Library for parsing arguments GNU-style? [closed]

Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.

---

开发者_StackOverflow中文版

We don’t allow questions seeking recommendations for books, tools, software libraries, and more. You can edit the question so it can be answered with facts and citations.

Closed 7 years ago.

Improve this question

I've noticed the basic 'style' of most GNU core applications whereby arguments are:

• --longoption
• --longoption=value or --longoption value
• -abcdefg (multiple options)
• -iuwww-data (option i, u = www-data)

They follow the above style. I want to avoid writing an argument parser if there's a library that does this using the above style. Is there one you know of?

---

getopt_long will do the job, here is an example from http://www.gnu.org/s/libc/manual/html_node/Getopt-Long-Option-Example.html

 #include <stdio.h>
 #include <stdlib.h>
 #include <getopt.h>

 /* Flag set by ‘--verbose’. */
 static int verbose_flag;

 int
 main (argc, argv)
      int argc;
      char **argv;
 {
   int c;

   while (1)
     {
       static struct option long_options[] =
         {
           /* These options set a flag. */
           {"verbose", no_argument,       &verbose_flag, 1},
           {"brief",   no_argument,       &verbose_flag, 0},
           /* These options don't set a flag.
              We distinguish them by their indices. */
           {"add",     no_argument,       0, 'a'},
           {"append",  no_argument,       0, 'b'},
           {"delete",  required_argument, 0, 'd'},
           {"create",  required_argument, 0, 'c'},
           {"file",    required_argument, 0, 'f'},
           {0, 0, 0, 0}
         };
       /* getopt_long stores the option index here. */
       int option_index = 0;

       c = getopt_long (argc, argv, "abc:d:f:",
                        long_options, &option_index);

       /* Detect the end of the options. */
       if (c == -1)
         break;

       switch (c)
         {
         case 0:
           /* If this option set a flag, do nothing else now. */
           if (long_options[option_index].flag != 0)
             break;
           printf ("option %s", long_options[option_index].name);
           if (optarg)
             printf (" with arg %s", optarg);
           printf ("\n");
           break;

         case 'a':
           puts ("option -a\n");
           break;

         case 'b':
           puts ("option -b\n");
           break;

         case 'c':
           printf ("option -c with value `%s'\n", optarg);
           break;

         case 'd':
           printf ("option -d with value `%s'\n", optarg);
           break;

         case 'f':
           printf ("option -f with value `%s'\n", optarg);
           break;

         case '?':
           /* getopt_long already printed an error message. */
           break;

         default:
           abort ();
         }
     }

   /* Instead of reporting ‘--verbose’
      and ‘--brief’ as they are encountered,
      we report the final status resulting from them. */
   if (verbose_flag)
     puts ("verbose flag is set");

   /* Print any remaining command line arguments (not options). */
   if (optind < argc)
     {
       printf ("non-option ARGV-elements: ");
       while (optind < argc)
         printf ("%s ", argv[optind++]);
       putchar ('\n');
     }

   exit (0);
 }

---

GNU provides getopt_long, though they actually recommend argp. Check out the GNU libc manual entry on parsing arguments.

---

http://argtable.sourceforge.net/

and

http://www.gnu.org/s/libc/manual/html_node/Parsing-Program-Arguments.html

---

Back in the day people just packaged getopt.c and getopt.h with their sources.

Here is a Google Code query for it. You could use that if you do not want to depend on GNU libc because you may need this on a different OS. But if you're on Linux then libc already gives it to you as the other answers suggested.

---

Google has open sourced the google-gflags library, a command line flag parsing library..

AFAIK, it doesn't provide a "long and short" version of each flag (so you can't combine in multiple options "-aeiou"), but it's trivial to use and doesn't require a centralized list of flags.