Analysieren von Befehlszeilenoptionen mit mehreren Argumenten [getopt?]

Ich brauche mein Programm, um mehrere Argumente von der Befehlszeile zu erhalten, die Syntax lautet wie folgt:

getpwd -l user1 user2 ... -L -X -S...

Also muss ich die Benutzer dahinter bringen -l Möglichkeit. Ich habe versucht, mit getoptaber ohne viel Glück funktioniert es nur, wenn ich die anderen Optionen vor die setze -l:

getpwd -L -X -S ... -l user1 user2 ...

Mein Code (z -l und -S):

    while((c = getopt(argc, argv, "l:S")) != -1){
    switch(c){
        case 'l':
            index = optind-1;
            while(index < argc){
                next = strdup(argv[index]); /* get login */
                index++;
                if(next[0] != '-'){         /* check if optarg is next switch */
                    login[lcount++] = next;
                }
                else break;
            }
            break;
        case 'S':
            sflag++;                        /* other option */
            break;
        case ':':                           /* error - missing operand */
            fprintf(stderr, "Option -%c requires an operand\n", optopt);
            break;
        case '?':                           /* error - unknown option */
            fprintf(stderr,"Unrecognized option: -%c\n", optopt);
            break;
      }
   }

optopt und optind sind extern int.

Die Frage ist also: Kann ich die verwenden getopt() Funktion (bzw getopt_long()) ? Oder muss ich meinen eigenen Parser schreiben, um das zu bekommen, was ich brauche?

Ihr Code war eigentlich sehr, sehr nahe an der Arbeit. Das einzige, was dir gefehlt hat, ist das getopt erwartet nur, dass Sie danach ein Argument verbrauchen -lund setzt daher die Befehlszeilenanalyse nach dem ersten Argument bis fort -l. Da Sie hinter seinen Rücken gehen und mehr Argumente abziehen, müssen Sie es sagen getopt wo die Befehlszeile erneut analysiert werden soll.

getopt speichert diese Informationen in der globalen Variablen optind. Als ich die Zeile hinzugefügt habe:

optind = index - 1;

Vor dem break; in deiner l Fall begann Ihr Code zu arbeiten.

Ich habe eine C-Bibliothek (GPL-Lizenz) zum Analysieren von Befehlszeilenargumenten geschrieben:

https://github.com/Vincenzo1968/myoptParser

https://github.com/Vincenzo1968/myoptParser/blob/master/how_to_use.md

Sie können die minimale und maximale Anzahl von Argumenten angeben, die diese Option akzeptiert. Sie können auch angeben, dass eine Option null oder mehr Argumente akzeptiert (oder ein oder mehr, zwei oder mehr usw.). Und natürlich können Sie eine feste Anzahl von Argumenten angeben: null, eins, zwei und so weiter.

Sie können auch den Typ der Argumente angeben: String, Integer oder Float. Der Parser prüft, ob die angegebene Zahl und der angegebene Typ übereinstimmen, und gibt andernfalls einen Fehler zurück.

Mit dem Parser können Sie auch angeben, ob eine Option erforderlich ist oder nicht. Schließlich können Sie die sich gegenseitig ausschließenden Optionen angeben.

Die folgende Funktion generiert ein argc, argv-Paar für eine einzelne Option innerhalb einer Argumentliste:

void GetArgsList (int argc, char *argv[], int* o_argc, char*** o_argv)
{
    char** ret = NULL;
    int i;
    int count = 0;

    for (i = optind - 1; i < argc ; ++i)
    {
        if (argv[i][0]=='-')
        {
            break;
        }
        else
        {
            if (NULL == ret)
            {
                ret = &argv[i];
            }
            count++;
        }
    }

    optind = i - 1;

    if (o_argc)
    {
        *o_argc = count;
    }

    *o_argv = ret;
}