toybox/lib/args.c
<<
>>
Prefs
   1/* args.c - Command line argument parsing.
   2 *
   3 * Copyright 2006 Rob Landley <rob@landley.net>
   4 */
   5
   6// NOTE: If option parsing segfaults, switch on TOYBOX_DEBUG in menuconfig to
   7// add syntax checks to option string parsing which aren't needed in the final
   8// code (since get_opt string is hardwired and should be correct when you ship)
   9
  10#include "toys.h"
  11
  12// Design goals:
  13//   Don't use getopt() out of libc.
  14//   Don't permute original arguments (screwing up ps/top output).
  15//   Integrated --long options "(noshort)a(along)b(blong1)(blong2)"
  16
  17/* This uses a getopt-like option string, but not getopt() itself. We call
  18 * it the get_opt string.
  19 *
  20 * Each option in the get_opt string corresponds to a bit position in the
  21 * return value. The rightmost argument is (1<<0), the next to last is (1<<1)
  22 * and so on. If the option isn't seen in argv[], its bit remains 0.
  23 *
  24 * Options which have an argument fill in the corresponding slot in the global
  25 * union "this" (see generated/globals.h), which it treats as an array of longs
  26 * (note that sizeof(long)==sizeof(pointer) is guaranteed by LP64).
  27 *
  28 * You don't have to free the option strings, which point into the environment
  29 * space. List objects should be freed by main() when command_main() returns.
  30 *
  31 * Example:
  32 *   Calling get_optflags() when toys.which->options="ab:c:d" and
  33 *   argv = ["command", "-b", "fruit", "-d", "walrus"] results in:
  34 *
  35 *     Changes to struct toys:
  36 *       toys.optflags = 5 (I.E. 0101 so -b = 4 | -d = 1)
  37 *       toys.optargs[0] = "walrus" (leftover argument)
  38 *       toys.optargs[1] = NULL (end of list)
  39 *       toys.optc = 1 (there was 1 leftover argument)
  40 *
  41 *     Changes to union this:
  42 *       this[0]=NULL (because -c didn't get an argument this time)
  43 *       this[1]="fruit" (argument to -b)
  44 */
  45
  46// What you can put in a get_opt string:
  47//   Any otherwise unused character (all letters, unprefixed numbers) specify
  48//   an option that sets a flag. The bit value is the same as the binary digit
  49//   if you string the option characters together in order.
  50//   So in "abcdefgh" a = 128, h = 1
  51//
  52//   Suffixes specify that this option takes an argument (stored in GLOBALS):
  53//       Note that pointer and long are always the same size, even on 64 bit.
  54//     : string argument, keep most recent if more than one
  55//     * string argument, appended to a struct arg_list linked list.
  56//     # signed long argument
  57//       <LOW     - die if less than LOW
  58//       >HIGH    - die if greater than HIGH
  59//       =DEFAULT - value if not specified
  60//     - signed long argument defaulting to negative (say + for positive)
  61//     . double precision floating point argument (with CFG_TOYBOX_FLOAT)
  62//       Chop this option out with USE_TOYBOX_FLOAT() in option string
  63//       Same <LOW>HIGH=DEFAULT as #
  64//     @ occurrence counter (which is a long)
  65//     % time offset in milliseconds with optional s/m/h/d suffix
  66//     (longopt)
  67//     | this is required. If more than one marked, only one required.
  68//     ; long option's argument is optional (can only be supplied with --opt=)
  69//     ^ Stop parsing after encountering this argument
  70//    " " (space char) the "plus an argument" must be separate
  71//        I.E. "-j 3" not "-j3". So "kill -stop" != "kill -s top"
  72//
  73//   At the beginning of the get_opt string (before any options):
  74//     ^ stop at first nonoption argument
  75//     <0 die if less than # leftover arguments (default 0)
  76//     >9 die if > # leftover arguments (default MAX_INT)
  77//     ? Allow unknown arguments (pass them through to command).
  78//     & first arg has imaginary dash (ala tar/ps/ar) which sets FLAGS_NODASH
  79//
  80//   At the end: [groups] of previously seen options
  81//     - Only one in group (switch off)    [-abc] means -ab=-b, -ba=-a, -abc=-c
  82//     + Synonyms (switch on all)          [+abc] means -ab=-abc, -c=-abc
  83//     ! More than one in group is error   [!abc] means -ab calls error_exit()
  84//       primarily useful if you can switch things back off again.
  85//
  86//   You may use octal escapes with the high bit (127) set to use a control
  87//   character as an option flag. For example, \300 would be the option -@
  88
  89// Notes from getopt man page
  90//   - and -- cannot be arguments.
  91//     -- force end of arguments
  92//     - is a synonym for stdin in file arguments
  93//   -abcd means -a -b -c -d (but if -b takes an argument, then it's -a -b cd)
  94
  95// Linked list of all known options (option string parsed into this).
  96// Hangs off getoptflagstate, freed at end of option parsing.
  97struct opts {
  98  struct opts *next;
  99  long *arg;         // Pointer into union "this" to store arguments at.
 100  int c;             // Argument character to match
 101  int flags;         // |=1, ^=2, " "=4, ;=8
 102  unsigned long long dex[3]; // bits to disable/enable/exclude in toys.optflags
 103  char type;         // Type of arguments to store union "this"
 104  union {
 105    long l;
 106    FLOAT f;
 107  } val[3];          // low, high, default - range of allowed values
 108};
 109
 110// linked list of long options. (Hangs off getoptflagstate, free at end of
 111// option parsing, details about flag to set and global slot to fill out
 112// stored in related short option struct, but if opt->c = -1 the long option
 113// is "bare" (has no corresponding short option).
 114struct longopts {
 115  struct longopts *next;
 116  struct opts *opt;
 117  char *str;
 118  int len;
 119};
 120
 121// State during argument parsing.
 122struct getoptflagstate
 123{
 124  int argc, minargs, maxargs;
 125  char *arg;
 126  struct opts *opts;
 127  struct longopts *longopts;
 128  int noerror, nodash_now, stopearly;
 129  unsigned excludes, requires;
 130};
 131
 132// Use getoptflagstate to parse one command line option from argv
 133static int gotflag(struct getoptflagstate *gof, struct opts *opt)
 134{
 135  int type;
 136
 137  // Did we recognize this option?
 138  if (!opt) {
 139    if (gof->noerror) return 1;
 140    help_exit("Unknown option '%s'", gof->arg);
 141  }
 142
 143  // Might enabling this switch off something else?
 144  if (toys.optflags & opt->dex[0]) {
 145    struct opts *clr;
 146    unsigned long long i = 1;
 147
 148    // Forget saved argument for flag we switch back off
 149    for (clr=gof->opts, i=1; clr; clr = clr->next, i<<=1)
 150      if (clr->arg && (i & toys.optflags & opt->dex[0])) *clr->arg = 0;
 151    toys.optflags &= ~opt->dex[0];
 152  }
 153
 154  // Set flags
 155  toys.optflags |= opt->dex[1];
 156  gof->excludes |= opt->dex[2];
 157  if (opt->flags&2) gof->stopearly=2;
 158
 159  if (toys.optflags & gof->excludes) {
 160    struct opts *bad;
 161    unsigned i = 1;
 162
 163    for (bad=gof->opts, i=1; bad ;bad = bad->next, i<<=1) {
 164      if (opt == bad || !(i & toys.optflags)) continue;
 165      if (toys.optflags & bad->dex[2]) break;
 166    }
 167    if (bad) help_exit("No '%c' with '%c'", opt->c, bad->c);
 168  }
 169
 170  // Does this option take an argument?
 171  if (!gof->arg) {
 172    if (opt->flags & 8) return 0;
 173    gof->arg = "";
 174  } else gof->arg++;
 175  type = opt->type;
 176
 177  if (type == '@') ++*(opt->arg);
 178  else if (type) {
 179    char *arg = gof->arg;
 180
 181    // Handle "-xblah" and "-x blah", but also a third case: "abxc blah"
 182    // to make "tar xCjfv blah1 blah2 thingy" work like
 183    // "tar -x -C blah1 -j -f blah2 -v thingy"
 184
 185    if (gof->nodash_now || (!arg[0] && !(opt->flags & 8)))
 186      arg = toys.argv[++gof->argc];
 187    if (!arg) {
 188      char *s = "Missing argument to ";
 189      struct longopts *lo;
 190
 191      if (opt->c != -1) help_exit("%s-%c", s, opt->c);
 192
 193      for (lo = gof->longopts; lo->opt != opt; lo = lo->next);
 194      help_exit("%s--%.*s", s, lo->len, lo->str);
 195    }
 196
 197    if (type == ':') *(opt->arg) = (long)arg;
 198    else if (type == '*') {
 199      struct arg_list **list;
 200
 201      list = (struct arg_list **)opt->arg;
 202      while (*list) list=&((*list)->next);
 203      *list = xzalloc(sizeof(struct arg_list));
 204      (*list)->arg = arg;
 205    } else if (type == '#' || type == '-') {
 206      long l = atolx(arg);
 207      if (type == '-' && !ispunct(*arg)) l*=-1;
 208      if (l < opt->val[0].l) help_exit("-%c < %ld", opt->c, opt->val[0].l);
 209      if (l > opt->val[1].l) help_exit("-%c > %ld", opt->c, opt->val[1].l);
 210
 211      *(opt->arg) = l;
 212    } else if (CFG_TOYBOX_FLOAT && type == '.') {
 213      FLOAT *f = (FLOAT *)(opt->arg);
 214
 215      *f = strtod(arg, &arg);
 216      if (opt->val[0].l != LONG_MIN && *f < opt->val[0].f)
 217        help_exit("-%c < %lf", opt->c, (double)opt->val[0].f);
 218      if (opt->val[1].l != LONG_MAX && *f > opt->val[1].f)
 219        help_exit("-%c > %lf", opt->c, (double)opt->val[1].f);
 220    } else if (type=='%') *(opt->arg) = xparsemillitime(arg);
 221
 222    if (!gof->nodash_now) gof->arg = "";
 223  }
 224
 225  return 0;
 226}
 227
 228// Parse this command's options string into struct getoptflagstate, which
 229// includes a struct opts linked list in reverse order (I.E. right-to-left)
 230void parse_optflaglist(struct getoptflagstate *gof)
 231{
 232  char *options = toys.which->options;
 233  long *nextarg = (long *)&this;
 234  struct opts *new = 0;
 235  int idx;
 236
 237  // Parse option format string
 238  memset(gof, 0, sizeof(struct getoptflagstate));
 239  gof->maxargs = INT_MAX;
 240  if (!options) return;
 241
 242  // Parse leading special behavior indicators
 243  for (;;) {
 244    if (*options == '^') gof->stopearly++;
 245    else if (*options == '<') gof->minargs=*(++options)-'0';
 246    else if (*options == '>') gof->maxargs=*(++options)-'0';
 247    else if (*options == '?') gof->noerror++;
 248    else if (*options == '&') gof->nodash_now = 1;
 249    else break;
 250    options++;
 251  }
 252
 253  // Parse option string into a linked list of options with attributes.
 254
 255  if (!*options) gof->stopearly++;
 256  while (*options) {
 257    char *temp;
 258
 259    // Option groups come after all options are defined
 260    if (*options == '[') break;
 261
 262    // Allocate a new list entry when necessary
 263    if (!new) {
 264      new = xzalloc(sizeof(struct opts));
 265      new->next = gof->opts;
 266      gof->opts = new;
 267      new->val[0].l = LONG_MIN;
 268      new->val[1].l = LONG_MAX;
 269    }
 270    // Each option must start with "(" or an option character.  (Bare
 271    // longopts only come at the start of the string.)
 272    if (*options == '(' && new->c != -1) {
 273      char *end;
 274      struct longopts *lo;
 275
 276      // Find the end of the longopt
 277      for (end = ++options; *end && *end != ')'; end++);
 278      if (CFG_TOYBOX_DEBUG && !*end) error_exit("(longopt) didn't end");
 279
 280      // init a new struct longopts
 281      lo = xmalloc(sizeof(struct longopts));
 282      lo->next = gof->longopts;
 283      lo->opt = new;
 284      lo->str = options;
 285      lo->len = end-options;
 286      gof->longopts = lo;
 287      options = ++end;
 288
 289      // Mark this struct opt as used, even when no short opt.
 290      if (!new->c) new->c = -1;
 291
 292      continue;
 293
 294    // If this is the start of a new option that wasn't a longopt,
 295
 296    } else if (strchr(":*#@.-%", *options)) {
 297      if (CFG_TOYBOX_DEBUG && new->type)
 298        error_exit("multiple types %c:%c%c", new->c, new->type, *options);
 299      new->type = *options;
 300    } else if (-1 != (idx = stridx("|^ ;", *options))) new->flags |= 1<<idx;
 301    // bounds checking
 302    else if (-1 != (idx = stridx("<>=", *options))) {
 303      if (new->type == '#' || new->type == '%') {
 304        long l = strtol(++options, &temp, 10);
 305        if (temp != options) new->val[idx].l = l;
 306      } else if (CFG_TOYBOX_FLOAT && new->type == '.') {
 307        FLOAT f = strtod(++options, &temp);
 308        if (temp != options) new->val[idx].f = f;
 309      } else error_exit("<>= only after .#%%");
 310      options = --temp;
 311
 312    // At this point, we've hit the end of the previous option.  The
 313    // current character is the start of a new option.  If we've already
 314    // assigned an option to this struct, loop to allocate a new one.
 315    // (It'll get back here afterwards and fall through to next else.)
 316    } else if (new->c) {
 317      new = 0;
 318      continue;
 319
 320    // Claim this option, loop to see what's after it.
 321    } else new->c = 127&*options;
 322
 323    options++;
 324  }
 325
 326  // Initialize enable/disable/exclude masks and pointers to store arguments.
 327  // (This goes right to left so we need the whole list before we can start.)
 328  idx = 0;
 329  for (new = gof->opts; new; new = new->next) {
 330    unsigned long long u = 1L<<idx++;
 331
 332    if (new->c == 1) new->c = 0;
 333    new->dex[1] = u;
 334    if (new->flags & 1) gof->requires |= u;
 335    if (new->type) {
 336      new->arg = (void *)nextarg;
 337      *(nextarg++) = new->val[2].l;
 338    }
 339  }
 340
 341  // Parse trailing group indicators
 342  while (*options) {
 343    unsigned bits = 0;
 344
 345    if (CFG_TOYBOX_DEBUG && *options != '[') error_exit("trailing %s", options);
 346
 347    idx = stridx("-+!", *++options);
 348    if (CFG_TOYBOX_DEBUG && idx == -1) error_exit("[ needs +-!");
 349    if (CFG_TOYBOX_DEBUG && (options[1] == ']' || !options[1]))
 350      error_exit("empty []");
 351
 352    // Don't advance past ] but do process it once in loop.
 353    while (*options++ != ']') {
 354      struct opts *opt;
 355      int i;
 356
 357      if (CFG_TOYBOX_DEBUG && !*options) error_exit("[ without ]");
 358      // Find this option flag (in previously parsed struct opt)
 359      for (i=0, opt = gof->opts; ; i++, opt = opt->next) {
 360        if (*options == ']') {
 361          if (!opt) break;
 362          if (bits&(1<<i)) opt->dex[idx] |= bits&~(1<<i);
 363        } else {
 364          if (*options==1) break;
 365          if (CFG_TOYBOX_DEBUG && !opt)
 366            error_exit("[] unknown target %c", *options);
 367          if (opt->c == *options) {
 368            bits |= 1<<i;
 369            break;
 370          }
 371        }
 372      }
 373    }
 374  }
 375}
 376
 377// Fill out toys.optflags, toys.optargs, and this[] from toys.argv
 378
 379void get_optflags(void)
 380{
 381  struct getoptflagstate gof;
 382  struct opts *catch;
 383  unsigned long long saveflags;
 384  char *letters[]={"s",""};
 385
 386  // Option parsing is a two stage process: parse the option string into
 387  // a struct opts list, then use that list to process argv[];
 388
 389  toys.exitval = toys.which->flags >> 24;
 390
 391  // Allocate memory for optargs
 392  saveflags = 0;
 393  while (toys.argv[saveflags++]);
 394  toys.optargs = xzalloc(sizeof(char *)*saveflags);
 395
 396  parse_optflaglist(&gof);
 397
 398  if (toys.argv[1] && toys.argv[1][0] == '-') gof.nodash_now = 0;
 399
 400  // Iterate through command line arguments, skipping argv[0]
 401  for (gof.argc=1; toys.argv[gof.argc]; gof.argc++) {
 402    gof.arg = toys.argv[gof.argc];
 403    catch = NULL;
 404
 405    // Parse this argument
 406    if (gof.stopearly>1) goto notflag;
 407
 408    if (gof.argc>1 || *gof.arg=='-') gof.nodash_now = 0;
 409
 410    // Various things with dashes
 411    if (*gof.arg == '-') {
 412
 413      // Handle -
 414      if (!gof.arg[1]) goto notflag;
 415      gof.arg++;
 416      if (*gof.arg=='-') {
 417        struct longopts *lo;
 418
 419        gof.arg++;
 420        // Handle --
 421        if (!*gof.arg) {
 422          gof.stopearly += 2;
 423          continue;
 424        }
 425
 426        // do we match a known --longopt?
 427        for (lo = gof.longopts; lo; lo = lo->next) {
 428          if (!strncmp(gof.arg, lo->str, lo->len)) {
 429            if (!gof.arg[lo->len]) gof.arg = 0;
 430            else if (gof.arg[lo->len] == '=' && lo->opt->type)
 431              gof.arg += lo->len;
 432            else continue;
 433            // It's a match.
 434            catch = lo->opt;
 435            break;
 436          }
 437        }
 438
 439        // Should we handle this --longopt as a non-option argument?
 440        if (!lo && gof.noerror) {
 441          gof.arg -= 2;
 442          goto notflag;
 443        }
 444
 445        // Long option parsed, handle option.
 446        gotflag(&gof, catch);
 447        continue;
 448      }
 449
 450    // Handle things that don't start with a dash.
 451    } else {
 452      if (gof.nodash_now) toys.optflags |= FLAGS_NODASH;
 453      else goto notflag;
 454    }
 455
 456    // At this point, we have the args part of -args.  Loop through
 457    // each entry (could be -abc meaning -a -b -c)
 458    saveflags = toys.optflags;
 459    while (*gof.arg) {
 460
 461      // Identify next option char.
 462      for (catch = gof.opts; catch; catch = catch->next)
 463        if (*gof.arg == catch->c)
 464          if (!((catch->flags&4) && gof.arg[1])) break;
 465
 466      // Handle option char (advancing past what was used)
 467      if (gotflag(&gof, catch) ) {
 468        toys.optflags = saveflags;
 469        gof.arg = toys.argv[gof.argc];
 470        goto notflag;
 471      }
 472    }
 473    continue;
 474
 475    // Not a flag, save value in toys.optargs[]
 476notflag:
 477    if (gof.stopearly) gof.stopearly++;
 478    toys.optargs[toys.optc++] = toys.argv[gof.argc];
 479  }
 480
 481  // Sanity check
 482  if (toys.optc<gof.minargs)
 483    help_exit("Need%s %d argument%s", letters[!!(gof.minargs-1)],
 484      gof.minargs, letters[!(gof.minargs-1)]);
 485  if (toys.optc>gof.maxargs)
 486    help_exit("Max %d argument%s", gof.maxargs, letters[!(gof.maxargs-1)]);
 487  if (gof.requires && !(gof.requires & toys.optflags)) {
 488    struct opts *req;
 489    char needs[32], *s = needs;
 490
 491    for (req = gof.opts; req; req = req->next)
 492      if (req->flags & 1) *(s++) = req->c;
 493    *s = 0;
 494
 495    help_exit("Needs %s-%s", s[1] ? "one of " : "", needs);
 496  }
 497
 498  toys.exitval = 0;
 499
 500  if (CFG_TOYBOX_FREE) {
 501    llist_traverse(gof.opts, free);
 502    llist_traverse(gof.longopts, free);
 503  }
 504}
 505