src/common/cliparser.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005-09 by the Quassel Project                          *
   3  *   devel@quassel-irc.org                                                 *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) version 3.                                           *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20 #include "cliparser.h"
  21
  22 #include <QDir>
  23 #include <QDebug>
  24 #include <QString>
  25 #include <QFileInfo>
  26
  27 #include <iostream>
  28
  29 CliParser::CliParser() : AbstractCliParser()
  30 {
  31 }
  32
  33
  34 void CliParser::addArgument(const QString &longName_, const CliParserArg &arg)
  35 {
  36     QString longName = longName_;
  37     longName.remove(QRegExp("\\s*<.*>\\s*")); // KCmdLineArgs takes args of the form "arg <defval>"
  38     if (argsMap.contains(longName)) qWarning() << "Warning: Multiple definition of argument" << longName;
  39     if (arg.shortName != 0 && !lnameOfShortArg(arg.shortName).isNull())
  40         qWarning().nospace() << "Warning: Redefining shortName '" << arg.shortName << "' for " << longName << " previously defined for " << lnameOfShortArg(arg.shortName);
  41     argsMap.insert(longName, arg);
  42 }
  43
  44
  45 bool CliParser::addLongArg(const CliParserArg::CliArgType type, const QString &name, const QString &value)
  46 {
  47     if (argsMap.contains(name)) {
  48         if (type == CliParserArg::CliArgOption && argsMap.value(name).type == type) {
  49             argsMap[name].value = escapedValue(value);
  50             return true;
  51         }
  52         else if (type == CliParserArg::CliArgSwitch && argsMap.value(name).type == type) {
  53             argsMap[name].boolValue = true;
  54             return true;
  55         }
  56     }
  57     qWarning() << "Warning: Unrecognized argument:" << name;
  58     return false;
  59 }
  60
  61
  62 bool CliParser::addShortArg(const CliParserArg::CliArgType type, const char shortName, const QString &value)
  63 {
  64     QString longName = lnameOfShortArg(shortName);
  65     if (!longName.isNull()) {
  66         if (type == CliParserArg::CliArgOption && argsMap.value(longName).type == type) {
  67             argsMap[longName].value = escapedValue(value);
  68             return true;
  69         }
  70         else if (type == CliParserArg::CliArgSwitch) {
  71             if (argsMap.value(longName).type == type) {
  72                 argsMap[longName].boolValue = true;
  73                 return true;
  74             }
  75             // arg is an option but detected as a switch -> argument is missing
  76             else {
  77                 qWarning().nospace() << "Warning: '" << shortName << "' is an option which needs an argument";
  78                 return false;
  79             }
  80         }
  81     }
  82     qWarning().nospace() << "Warning: Unrecognized argument: '" << shortName << "'";
  83     return false;
  84 }
  85
  86
  87 QString CliParser::escapedValue(const QString &value)
  88 {
  89     QString escapedValue = value;
  90     if (escapedValue.startsWith("~"))
  91         escapedValue.replace(0, 1, QDir::homePath());
  92
  93     return escapedValue;
  94 }
  95
  96
  97 bool CliParser::init(const QStringList &args)
  98 {
  99     argsRaw = args;
 100     QStringList::const_iterator currentArg;
 101     for (currentArg = argsRaw.constBegin(); currentArg != argsRaw.constEnd(); ++currentArg) {
 102         if (currentArg->startsWith("--")) {
 103             // long
 104             QString name;
 105             if (currentArg->contains("=")) {
 106                 // option
 107                 QStringList tmp = currentArg->mid(2).split("=");
 108                 name = tmp.at(0);
 109                 QString value;
 110                 // this is needed to allow --option=""
 111                 if (tmp.at(1).isNull()) value = QString("");
 112                 else value = tmp.at(1);
 113                 if (!addLongArg(CliParserArg::CliArgOption, name, value)) return false;
 114             }
 115             else {
 116                 // switch
 117                 name = currentArg->mid(2);
 118                 if (!addLongArg(CliParserArg::CliArgSwitch, name)) return false;
 119             }
 120         }
 121         else if (currentArg->startsWith("-")) {
 122             // short
 123             char name;
 124             QStringList::const_iterator nextArg = currentArg+1;
 125             // if next arg is a short/long option/switch the current arg is one too
 126             if (nextArg == argsRaw.constEnd() || nextArg->startsWith("-")) {
 127                 // switch
 128                 for (int i = 0; i < currentArg->mid(1).toAscii().size(); i++) {
 129                     name = currentArg->mid(1).toAscii().at(i);
 130                     if (!addShortArg(CliParserArg::CliArgSwitch, name)) return false;
 131                 }
 132             }
 133             // if next arg is is no option/switch it's an argument to a shortoption
 134             else {
 135                 // option
 136                 // short options are not freely mixable with other shortargs
 137                 if (currentArg->mid(1).toAscii().size() > 1) {
 138                     qWarning() << "Warning: Shortoptions may not be combined with other shortoptions or switches";
 139                     return false;
 140                 }
 141                 QString value;
 142                 bool skipNext = false;
 143                 if (nextArg != argsRaw.constEnd()) {
 144                     value = nextArg->toLocal8Bit();
 145                     skipNext = true;
 146                 }
 147                 else value = currentArg->toLocal8Bit();
 148                 name = currentArg->mid(1).toAscii().at(0);
 149                 // we took one argument as argument to an option so skip it next time
 150                 if (skipNext) currentArg++;
 151                 if (!addShortArg(CliParserArg::CliArgOption, name, value)) return false;
 152             }
 153         }
 154         else {
 155             // we don't support plain arguments without -/--
 156             if (currentArg->toLatin1() != argsRaw.at(0)) return false;
 157         }
 158     }
 159     return true;
 160 }
 161
 162
 163 void CliParser::usage()
 164 {
 165     std::cout << "Usage: " << qPrintable(QFileInfo(argsRaw.at(0)).completeBaseName()) << " [arguments]" << std::endl;
 166
 167     // get size of longName field
 168     QStringList keys = argsMap.keys();
 169     uint lnameFieldSize = 0;
 170     foreach(QString key, keys) {
 171         uint size = 0;
 172         if (argsMap.value(key).type == CliParserArg::CliArgOption)
 173             size += key.size()*2;
 174         else
 175             size += key.size();
 176         // this is for " --...=[....] "
 177         size += 8;
 178         if (size > lnameFieldSize) lnameFieldSize = size;
 179     }
 180
 181     QMap<QString, CliParserArg>::const_iterator arg;
 182     for (arg = argsMap.constBegin(); arg != argsMap.constEnd(); ++arg) {
 183         QString output;
 184         QString lnameField;
 185
 186         if (arg.value().shortName) {
 187             output.append(" -").append(arg.value().shortName).append(",");
 188         }
 189         else output.append("    ");
 190         lnameField.append(" --").append(arg.key());
 191         if (arg.value().type == CliParserArg::CliArgOption) {
 192             lnameField.append("=[").append(arg.key().toUpper()).append("]");
 193         }
 194         output.append(lnameField.leftJustified(lnameFieldSize));
 195         if (!arg.value().help.isEmpty()) {
 196             output.append(arg.value().help);
 197         }
 198         if (arg.value().type == CliParserArg::CliArgOption && !arg.value().def.isNull()) {
 199             output.append(". Default is: ").append(arg.value().def);
 200         }
 201         std::cout << qPrintable(output) << std::endl;
 202     }
 203 }
 204
 205
 206 QString CliParser::value(const QString &longName)
 207 {
 208     if (argsMap.contains(longName) && argsMap.value(longName).type == CliParserArg::CliArgOption) {
 209         if (!argsMap.value(longName).value.isNull())
 210             return argsMap.value(longName).value;
 211         else
 212             return argsMap.value(longName).def;
 213     }
 214     else {
 215         qWarning() << "Warning: Requested value of not defined argument" << longName << "or argument is a switch";
 216         return QString();
 217     }
 218 }
 219
 220
 221 bool CliParser::isSet(const QString &longName)
 222 {
 223     if (argsMap.contains(longName)) {
 224         if (argsMap.value(longName).type == CliParserArg::CliArgOption) return !argsMap.value(longName).value.isNull();
 225         else return argsMap.value(longName).boolValue;
 226     }
 227     else {
 228         qWarning() << "Warning: Requested isSet of not defined argument" << longName;
 229         return false;
 230     }
 231 }
 232
 233
 234 QString CliParser::lnameOfShortArg(const char arg)
 235 {
 236     QMap<QString, CliParserArg>::const_iterator cur;
 237     for (cur = argsMap.constBegin(); cur != argsMap.constEnd(); ++cur) {
 238         if (cur.value().shortName == arg) return cur.key();
 239     }
 240     return QString();
 241 }