Simple command line parsing

Question

I'm making a project that needs a simple cross-platform command-line parser. I made this. Hope you enjoy!

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>

#define __NUM_OF_ELEMENTS(ARR) (sizeof(ARR)/sizeof(ARR[0]))
#define __HAS_ARG(FLAGS, ARG) (FLAGS & (1 << ARG))


void panic(const char *fmt, ...){
    fprintf(stderr, "error: ");

    va_list arglist;
    va_start( arglist, fmt );
    vfprintf(stderr, fmt, arglist);
    va_end( arglist );

    exit(EXIT_FAILURE);
}

void help(const char * progName){
    char * whoami = 0;
    (whoami = strrchr(progName, '/')) ? ++whoami : (whoami = progName);
    printf(

           "%s is intended to do blah\n"
           "Options:\n"
           " --help                Display This message\n"
           " --file [file name]    Input file to use\n",

    whoami);
    exit(EXIT_SUCCESS);
}

int main(int argc, char *argv[])
{
    if(argc == 1){
        help(argv[0]);
    }

    const char * args[] = {"--help", "--file", "--2cool4scool"};
    enum                  {HELP_ARG, FILE_ARG, TOO_COOL_FOR_SCHOOL_ARG};
    unsigned int flags = 0;

    //skip prog name
    for(unsigned int arg = 1, i = 0; arg < argc; ++arg){
        for(i = 0; i < (unsigned int)__NUM_OF_ELEMENTS(args); ++i){
            if(!strcmp(argv[arg], args[i])){
                flags |= 1 << i;
                goto CMD_ARGUMENT_FOUND;
            }
        }


        //argument is not found / unkown arg
        panic("Argument '%s' not found\n", argv[arg]);


        CMD_ARGUMENT_FOUND:;
    }

    if(__HAS_ARG(flags, HELP_ARG)){
        help(argv[0]);
    }
    if(__HAS_ARG(flags, TOO_COOL_FOR_SCHOOL_ARG)){
        puts("Hell YA!");
    }

    return 0;
}

Answer 1

Since this is a single-translation-unit program, mark your panic and help as static.

About this:

(whoami = strrchr(progName, '/')) ? ++whoami : (whoami = progName);

"Yikes". Generously we call this write-only code. Unroll it to

char *whoami = strrchr(progName, '/');
if (whoami)
    whoami++;
else
    whoami = progName;

In this loop, your i declaration should be moved down:

for(unsigned int arg = 1, i = 0; arg < argc; ++arg){
    for(i = 0; i < (unsigned int)__NUM_OF_ELEMENTS(args); ++i){

should be

for (unsigned int arg = 1; arg < argc; ++arg) {
    for (int i = 0; i < (unsigned int)__NUM_OF_ELEMENTS(args); ++i) {

to narrow its scope.

Don't use goto. Factor out a function where the double loop termination is done using a return.

Answer 2

These names are dangerous:

#define __NUM_OF_ELEMENTS(ARR) (sizeof(ARR)/sizeof(ARR[0]))
#define __HAS_ARG(FLAGS, ARG) (FLAGS & (1 << ARG))

Any identifier containing two consecutive underscores is reserved for the implementation for any purpose. The same goes for names beginning with underscore and a capital letter.

Also, you slightly messed up the protective parentheses when expanding macro arguments:

#define NUM_OF_ELEMENTS(ARR) (sizeof (ARR) / sizeof (ARR)[0])
#define HAS_ARG(FLAGS, ARG) ((FLAGS) & (1 << (ARG)))

---

If no arguments are passed, then we hit this:

if(argc == 1){
    help(argv[0]);
}

In a portable program, we should really test argc <= 1, since implementations are allowed to pass 0 as argc. The usage message should go to stderr, not stdout. And why do we continue after this? It seems very odd to print an unasked-for usage message, but then continue and return a success status.

---

Maintaining parallel lists is tedious and error-prone. So this code looks pretty straightforward with three possible options:

const char * args[] = {"--help", "--file", "--2cool4scool"};
enum                  {HELP_ARG, FILE_ARG, TOO_COOL_FOR_SCHOOL_ARG};

It becomes unmanageable once you have a few dozen options. And it doesn't handle synonyms very well (e.g. -f and --file both being acceptable).

flags |= 1 << i;

That ought to be 1u << i, since flags is unsigned (same goes for the corresponding macro). And this fails silently once i becomes greater than the width of unsigned, leading to a hard-to-find error.

---

    //argument is not found / unkown arg

Typo: unknown

---

if(__HAS_ARG(flags, HELP_ARG))
if(__HAS_ARG(flags, TOO_COOL_FOR_SCHOOL_ARG))

It seems that the --file option is recognised but ignored. That's almost certainly a bug. Worse than that, the help says it should be followed by a file-name argument, but actually doing so results in an "argument not found" error.

---

It's worth reading the documentation of Python's argparse module (even if you don't know Python) to see what a real argument handler can and should do. For example, it automates printing the usage message so you don't end up forgetting to update it when you add a new option, like here:

       "Options:\n"
       " --help                Display This message\n"
       " --file [file name]    Input file to use\n",