Argument-parsing helpers for C/Unix

Question

I know of the following:

• The venerable getopt(3)
• The extended getopt_long
• glibc's argp parser for Unix-style argument vectors
• popt from the GNOME project (or its spiritual successor in Glib)

I'm sure there's more that I haven't used or even heard of; a quick Google search reveals Gopt, argtable, and Optlist.

Personally, I like argp best, and every program I wrote using getopt/getopt_long (beyond a certain baseline of complexity) has been converted to use argp. It's more widely available than popt, more powerful than getopt_long, well-documented, consistent with all the GNU-style conventions, and very flexible. On the downside, it's far from the easiest to use (thanks to being so flexible), and the code to support it is quite verbose (as are many things in C).

What do you use, and why?

Yes, I mean C rather than C++. There are a ton of C++ parsers, but I don't use C++.

John Millikin notes that popt is no longer maintained. I list it because many programs still use it -- including AbiWord, rpm, rsync, and samba -- despite Gnome's efforts to migrate away. But I've added a link to Glib's argument parser now, too.

---

For C++ argument parsing, see the question What parameter parser libraries are there for C++?

Answer 1

GNU has gengetopt which generates code for an options data structure and the getopt_long code to parse the command line and fill the structure.. It's fairly easy to learn and works well.

As a bonus you can pass the options structure around your code and avoid global storage if desired.

It provides GNU style semantics (obviously), and is small enough to simply include with the project for distribution if you're not sure of your audience's build environment.

Answer 2

As the saying goes, "standard is better than better". So I always use getopt_long() and anything that is non-GNOME/glibby, and the glib one on anything that does.

For the same reason I always use optparse in Python applications, even though it has a lot of missing features relative to getopt_long() ... but that's the Python standard.

Answer 3

Since I was looking for the same thing, I read the answers of this old topic. Finally I chose dropt which is mentioned in What parameter parser libraries are there for C++?. Actually it's implemented in C, so I think it's worth mentioning here as well. I haven't used the C++ helper, which wraps the C implementation.

Interesting facts about dropt:

• Lightweight
• Depends only on standard libs
• No steep learning curve
• Sufficient for basic arg parsing, plus a couple of powerful features
• Easy to extend
• Unrestrictive license (zlib-ish)

It is limited though. For instance, I had to adapt my parameters syntax specifications a little; that was acceptable in this very case, but of course sometimes specifications are carved in stone.

As a conclusion I would recommend dropt at least for fast prototyping, tools development, and in-house projects.

Answer 4

popt has been abandoned for a long time -- argument parsing was merged into glib since version 2.6, three years ago.

I use glib's parser, or Python's port of getopt.

Answer 5

I'm not too fond of getopt either (although it's pretty standard). One solution I've made is the function argopt(). It's C compatible, can be used to test whether flags are set as well as reading options with values. It only supports short options (e.g. -h) although writing a similar function for long options (e.g. --help) shouldn't be too difficult. See example:

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

    if(argopt(argc, argv, 'p')) printf("-p is set\n");
    if(argopt(argc, argv, 'q')) printf("-q is set\n");

    const char *f = argopt(argc, argv, 'f');
    if(f) printf("-f is %s\n",f);

    return 0;
}

Example from command line:

$./main -f input.txt -rq
-q is set
-f is input.txt

Disclaimer: I made this function for fun, intending for it to be short, C-compatible, easy to use, and have no dependencies. Here it is:

const char* argopt(int argc, const char *const *argv, char key){

    for(int i=1; i<argc; i++){
        const char *c = argv[i];
        if(*c!='-') continue;
        while(*++c) if(*c==key) return argv[(i+1)%argc];
    }

    return 0;
}

Answer 6

I really like the TCLAP library, because it is very flexible and easy to use. It is also completely template-based, so it is a header-only library.

My mistake: you said C and I posted a C++ library...

Answer 7

I have been developing and using libparamset that is a command-line parameter parsing library written in plain C. It provides:

• Cross-platform functionality (Linux, OS X, Windows).
• Configurable parser where each parameter can act differently (powerful and flexible feature).
• Auto-generated messages for typos, unknown parameters or invalid parameters.
• Extra functionality to design command-line user interface.
• Good documentation.