X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcommon%2Fcliparser.cpp;h=726030388fc4f233e0729e801b08021d471dc6eb;hp=fc29f0e54aab3577d7000397729052ceea049be1;hb=16f22647e6890d3eb8c3e94f7a0700e12fa29e44;hpb=b3a2bd9e7d829afca26c6ab3ea09dfc6490319ce diff --git a/src/common/cliparser.cpp b/src/common/cliparser.cpp index fc29f0e5..72603038 100644 --- a/src/common/cliparser.cpp +++ b/src/common/cliparser.cpp @@ -1,5 +1,5 @@ /*************************************************************************** - * Copyright (C) 2005-08 by the Quassel IRC Team * + * Copyright (C) 2005-2016 by the Quassel Project * * devel@quassel-irc.org * * * * This program is free software; you can redistribute it and/or modify * @@ -15,183 +15,226 @@ * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * - * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * ***************************************************************************/ + #include "cliparser.h" +#include +#include #include #include -CliParser::CliParser(QStringList arguments) +#include + +CliParser::CliParser() : AbstractCliParser() { - argsRaw = arguments; } -void CliParser::addSwitch(QString longName, char shortName, QVariant def) { - addArgument(CliParserArg::CliArgSwitch, longName, shortName, def); -} -void CliParser::addOption(QString longName, char shortName, QVariant def) { - addArgument(CliParserArg::CliArgOption, longName, shortName, def); +void CliParser::addArgument(const QString &longName, const CliParserArg &arg) +{ + if (argsMap.contains(longName)) qWarning() << "Warning: Multiple definition of argument" << longName; + if (arg.shortName != 0 && !lnameOfShortArg(arg.shortName).isNull()) + qWarning().nospace() << "Warning: Redefining shortName '" << arg.shortName << "' for " << longName << " previously defined for " << lnameOfShortArg(arg.shortName); + argsMap.insert(longName, arg); } -void CliParser::addArgument(CliParserArg::CliArgType type, QString longName, char shortName, QVariant def) { - CliParserArg arg = CliParserArg(type, longName, shortName, def); - argsHash.insert(longName, arg); - if(shortName && !shortHash.contains(shortName)) shortHash.insert(shortName, argsHash.find(longName)); -} -void CliParser::addHelp(QString key, QString txt) { - if(argsHash.contains(key)) argsHash[key].shortHelp = txt; - else qWarning("Warning: Helptext for unknown argument '%s' given",key.toLatin1().constData()); +bool CliParser::addLongArg(const CliParserArg::CliArgType type, const QString &name, const QString &value) +{ + if (argsMap.contains(name)) { + if (type == CliParserArg::CliArgOption && argsMap.value(name).type == type) { + argsMap[name].value = escapedValue(value); + return true; + } + else if (type == CliParserArg::CliArgSwitch && argsMap.value(name).type == type) { + argsMap[name].boolValue = true; + return true; + } + } + qWarning() << "Warning: Unrecognized argument:" << name; + return false; } -bool CliParser::parse() { - QStringList::const_iterator currentArg; - for (currentArg = argsRaw.constBegin(); currentArg != argsRaw.constEnd(); ++currentArg) { - if(currentArg->startsWith("--")) { - QString name; - // long - if(currentArg->contains("=")) { - // option - QStringList tmp = currentArg->mid(2).split("="); - name = tmp.at(0); - QString value = tmp.at(1); - if(argsHash.contains(name) && !value.isEmpty()){ - argsHash[name].value = value; + +bool CliParser::addShortArg(const CliParserArg::CliArgType type, const char shortName, const QString &value) +{ + QString longName = lnameOfShortArg(shortName); + if (!longName.isNull()) { + if (type == CliParserArg::CliArgOption && argsMap.value(longName).type == type) { + argsMap[longName].value = escapedValue(value); + return true; } - else return false; - } - else { - // switch - name = currentArg->mid(2); - if(argsHash.contains(name)) { - argsHash[name].value = true; + else if (type == CliParserArg::CliArgSwitch) { + if (argsMap.value(longName).type == type) { + argsMap[longName].boolValue = true; + return true; + } + // arg is an option but detected as a switch -> argument is missing + else { + qWarning().nospace() << "Warning: '" << shortName << "' is an option which needs an argument"; + return false; + } } - else return false; - } } - else if(currentArg->startsWith("-")) { - char name; - // short - bool bla = true; - if(++currentArg == argsRaw.constEnd()) { - --currentArg; - bla = false; - } - // if next arg is a short/long option/switch the current arg is one too - if(currentArg->startsWith("-")) { - // switch - if(bla) --currentArg; - for (int i = 0; i < currentArg->mid(1).toAscii().size(); i++) { - name = currentArg->mid(1).toAscii().at(i); - if(shortHash.contains(name) && shortHash.value(name).value().type == CliParserArg::CliArgSwitch) { - shortHash[name].value().value = true; - } - else return false; + qWarning().nospace() << "Warning: Unrecognized argument: '" << shortName << "'"; + return false; +} + + +QString CliParser::escapedValue(const QString &value) +{ + QString escapedValue = value; + if (escapedValue.startsWith("~")) + escapedValue.replace(0, 1, QDir::homePath()); + + return escapedValue; +} + + +bool CliParser::init(const QStringList &args) +{ + argsRaw = args; + QStringList::const_iterator currentArg; + for (currentArg = argsRaw.constBegin(); currentArg != argsRaw.constEnd(); ++currentArg) { + if (currentArg->startsWith("--")) { + // long + QString name; + if (currentArg->contains("=")) { + // option + QStringList tmp = currentArg->mid(2).split("="); + name = tmp.at(0); + QString value; + // this is needed to allow --option="" + if (tmp.at(1).isNull()) value = QString(""); + else value = tmp.at(1); + if (!addLongArg(CliParserArg::CliArgOption, name, value)) return false; + } + else { + // switch + name = currentArg->mid(2); + if (!addLongArg(CliParserArg::CliArgSwitch, name)) return false; + } } - } - // if next arg is is no option/switch it's an argument to a shortoption - else { - // option - QString value = currentArg->toUtf8(); - if(bla) --currentArg; - name = currentArg->mid(1).toAscii().at(0); - if(bla) currentArg++; - if(shortHash.contains(name) && shortHash.value(name).value().type == CliParserArg::CliArgOption) { - shortHash[name].value().value = value; + else if (currentArg->startsWith("-")) { + // short + char name; + QStringList::const_iterator nextArg = currentArg+1; + // if next arg is a short/long option/switch the current arg is one too + if (nextArg == argsRaw.constEnd() || nextArg->startsWith("-")) { + // switch + for (int i = 0; i < currentArg->mid(1).toLatin1().size(); i++) { + name = currentArg->mid(1).toLatin1().at(i); + if (!addShortArg(CliParserArg::CliArgSwitch, name)) return false; + } + } + // if next arg is is no option/switch it's an argument to a shortoption + else { + // option + // short options are not freely mixable with other shortargs + if (currentArg->mid(1).toLatin1().size() > 1) { + qWarning() << "Warning: Shortoptions may not be combined with other shortoptions or switches"; + return false; + } + QString value; + bool skipNext = false; + if (nextArg != argsRaw.constEnd()) { + value = nextArg->toLocal8Bit(); + skipNext = true; + } + else value = currentArg->toLocal8Bit(); + name = currentArg->mid(1).toLatin1().at(0); + // we took one argument as argument to an option so skip it next time + if (skipNext) ++currentArg; + if (!addShortArg(CliParserArg::CliArgOption, name, value)) return false; + } + } + else { + // we don't support plain arguments without -/-- + if (currentArg->toLatin1() != argsRaw.at(0)) return false; } - else return false; - } - } - else { - // we don't support plain arguments without -/-- - if(currentArg->toLatin1() != argsRaw.at(0)) { - return false; - } } - } - return true; + return true; } -void CliParser::usage() { - qWarning("Usage: %s [arguments]",QFileInfo(argsRaw.at(0)).completeBaseName().toLatin1().constData()); - - // get size of longName field - QStringList keys = argsHash.keys(); - uint lnameFieldSize = 0; - foreach (QString key, keys) { - uint size = 0; - if(argsHash.value(key).type == CliParserArg::CliArgOption) - size += key.size()*2; - else - size += key.size(); - // this is for " --...=[....] " - size += 8; - if(size > lnameFieldSize) lnameFieldSize = size; - } - - QHash::const_iterator arg; - for(arg = argsHash.constBegin(); arg != argsHash.constEnd(); ++arg) { - QString output; - QString lnameField; - - if(arg.value().sname) { - output.append(" -").append(arg.value().sname).append(","); + +void CliParser::usage() +{ + std::cout << "Usage: " << qPrintable(QFileInfo(argsRaw.at(0)).completeBaseName()) << " [arguments]" << std::endl; + + // get size of longName field + QStringList keys = argsMap.keys(); + uint lnameFieldSize = 0; + foreach(QString key, keys) { + uint size = 0; + if (argsMap.value(key).type == CliParserArg::CliArgOption) + size += key.size()*2; + else + size += key.size(); + // this is for " --...=[....] " + size += 8; + if (size > lnameFieldSize) lnameFieldSize = size; } - else output.append(" "); - lnameField.append(" --").append(arg.key().toLatin1().constData()); - if(arg.value().type == CliParserArg::CliArgOption) { - lnameField.append("=[").append(arg.value().lname.toUpper()).append("]"); + + QMap::const_iterator arg; + for (arg = argsMap.constBegin(); arg != argsMap.constEnd(); ++arg) { + QString output; + QString lnameField; + + if (arg.value().shortName) { + output.append(" -").append(arg.value().shortName).append(","); + } + else output.append(" "); + lnameField.append(" --").append(arg.key()); + if (arg.value().type == CliParserArg::CliArgOption && !arg.value().valueName.isEmpty()) { + lnameField.append("=<").append(arg.value().valueName).append(">"); + } + output.append(lnameField.leftJustified(lnameFieldSize)); + if (!arg.value().help.isEmpty()) { + output.append(arg.value().help); + } + if (arg.value().type == CliParserArg::CliArgOption && !arg.value().def.isNull()) { + output.append(". Default is: ").append(arg.value().def); + } + std::cout << qPrintable(output) << std::endl; } - output.append(lnameField.leftJustified(lnameFieldSize)); - if(!arg.value().shortHelp.isEmpty()) { - output.append(arg.value().shortHelp); +} + + +QString CliParser::value(const QString &longName) +{ + if (argsMap.contains(longName) && argsMap.value(longName).type == CliParserArg::CliArgOption) { + if (!argsMap.value(longName).value.isNull()) + return argsMap.value(longName).value; + else + return argsMap.value(longName).def; } - if(arg.value().type == CliParserArg::CliArgOption) { - output.append(". Default is: ").append(arg.value().def.toString()); + else { + qWarning() << "Warning: Requested value of not defined argument" << longName << "or argument is a switch"; + return QString(); } - qWarning(output.toLatin1()); - } } -QVariant CliParser::value(QString key) { - if(argsHash.contains(key)) { - if(argsHash.value(key).value.isValid()) - return argsHash.value(key).value; - else - return argsHash.value(key).def; - } - else { - qWarning("Warning: Requested value of not defined argument '%s'",key.toLatin1().constData()); - return QVariant(); - } -} -CliParserArg::CliParserArg(CliArgType _type, QString longName, char shortName, QVariant _def) - : type(_type), - lname(longName), - sname(shortName), - shortHelp(QString()), - def(_def), - value(QVariant()) { +bool CliParser::isSet(const QString &longName) +{ + if (argsMap.contains(longName)) { + if (argsMap.value(longName).type == CliParserArg::CliArgOption) return !argsMap.value(longName).value.isNull(); + else return argsMap.value(longName).boolValue; + } + else { + qWarning() << "Warning: Requested isSet of not defined argument" << longName; + return false; + } } -CliParserArg::CliParserArg(const CliParserArg &other) { - type = other.type; - lname = other.lname; - sname = other.sname; - shortHelp = other.shortHelp; - def = other.def; - value = other.value; -} -CliParserArg &CliParserArg::operator=(const CliParserArg &other) { - type = other.type; - lname = other.lname; - sname = other.sname; - shortHelp = other.shortHelp; - def = other.def; - value = other.value; - return *this; +QString CliParser::lnameOfShortArg(const char arg) +{ + QMap::const_iterator cur; + for (cur = argsMap.constBegin(); cur != argsMap.constEnd(); ++cur) { + if (cur.value().shortName == arg) return cur.key(); + } + return QString(); }