bcalc

commander.c (5799B)

---

 
 //
 // commander.c
 //
 // Copyright (c) 2012 TJ Holowaychuk <tj@vision-media.ca>
 //
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <assert.h>
 #include "commander.h"
 
 /*
  * Output error and exit.
  */
 
 static void
 error(char *msg) {
   fprintf(stderr, "%s\n", msg);
   exit(1);
 }
 
 /*
  * Output command version.
  */
 
 static void
 command_version(command_t *self) {
   printf("%s\n", self->version);
   command_free(self);
   exit(0);
 }
 
 /*
  * Output command help.
  */
 
 void
 command_help(command_t *self) {
   printf("\n");
   printf("  Usage: %s %s\n", self->name, self->usage);
   printf("\n");
   printf("  Options:\n");
   printf("\n");
 
   int i;
   for (i = 0; i < self->option_count; ++i) {
     command_option_t *option = &self->options[i];
     printf("    %s, %-25s %s\n"
       , option->small
       , option->large_with_arg
       , option->description);
   }
 
   printf("\n");
   command_free(self);
   exit(0);
 }
 
 /*
  * Initialize with program `name` and `version`.
  */
 
 void
 command_init(command_t *self, const char *name, const char *version) {
   self->arg = NULL;
   self->name = name;
   self->version = version;
   self->option_count = self->argc = 0;
   self->usage = "[options]";
   self->nargv = NULL;
   command_option(self, "-V", "--version", "output program version", command_version);
   command_option(self, "-h", "--help", "output help information", command_help);
 }
 
 /*
  * Free up commander after use.
  */
 
 void
 command_free(command_t *self) {
   int i;
 
   for (i = 0; i < self->option_count; ++i) {
     command_option_t *option = &self->options[i];
     free(option->argname);
     free(option->large);
   }
 
   if (self->nargv) {
     for (i = 0; self->nargv[i]; ++i) {
       free(self->nargv[i]);
     }
     free(self->nargv);
   }
 }
 
 /*
  * Parse argname from `str`. For example
  * Take "--required <arg>" and populate `flag`
  * with "--required" and `arg` with "<arg>".
  */
 
 static void
 parse_argname(const char *str, char *flag, char *arg) {
   int buffer = 0;
   size_t flagpos = 0;
   size_t argpos = 0;
   size_t len = strlen(str);
   size_t i;
 
   for (i = 0; i < len; ++i) {
     if (buffer || '[' == str[i] || '<' == str[i]) {
       buffer = 1;
       arg[argpos++] = str[i];
     } else {
       if (' ' == str[i]) continue;
       flag[flagpos++] = str[i];
     }
   }
 
   arg[argpos] = '\0';
   flag[flagpos] = '\0';
 }
 
 /*
  * Normalize the argument vector by exploding
  * multiple options (if any). For example
  * "foo -abc --scm git" -> "foo -a -b -c --scm git"
  */
 
 static char **
 normalize_args(int *argc, char **argv) {
   int size = 0;
   int alloc = *argc + 1;
   char **nargv = malloc(alloc * sizeof(char *));
   int i;
 
   for (i = 0; argv[i]; ++i) {
     const char *arg = argv[i];
     size_t len = strlen(arg);
 
     // short flag
     if (len > 2 && '-' == arg[0] && !strchr(arg + 1, '-')) {
       alloc += len - 2;
       nargv = realloc(nargv, alloc * sizeof(char *));
       for (size_t j = 1; j < len; ++j) {
         nargv[size] = malloc(3);
         sprintf(nargv[size], "-%c", arg[j]);
         size++;
       }
       continue;
     }
 
     // regular arg
     nargv[size] = malloc(len + 1);
     strcpy(nargv[size], arg);
     size++;
   }
 
   nargv[size] = NULL;
   *argc = size;
   return nargv;
 }
 
 /*
  * Define an option.
  */
 
 void
 command_option(command_t *self, const char *small, const char *large, const char *desc, command_callback_t cb) {
   if (self->option_count == COMMANDER_MAX_OPTIONS) {
     command_free(self);
     error("Maximum option definitions exceeded");
   }
   int n = self->option_count++;
   command_option_t *option = &self->options[n];
   option->cb = cb;
   option->small = small;
   option->description = desc;
   option->required_arg = option->optional_arg = 0;
   option->large_with_arg = large;
   option->argname = malloc(strlen(large) + 1);
   assert(option->argname);
   option->large = malloc(strlen(large) + 1);
   assert(option->large);
   parse_argname(large, option->large, option->argname);
   if ('[' == option->argname[0]) option->optional_arg = 1;
   if ('<' == option->argname[0]) option->required_arg = 1;
 }
 
 /*
  * Parse `argv` (internal).
  * Input arguments should be normalized first
  * see `normalize_args`.
  */
 
 static void
 command_parse_args(command_t *self, int argc, char **argv) {
   int literal = 0;
   int i, j;
 
   for (i = 1; i < argc; ++i) {
     const char *arg = argv[i];
     for (j = 0; j < self->option_count; ++j) {
       command_option_t *option = &self->options[j];
 
       // match flag
       if (!strcmp(arg, option->small) || !strcmp(arg, option->large)) {
         self->arg = NULL;
 
         // required
         if (option->required_arg) {
           arg = argv[++i];
           if (!arg || '-' == arg[0]) {
             fprintf(stderr, "%s %s argument required\n", option->large, option->argname);
             command_free(self);
             exit(1);
           }
           self->arg = arg;
         }
 
         // optional
         if (option->optional_arg) {
           if (argv[i + 1] && '-' != argv[i + 1][0]) {
             self->arg = argv[++i];
           }
         }
 
         // invoke callback
         option->cb(self);
         goto match;
       }
     }
 
     // --
     if ('-' == arg[0] && '-' == arg[1] && 0 == arg[2]) {
       literal = 1;
       goto match;
     }
 
     // unrecognized
     if ('-' == arg[0] && !literal) {
       fprintf(stderr, "unrecognized flag %s\n", arg);
       command_free(self);
       exit(1);
     }
 
     int n = self->argc++;
     if (n == COMMANDER_MAX_ARGS) {
       command_free(self);
       error("Maximum number of arguments exceeded");
     }
     self->argv[n] = (char *) arg;
     match:;
   }
 }
 
 /*
  * Parse `argv` (public).
  */
 
 void
 command_parse(command_t *self, int argc, char **argv) {
   self->nargv = normalize_args(&argc, argv);
   command_parse_args(self, argc, self->nargv);
   self->argv[self->argc] = NULL;
 }