Analizator wiersza polecenia dla Qt4

Question

Szukam parsera wiersza poleceń dla Qt4.

Zrobiłem małe wyszukiwanie google i okazało się, że: http://www.froglogic.com/pg?id=PublicationsFreeware&category=getopt jednak brakuje w nim obsługi przełączników "--enable-foo" i "--disable-foo". Poza tym wygląda na prawdziwego zwycięzcę.

EDIT:

Wydaje Frologic usunięte to. Najlepsze opcje, jakie widzę, to użycie funkcji Boost (która nie jest API ani stabilna ABI) lub rozwidlenie obsługi kdelibs. Yay ...

Answer 1

Od Qt 5.2 możesz w końcu znaleźć rozwiązanie w samym QtCore: dostarczyłem tam QCommandLineParser.

Answer 2

Czy musi to być specyfikacja Qt4? Jeśli nie, GNU Getopt jest naprawdę niezły, chociaż licencjonowanie może stanowić problem, jeśli nie korzystasz z oprogramowania open source.

Answer 3

Ten pakiet obsługuje -disable-foo i -enable-foo przez opts.addSwitch ("disable-foo", & foo_disabled); i opts.addSwitch ("enable-foo", & foo_enabled);. Musisz obsłużyć sprawdzanie obu i radzenie sobie z osobą określającą oba (oops).

Co ja nie rozumiem, w jaki sposób ma to nic wspólnego z QT4 ...

Answer 4

QCoreApplication's constructors wymagają (int &argc, char **argv) (i QApplication dziedziczy QCoreApplication). Jako documentation states, jest wysoce zalecane,

Od QApplication zajmuje się również linia argumentacji wspólnego dowodzenia, to zwykle dobry pomysł, aby go utworzyć przed żadnej interpretacji lub modyfikacja argv odbywa się w samej aplikacji.

A jeśli pozwalając Qt dostać pierwszego przejścia na obsługę argumentów jakikolwiek byłoby również dobrym pomysłem jest użycie QStringList QCoreApplication::arguments() zamiast chodząc argv; QApplication może usunąć niektóre z argumentów, które podjął dla własnego użytku.

ten nie nadaje się do bycia bardzo kompatybilny z innymi bibliotekami argumentów-parsowania ...

Jednak kdelibs nie pochodzi z ładnym parsera argument KCmdLineArgs. Jest to LGPL i może być używany bez KApplication, jeśli naprawdę chcesz (zadzwoń pod numer KCmdLineArgs::init).

KCmdLineOptions options; 
options.add("enable-foo", ki18n("enables foo")); 
options.add("nodisable-foo", ki18n("disables foo")); 
// double negatives are confusing, but this makes disable-foo enabled by default 

KCmdLineArgs::addCmdLineOptions(options); 
KApplication app; 
KCmdLineArgs *args = KCmdLineArgs::parsedArgs(); 

if (args->isSet("enable-foo") && !args->isSet("disable-foo")) 
    cout << "foo enabled" << endl; 
else 
    cout << "foo disabled" << endl; 

Nienormowany (kto kiedykolwiek przetestuje to, co pisze na S.O.?).

Answer 5

bardzo prosty sposób jest skanowanie „klucz = wartość” args,
umieścić je w tabeli powiedzieć zz.map: QString -> QVariant,
i uzyskać ich wartości z zz.map.value (klucz, domyślna). Przykład:

#include "ztest.h" 
Ztest zz; 
int main(int argc, char* argv[]) 
{ 
    zz.eqargs(++ argv); // scan test=2 x=str ... to zz.map 

    QString xx = zz.map.value("xx", ""); 
    if(Zint(Size, 10)) // a #def -> zz.map.value("Size", 10) 
     ... 

ztest.h jest < 1 stronie, poniżej; to samo dla Pythona ~ 10 linii.

(Każdy ma swój ulubiony parser opcji; ten jest najprostszy.
warto powtarzać: jednak określić opcje, echo ich do plików wyjściowych -
„każdy naukowiec wiem, ma problemy z utrzymaniem toru co Parametry używali ostatnim razem pobiegli skrypt”)

TO. sprawić, że QPoints itp. działają, oczywiście, potrzebuje parsera QString -> QPoint. Ktoś wie od ręki, dlaczego to nie działa (w Qt 4.4.3)?

QPoint pt(0,0); 
QDataStream s("QPoint(1,2)"); 
s >> pt; 
qDebug() << "pt:" << pt; // QPoint(1364225897,1853106225) ?? 

Dodany 25nov -

// ztest.h: scan args x=2 s=str ... to a key -> string table 
// usage: 
// Ztest ztest; 
// int main(int argc, char* argv[]) 
// { 
//  QApplication app(argc, argv); 
//  ztest.eqargs(++ argv); // scan leading args name=value ... 
//  int x = Zint(x, 10); // arg x= or default 10 
//  qreal ff = Zreal(ff, 3.14); 
//  QString s = Zstr(s, "default"); 
// care: int misspelled = Zint(misspellled) -- you lose 
//version: 2009-06-09 jun denis 

#ifndef ztest_h 
#define ztest_h 

#include <QHash> 
#include <QString> 
#include <QVariant> 
#include <QRegExp> 

//------------------------------------------------------------------------------ 
class Ztest { 
public: 
    QHash< QString, QVariant > map; 
    int test; // arg test=num, if(ztest.test) 

    Ztest() : test(0) {} 

    QVariant val(const QString& key, const QVariant& default_ = 0) 
    { 
    return map.value(key, default_); 
    } 

    void setval(const QString& key, const QVariant& val) 
    { 
    map[key] = val; 
    if(key == "test" || key == "Test") 
     test = val.toInt(); 
    } 

//------------------------------------------------------------------------------ 
    // ztest.eqargs(++ argv) scans test=2 x=3 ... -> ztest table 
    void eqargs(char** argv) 
    { 
    char** argv0 = argv; 
    char *arg; 
    QRegExp re("(\\w+)=(.*)"); // name= anything, but not ./file=name 
    for(; (arg = *argv) && re.exactMatch(arg); argv ++){ 
     setval(re.cap(1), re.cap(2)); 
    } 
     // change argv[0..] -> args after all name=values 
    while((*argv0++ = *argv++) != 0) {} 
    } 
}; 

extern Ztest ztest; 

    // macros: int x = Zint(x, 10): x= arg or default 10 
#define Zstr(key, default) ztest.val(#key, default).toString() 
#define Zint(key, default) ztest.val(#key, default).toInt() 
#define Zreal(key, default) ztest.val(#key, default).toDouble() 

#endif 

Answer 6

Również niektóre fantazyjne opcje analizowania można spróbować gperf.

IBM ma na sobie ładny tutorial.

Answer 7

Spójrz na to: http://code.google.com/p/qtargparser/

Answer 8

Inną opcją natknąłem się patrząc na to, zbyt:

http://code.google.com/p/qgetopts/

Nie używałem go jednak.

Answer 9

Istnieje również QxtCommandOptions z http://www.libqxt.org/

Answer 10

To jest mniej więcej taka sama odpowiedź jak ephemient, ale z prostym regexp pomóc analizować args. (W ten sposób może być przydatna, gdy trzeba tylko garść args)

Run z tym:

./QArgTest --pid=45 --enable-foo 

I kod:

int main(int argc, char *argv[]) { 
    QApplication app(argc, argv, false); 
    qDebug() << "QApp arg test app"; 

    QStringList args = app.arguments(); 

    int pid = 0; 

    QRegExp rxArgPid("--pid=([0-9]{1,})"); 
    QRegExp rxArgFooEna("--enable-foo"); 
    QRegExp rxArgFooDis("--disable-foo"); 

    for (int i = 1; i < args.size(); ++i) { 
     if (rxArgPid.indexIn(args.at(i)) != -1) { 
      pid = rxArgPid.cap(1).toInt(); 
      qDebug() << i << ":" << args.at(i) << rxArgPid.cap(1) << pid; 
     } 
     else if (rxArgFooEna.indexIn(args.at(i)) != -1) { 
      qDebug() << i << ":" << args.at(i) << "Enable Foo"; 
     } 
     else if (rxArgFooDis.indexIn(args.at(i)) != -1) { 
      qDebug() << i << ":" << args.at(i) << "Disable Foo"; 
     } 
     else { 
      qDebug() << "Uknown arg:" << args.at(i); 
     } 
    } 
    return 0; 
} 

Answer 11

To 2013 i nadal nie ma "1st Party" arg parser. Anyways..if ktoś znajdzie się w obliczu tego samego problemu i chciałby uniknąć krzywe uczenia się, które pochodzą z bibliotekami parsera cmd, tutaj jest „szybkie & brudne” fix dla Ciebie: -

QString QArgByKey(QString key, QChar sep = QChar('\0')) //prototype usually in separate header 

QString QArgByKey(QString key, QChar sep) 
{ 
    bool sepd=sep!=QChar('\0'); 
    int pos=sepd?qApp->arguments().indexOf(QRegExp('^'+key+sep+"\\S*")):qApp->arguments().indexOf(QRegExp(key)); 
    return pos==-1?QString::null: 
    (sepd?qApp->arguments().at(pos).split(sep).at(1):(++pos<qApp->arguments().size()?qApp->arguments().at(pos):QString::null)); 
} 

Przykład: -

user@box:~$ ./myApp firstKey=Value1 --secondKey Value2 thirdKey=val3.1,val3.2,val3.3 --enable-foo 

Zastosowanie:

QString param1 = QArgByKey("firstkey",'='); // Returns `Value1` from first pair 
QString param2 = QArgByKey("--secondkey"); // Returns `Value2` from second pair 
QString param3-1 = QArgByKey("thirdkey",'=').split(',').at(0); // Returns `val3.1` 
bool fooEnabled = qApp->arguments().contains("--enable-foo"); //To check for `--enable-foo` 

Params mogą być przekazywane w dowolnej kolejności

Edytuj: Uaktualnienia do tego fragmentu będą następujące: found here