pollymc/api/logic/Commandline.cpp

483 lines
13 KiB
C++
Raw Normal View History

2018-02-11 05:10:01 +05:30
/* Copyright 2013-2018 MultiMC Contributors
2013-02-20 04:37:52 +05:30
*
* Authors: Orochimarufan <orochimarufan.x3@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
2015-10-05 05:17:27 +05:30
#include "Commandline.h"
2013-02-20 04:37:52 +05:30
/**
* @file libutil/src/cmdutils.cpp
2013-02-20 04:37:52 +05:30
*/
namespace Commandline
{
2013-02-20 04:37:52 +05:30
// commandline splitter
QStringList splitArgs(QString args)
{
2018-07-15 18:21:05 +05:30
QStringList argv;
QString current;
bool escape = false;
QChar inquotes;
for (int i = 0; i < args.length(); i++)
{
QChar cchar = args.at(i);
// \ escaped
if (escape)
{
current += cchar;
escape = false;
// in "quotes"
}
else if (!inquotes.isNull())
{
if (cchar == '\\')
escape = true;
else if (cchar == inquotes)
inquotes = 0;
else
current += cchar;
// otherwise
}
else
{
if (cchar == ' ')
{
if (!current.isEmpty())
{
argv << current;
current.clear();
}
}
else if (cchar == '"' || cchar == '\'')
inquotes = cchar;
else
current += cchar;
}
}
if (!current.isEmpty())
argv << current;
return argv;
}
2013-02-26 02:14:36 +05:30
Parser::Parser(FlagStyle::Enum flagStyle, ArgumentStyle::Enum argStyle)
2013-02-20 04:37:52 +05:30
{
2018-07-15 18:21:05 +05:30
m_flagStyle = flagStyle;
m_argStyle = argStyle;
2013-02-20 04:37:52 +05:30
}
// styles setter/getter
2013-02-26 02:14:36 +05:30
void Parser::setArgumentStyle(ArgumentStyle::Enum style)
2013-02-20 04:37:52 +05:30
{
2018-07-15 18:21:05 +05:30
m_argStyle = style;
2013-02-20 04:37:52 +05:30
}
2013-02-26 02:14:36 +05:30
ArgumentStyle::Enum Parser::argumentStyle()
2013-02-20 04:37:52 +05:30
{
2018-07-15 18:21:05 +05:30
return m_argStyle;
2013-02-20 04:37:52 +05:30
}
2013-02-26 02:14:36 +05:30
void Parser::setFlagStyle(FlagStyle::Enum style)
2013-02-20 04:37:52 +05:30
{
2018-07-15 18:21:05 +05:30
m_flagStyle = style;
2013-02-20 04:37:52 +05:30
}
2013-02-26 02:14:36 +05:30
FlagStyle::Enum Parser::flagStyle()
2013-02-20 04:37:52 +05:30
{
2018-07-15 18:21:05 +05:30
return m_flagStyle;
2013-02-20 04:37:52 +05:30
}
// setup methods
void Parser::addSwitch(QString name, bool def)
2013-02-20 04:37:52 +05:30
{
2018-07-15 18:21:05 +05:30
if (m_params.contains(name))
throw "Name not unique";
OptionDef *param = new OptionDef;
param->type = otSwitch;
param->name = name;
param->metavar = QString("<%1>").arg(name);
param->def = def;
m_options[name] = param;
m_params[name] = (CommonDef *)param;
m_optionList.append(param);
2013-02-20 04:37:52 +05:30
}
void Parser::addOption(QString name, QVariant def)
2013-02-20 04:37:52 +05:30
{
2018-07-15 18:21:05 +05:30
if (m_params.contains(name))
throw "Name not unique";
OptionDef *param = new OptionDef;
param->type = otOption;
param->name = name;
param->metavar = QString("<%1>").arg(name);
param->def = def;
m_options[name] = param;
m_params[name] = (CommonDef *)param;
m_optionList.append(param);
2013-02-20 04:37:52 +05:30
}
void Parser::addArgument(QString name, bool required, QVariant def)
2013-02-20 04:37:52 +05:30
{
2018-07-15 18:21:05 +05:30
if (m_params.contains(name))
throw "Name not unique";
2018-07-15 18:21:05 +05:30
PositionalDef *param = new PositionalDef;
param->name = name;
param->def = def;
param->required = required;
param->metavar = name;
2018-07-15 18:21:05 +05:30
m_positionals.append(param);
m_params[name] = (CommonDef *)param;
2013-02-20 04:37:52 +05:30
}
void Parser::addDocumentation(QString name, QString doc, QString metavar)
2013-02-20 04:37:52 +05:30
{
2018-07-15 18:21:05 +05:30
if (!m_params.contains(name))
throw "Name does not exist";
2018-07-15 18:21:05 +05:30
CommonDef *param = m_params[name];
param->doc = doc;
if (!metavar.isNull())
param->metavar = metavar;
2013-02-20 04:37:52 +05:30
}
void Parser::addShortOpt(QString name, QChar flag)
2013-02-20 04:37:52 +05:30
{
2018-07-15 18:21:05 +05:30
if (!m_params.contains(name))
throw "Name does not exist";
if (!m_options.contains(name))
throw "Name is not an Option or Swtich";
OptionDef *param = m_options[name];
m_flags[flag] = param;
param->flag = flag;
2013-02-20 04:37:52 +05:30
}
// help methods
QString Parser::compileHelp(QString progName, int helpIndent, bool useFlags)
{
2018-07-15 18:21:05 +05:30
QStringList help;
help << compileUsage(progName, useFlags) << "\r\n";
// positionals
if (!m_positionals.isEmpty())
{
help << "\r\n";
help << "Positional arguments:\r\n";
QListIterator<PositionalDef *> it2(m_positionals);
while (it2.hasNext())
{
PositionalDef *param = it2.next();
help << " " << param->metavar;
help << " " << QString(helpIndent - param->metavar.length() - 1, ' ');
help << param->doc << "\r\n";
}
}
// Options
if (!m_optionList.isEmpty())
{
help << "\r\n";
QString optPrefix, flagPrefix;
getPrefix(optPrefix, flagPrefix);
help << "Options & Switches:\r\n";
QListIterator<OptionDef *> it(m_optionList);
while (it.hasNext())
{
OptionDef *option = it.next();
help << " ";
int nameLength = optPrefix.length() + option->name.length();
if (!option->flag.isNull())
{
nameLength += 3 + flagPrefix.length();
help << flagPrefix << option->flag << ", ";
}
help << optPrefix << option->name;
if (option->type == otOption)
{
QString arg = QString("%1%2").arg(
((m_argStyle == ArgumentStyle::Equals) ? "=" : " "), option->metavar);
nameLength += arg.length();
help << arg;
}
help << " " << QString(helpIndent - nameLength - 1, ' ');
help << option->doc << "\r\n";
}
}
return help.join("");
2013-02-20 04:37:52 +05:30
}
QString Parser::compileUsage(QString progName, bool useFlags)
{
2018-07-15 18:21:05 +05:30
QStringList usage;
usage << "Usage: " << progName;
QString optPrefix, flagPrefix;
getPrefix(optPrefix, flagPrefix);
// options
QListIterator<OptionDef *> it(m_optionList);
while (it.hasNext())
{
OptionDef *option = it.next();
usage << " [";
if (!option->flag.isNull() && useFlags)
usage << flagPrefix << option->flag;
else
usage << optPrefix << option->name;
if (option->type == otOption)
usage << ((m_argStyle == ArgumentStyle::Equals) ? "=" : " ") << option->metavar;
usage << "]";
}
// arguments
QListIterator<PositionalDef *> it2(m_positionals);
while (it2.hasNext())
{
PositionalDef *param = it2.next();
usage << " " << (param->required ? "<" : "[");
usage << param->metavar;
usage << (param->required ? ">" : "]");
}
return usage.join("");
2013-02-20 04:37:52 +05:30
}
// parsing
QHash<QString, QVariant> Parser::parse(QStringList argv)
2013-02-20 04:37:52 +05:30
{
2018-07-15 18:21:05 +05:30
QHash<QString, QVariant> map;
2018-07-15 18:21:05 +05:30
QStringListIterator it(argv);
QString programName = it.next();
2018-07-15 18:21:05 +05:30
QString optionPrefix;
QString flagPrefix;
QListIterator<PositionalDef *> positionals(m_positionals);
QStringList expecting;
2018-07-15 18:21:05 +05:30
getPrefix(optionPrefix, flagPrefix);
2018-07-15 18:21:05 +05:30
while (it.hasNext())
{
QString arg = it.next();
2018-07-15 18:21:05 +05:30
if (!expecting.isEmpty())
// we were expecting an argument
{
QString name = expecting.first();
/*
2018-07-15 18:21:05 +05:30
if (map.contains(name))
throw ParsingError(
QString("Option %2%1 was given multiple times").arg(name, optionPrefix));
*/
2018-07-15 18:21:05 +05:30
map[name] = QVariant(arg);
expecting.removeFirst();
continue;
}
if (arg.startsWith(optionPrefix))
// we have an option
{
// qDebug("Found option %s", qPrintable(arg));
QString name = arg.mid(optionPrefix.length());
QString equals;
if ((m_argStyle == ArgumentStyle::Equals ||
m_argStyle == ArgumentStyle::SpaceAndEquals) &&
name.contains("="))
{
int i = name.indexOf("=");
equals = name.mid(i + 1);
name = name.left(i);
}
if (m_options.contains(name))
{
/*
if (map.contains(name))
throw ParsingError(QString("Option %2%1 was given multiple times")
.arg(name, optionPrefix));
*/
2018-07-15 18:21:05 +05:30
OptionDef *option = m_options[name];
if (option->type == otSwitch)
map[name] = true;
else // if (option->type == otOption)
{
if (m_argStyle == ArgumentStyle::Space)
expecting.append(name);
else if (!equals.isNull())
map[name] = equals;
else if (m_argStyle == ArgumentStyle::SpaceAndEquals)
expecting.append(name);
else
throw ParsingError(QString("Option %2%1 reqires an argument.")
.arg(name, optionPrefix));
}
continue;
}
throw ParsingError(QString("Unknown Option %2%1").arg(name, optionPrefix));
}
if (arg.startsWith(flagPrefix))
// we have (a) flag(s)
{
// qDebug("Found flags %s", qPrintable(arg));
QString flags = arg.mid(flagPrefix.length());
QString equals;
if ((m_argStyle == ArgumentStyle::Equals ||
m_argStyle == ArgumentStyle::SpaceAndEquals) &&
flags.contains("="))
{
int i = flags.indexOf("=");
equals = flags.mid(i + 1);
flags = flags.left(i);
}
for (int i = 0; i < flags.length(); i++)
{
QChar flag = flags.at(i);
if (!m_flags.contains(flag))
throw ParsingError(QString("Unknown flag %2%1").arg(flag, flagPrefix));
OptionDef *option = m_flags[flag];
/*
2018-07-15 18:21:05 +05:30
if (map.contains(option->name))
throw ParsingError(QString("Option %2%1 was given multiple times")
.arg(option->name, optionPrefix));
*/
2018-07-15 18:21:05 +05:30
if (option->type == otSwitch)
map[option->name] = true;
else // if (option->type == otOption)
{
if (m_argStyle == ArgumentStyle::Space)
expecting.append(option->name);
else if (!equals.isNull())
if (i == flags.length() - 1)
map[option->name] = equals;
else
throw ParsingError(QString("Flag %4%2 of Argument-requiring Option "
"%1 not last flag in %4%3")
.arg(option->name, flag, flags, flagPrefix));
else if (m_argStyle == ArgumentStyle::SpaceAndEquals)
expecting.append(option->name);
else
throw ParsingError(QString("Option %1 reqires an argument. (flag %3%2)")
.arg(option->name, flag, flagPrefix));
}
}
continue;
}
// must be a positional argument
if (!positionals.hasNext())
throw ParsingError(QString("Don't know what to do with '%1'").arg(arg));
PositionalDef *param = positionals.next();
map[param->name] = arg;
}
// check if we're missing something
if (!expecting.isEmpty())
throw ParsingError(QString("Was still expecting arguments for %2%1").arg(
expecting.join(QString(", ") + optionPrefix), optionPrefix));
while (positionals.hasNext())
{
PositionalDef *param = positionals.next();
if (param->required)
throw ParsingError(
QString("Missing required positional argument '%1'").arg(param->name));
else
map[param->name] = param->def;
}
// fill out gaps
QListIterator<OptionDef *> iter(m_optionList);
while (iter.hasNext())
{
OptionDef *option = iter.next();
if (!map.contains(option->name))
map[option->name] = option->def;
}
return map;
2013-02-20 04:37:52 +05:30
}
// clear defs
2013-02-20 04:37:52 +05:30
void Parser::clear()
{
2018-07-15 18:21:05 +05:30
m_flags.clear();
m_params.clear();
m_options.clear();
QMutableListIterator<OptionDef *> it(m_optionList);
while (it.hasNext())
{
OptionDef *option = it.next();
it.remove();
delete option;
}
QMutableListIterator<PositionalDef *> it2(m_positionals);
while (it2.hasNext())
{
PositionalDef *arg = it2.next();
it2.remove();
delete arg;
}
2013-02-20 04:37:52 +05:30
}
// Destructor
2013-02-20 04:37:52 +05:30
Parser::~Parser()
{
2018-07-15 18:21:05 +05:30
clear();
2013-02-20 04:37:52 +05:30
}
// getPrefix
2013-02-20 04:37:52 +05:30
void Parser::getPrefix(QString &opt, QString &flag)
{
2018-07-15 18:21:05 +05:30
if (m_flagStyle == FlagStyle::Windows)
opt = flag = "/";
else if (m_flagStyle == FlagStyle::Unix)
opt = flag = "-";
// else if (m_flagStyle == FlagStyle::GNU)
else
{
opt = "--";
flag = "-";
}
2013-02-20 04:37:52 +05:30
}
// ParsingError
ParsingError::ParsingError(const QString &what) : std::runtime_error(what.toStdString())
2013-02-20 04:37:52 +05:30
{
}
2015-10-05 05:17:27 +05:30
}