String in argv/argc parsen

Gibt es in C eine Möglichkeit, ein Stück Text zu analysieren und Werte für argv und argc zu erhalten, als ob der Text auf der Befehlszeile an eine Anwendung übergeben worden wäre?

Dies muss nicht unter Windows funktionieren, sondern nur unter Linux – es ist mir auch egal, Argumente zu zitieren.

Ich bin überrascht, dass niemand die einfachste Antwort mit der Standard-POSIX-Funktionalität gegeben hat:

http://www.opengroup.org/onlinepubs/9699919799/functions/wordexp.html

Wenn die Glib-Lösung für Ihren Fall zu viel des Guten ist, können Sie erwägen, selbst eine zu programmieren.

Dann kannst du:

• scannen Sie die Zeichenfolge und zählen Sie, wie viele Argumente es gibt (und Sie erhalten Ihr argc)
• Weisen Sie ein Array von char * zu (für Ihr argv)
• Scannen Sie die Zeichenfolge erneut, weisen Sie die Zeiger im zugewiesenen Array zu und ersetzen Sie Leerzeichen durch ‘\0’ (wenn Sie die Zeichenfolge mit den Argumenten nicht ändern können, sollten Sie sie duplizieren).
• Vergessen Sie nicht, das freizugeben, was Sie zugewiesen haben!

Das folgende Diagramm sollte (hoffentlich) verdeutlichen:

             aa bbb ccc "dd d" ee         <- original string

             aa0bbb0ccc00dd d00ee0        <- transformed string
             |  |   |    |     |
   argv[0] __/  /   /    /     /
   argv[1] ____/   /    /     /
   argv[2] _______/    /     /
   argv[3] ___________/     /
   argv[4] ________________/ 

Eine mögliche API könnte sein:

    char **parseargs(char *arguments, int *argc);
    void   freeparsedargs(char **argv);

Sie müssen zusätzliche Überlegungen anstellen, um freeparsedargs() sicher zu implementieren.

Wenn Ihre Zeichenfolge sehr lang ist und Sie nicht zweimal scannen möchten, können Sie Alternativen in Betracht ziehen, z. B. mehr Elemente für die argv-Arrays zuweisen (und bei Bedarf neu zuweisen).

BEARBEITEN: Vorgeschlagene Lösung (behandelt das zitierte Argument nicht).

    #include <stdio.h>

    static int setargs(char *args, char **argv)
    {
       int count = 0;

       while (isspace(*args)) ++args;
       while (*args) {
         if (argv) argv[count] = args;
         while (*args && !isspace(*args)) ++args;
         if (argv && *args) *args++ = '\0';
         while (isspace(*args)) ++args;
         count++;
       }
       return count;
    }

    char **parsedargs(char *args, int *argc)
    {
       char **argv = NULL;
       int    argn = 0;

       if (args && *args
        && (args = strdup(args))
        && (argn = setargs(args,NULL))
        && (argv = malloc((argn+1) * sizeof(char *)))) {
          *argv++ = args;
          argn = setargs(args,argv);
       }

       if (args && !argv) free(args);

       *argc = argn;
       return argv;
    }

    void freeparsedargs(char **argv)
    {
      if (argv) {
        free(argv[-1]);
        free(argv-1);
      } 
    }

    int main(int argc, char *argv[])
    {
      int i;
      char **av;
      int ac;
      char *as = NULL;

      if (argc > 1) as = argv[1];

      av = parsedargs(as,&ac);
      printf("== %d\n",ac);
      for (i = 0; i < ac; i++)
        printf("[%s]\n",av[i]);

      freeparsedargs(av);
      exit(0);
    }

Hier mein Beitrag. Es ist schön und kurz, aber Dinge, auf die Sie achten sollten, sind:

• Die Verwendung von strtok ändert die ursprüngliche “commandLine”-Zeichenfolge und ersetzt die Leerzeichen durch \0-Trennzeichen am Ende der Zeichenfolge
• argv[] zeigt am Ende auf “commandLine”, also ändern Sie es nicht, bis Sie mit argv fertig sind[].

Der Code:

enum { kMaxArgs = 64 };
int argc = 0;
char *argv[kMaxArgs];

char *p2 = strtok(commandLine, " ");
while (p2 && argc < kMaxArgs-1)
  {
    argv[argc++] = p2;
    p2 = strtok(0, " ");
  }
argv[argc] = 0;

Sie können jetzt argc und argv verwenden oder sie an andere Funktionen übergeben, die wie “foo(int argc, char **argv)” deklariert sind.

Das Immer-wunderbar glatt hat g_shell_parse_args() das klingt nach dem, wonach Sie suchen.

Wenn Sie nicht einmal daran interessiert sind, zu zitieren, ist dies möglicherweise übertrieben. Alles, was Sie tun müssen, ist die Tokenisierung, indem Sie Leerzeichen als Tokenzeichen verwenden. Das Schreiben einer einfachen Routine sollte wirklich nicht lange dauern.

Wenn Sie beim Speicher nicht sehr geizig sind, sollte es einfach sein, dies in einem Durchgang ohne Neuzuweisungen zu tun. Nehmen Sie einfach an, dass im schlimmsten Fall jedes zweite Zeichen ein Leerzeichen ist, und nehmen Sie somit eine Zeichenfolge von an n Zeichen enthält höchstens (n + 1) / 2 Argumente, und (natürlich) höchstens n Bytes Argumenttext (ohne Abschlusszeichen).

Hier ist eine Lösung für Windows und Unix (getestet auf Linux, OSX und Windows). Getestet mit Valgrind und Dr. Speicher.

Es verwendet Wortexp für POSIX-Systeme und CommandLineToArgvW für Windows.

Beachten Sie, dass bei der Windows-Lösung der größte Teil des Codes zwischen konvertiert wird char ** und wchar_t ** mit der schönen Win32-API, da gibt es keine CommandLineToArgvA verfügbar (ANSI-Version).

#ifdef _WIN32
#include <windows.h>
#else
#include <wordexp.h>
#endif

char **split_commandline(const char *cmdline, int *argc)
{
    int i;
    char **argv = NULL;
    assert(argc);

    if (!cmdline)
    {
        return NULL;
    }

    // Posix.
    #ifndef _WIN32
    {
        wordexp_t p;

        // Note! This expands shell variables.
        if (wordexp(cmdline, &p, 0))
        {
            return NULL;
        }

        *argc = p.we_wordc;

        if (!(argv = calloc(*argc, sizeof(char *))))
        {
            goto fail;
        }

        for (i = 0; i < p.we_wordc; i++)
        {
            if (!(argv[i] = strdup(p.we_wordv[i])))
            {
                goto fail;
            }
        }

        wordfree(&p);

        return argv;
    fail:
        wordfree(&p);
    }
    #else // WIN32
    {
        wchar_t **wargs = NULL;
        size_t needed = 0;
        wchar_t *cmdlinew = NULL;
        size_t len = strlen(cmdline) + 1;

        if (!(cmdlinew = calloc(len, sizeof(wchar_t))))
            goto fail;

        if (!MultiByteToWideChar(CP_ACP, 0, cmdline, -1, cmdlinew, len))
            goto fail;

        if (!(wargs = CommandLineToArgvW(cmdlinew, argc)))
            goto fail;

        if (!(argv = calloc(*argc, sizeof(char *))))
            goto fail;

        // Convert from wchar_t * to ANSI char *
        for (i = 0; i < *argc; i++)
        {
            // Get the size needed for the target buffer.
            // CP_ACP = Ansi Codepage.
            needed = WideCharToMultiByte(CP_ACP, 0, wargs[i], -1,
                                        NULL, 0, NULL, NULL);

            if (!(argv[i] = malloc(needed)))
                goto fail;

            // Do the conversion.
            needed = WideCharToMultiByte(CP_ACP, 0, wargs[i], -1,
                                        argv[i], needed, NULL, NULL);
        }

        if (wargs) LocalFree(wargs);
        if (cmdlinew) free(cmdlinew);
        return argv;

    fail:
        if (wargs) LocalFree(wargs);
        if (cmdlinew) free(cmdlinew);
    }
    #endif // WIN32

    if (argv)
    {
        for (i = 0; i < *argc; i++)
        {
            if (argv[i])
            {
                free(argv[i]);
            }
        }

        free(argv);
    }

    return NULL;
}

Ich habe dies gerade für ein eingebettetes Projekt in einfachem C getan, wo ich eine kleine CLI habe, die die Eingabe der seriellen Schnittstelle analysiert und eine begrenzte Menge von Befehlen mit den Parametern ausführt.

Dies ist wahrscheinlich nicht das Ordentlichste, aber so klein und effizient, wie ich es bekommen könnte:

int makeargs(char *args, int *argc, char ***aa) {
    char *buf = strdup(args);
    int c = 1;
    char *delim;
    char **argv = calloc(c, sizeof (char *));

    argv[0] = buf;

    while (delim = strchr(argv[c - 1], ' ')) {
        argv = realloc(argv, (c + 1) * sizeof (char *));
        argv[c] = delim + 1;
        *delim = 0x00;
        c++;
    }

    *argc = c;
    *aa = argv;

    return c;
}

zu testen:

int main(void) {
    char **myargs;
    int argc;

    int numargs = makeargs("Hello world, this is a test", &argc, &myargs);
    while (numargs) {
        printf("%s\r\n", myargs[argc - numargs--]);
    };

    return (EXIT_SUCCESS);
}

Matt Peitreks LIBTINYC hat ein Modul namens argcargv.cpp, das eine Zeichenfolge nimmt und sie unter Berücksichtigung von Argumenten in Anführungszeichen in das Argument-Array ausgibt. Beachten Sie, dass es Windows-spezifisch ist, aber es ist ziemlich einfach, also sollte es einfach sein, auf jede gewünschte Plattform zu wechseln.