contrib/cpio/lib/argp-parse.c

   1 /* Hierarchial argument parsing, layered over getopt
   2    Copyright (C) 1995-2000, 2002, 2003, 2004 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Written by Miles Bader <miles@gnu.ai.mit.edu>.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2, or (at your option)
   9    any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License along
  17    with this program; if not, write to the Free Software Foundation,
  18    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include <config.h>
  22 #endif
  23
  24 #include <alloca.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <unistd.h>
  28 #include <limits.h>
  29 #include <getopt.h>
  30 #include <getopt_int.h>
  31
  32 #ifdef _LIBC
  33 # include <libintl.h>
  34 # undef dgettext
  35 # define dgettext(domain, msgid) \
  36    INTUSE(__dcgettext) (domain, msgid, LC_MESSAGES)
  37 #else
  38 # include "gettext.h"
  39 #endif
  40 #define N_(msgid) (msgid)
  41
  42 #include "argp.h"
  43 #include "argp-namefrob.h"
  44
  45 /* Getopt return values.  */
  46 #define KEY_END (-1)            /* The end of the options.  */
  47 #define KEY_ARG 1               /* A non-option argument.  */
  48 #define KEY_ERR '?'             /* An error parsing the options.  */
  49
  50 /* The meta-argument used to prevent any further arguments being interpreted
  51    as options.  */
  52 #define QUOTE "--"
  53
  54 /* The number of bits we steal in a long-option value for our own use.  */
  55 #define GROUP_BITS CHAR_BIT
  56
  57 /* The number of bits available for the user value.  */
  58 #define USER_BITS ((sizeof ((struct option *)0)->val * CHAR_BIT) - GROUP_BITS)
  59 #define USER_MASK ((1 << USER_BITS) - 1)
  60
  61 /* EZ alias for ARGP_ERR_UNKNOWN.  */
  62 #define EBADKEY ARGP_ERR_UNKNOWN
  63 \f
  64 /* Default options.  */
  65
  66 /* When argp is given the --HANG switch, _ARGP_HANG is set and argp will sleep
  67    for one second intervals, decrementing _ARGP_HANG until it's zero.  Thus
  68    you can force the program to continue by attaching a debugger and setting
  69    it to 0 yourself.  */
  70 static volatile int _argp_hang;
  71
  72 #define OPT_PROGNAME    -2
  73 #define OPT_USAGE       -3
  74 #define OPT_HANG        -4
  75
  76 static const struct argp_option argp_default_options[] =
  77 {
  78   {"help",        '?',          0, 0,  N_("Give this help list"), -1},
  79   {"usage",       OPT_USAGE,    0, 0,  N_("Give a short usage message"), 0},
  80   {"program-name",OPT_PROGNAME,"NAME", OPTION_HIDDEN, N_("Set the program name"), 0},
  81   {"HANG",        OPT_HANG,    "SECS", OPTION_ARG_OPTIONAL | OPTION_HIDDEN,
  82      N_("Hang for SECS seconds (default 3600)"), 0},
  83   {NULL, 0, 0, 0, NULL, 0}
  84 };
  85
  86 static error_t
  87 argp_default_parser (int key, char *arg, struct argp_state *state)
  88 {
  89   switch (key)
  90     {
  91     case '?':
  92       __argp_state_help (state, state->out_stream, ARGP_HELP_STD_HELP);
  93       break;
  94     case OPT_USAGE:
  95       __argp_state_help (state, state->out_stream,
  96                        ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
  97       break;
  98
  99     case OPT_PROGNAME:          /* Set the program name.  */
 100 #if defined _LIBC || HAVE_DECL_PROGRAM_INVOCATION_NAME
 101       program_invocation_name = arg;
 102 #endif
 103       /* [Note that some systems only have PROGRAM_INVOCATION_SHORT_NAME (aka
 104          __PROGNAME), in which case, PROGRAM_INVOCATION_NAME is just defined
 105          to be that, so we have to be a bit careful here.]  */
 106
 107       /* Update what we use for messages.  */
 108       state->name = strrchr (arg, '/');
 109       if (state->name)
 110         state->name++;
 111       else
 112         state->name = arg;
 113
 114 #if defined _LIBC || HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME
 115       program_invocation_short_name = state->name;
 116 #endif
 117
 118       if ((state->flags & (ARGP_PARSE_ARGV0 | ARGP_NO_ERRS))
 119           == ARGP_PARSE_ARGV0)
 120         /* Update what getopt uses too.  */
 121         state->argv[0] = arg;
 122
 123       break;
 124
 125     case OPT_HANG:
 126       _argp_hang = atoi (arg ? arg : "3600");
 127       while (_argp_hang-- > 0)
 128         __sleep (1);
 129       break;
 130
 131     default:
 132       return EBADKEY;
 133     }
 134   return 0;
 135 }
 136
 137 static const struct argp argp_default_argp =
 138   {argp_default_options, &argp_default_parser, NULL, NULL, NULL, NULL, "libc"};
 139
 140 \f
 141 static const struct argp_option argp_version_options[] =
 142 {
 143   {"version",     'V',          0, 0,  N_("Print program version"), -1},
 144   {NULL, 0, 0, 0, NULL, 0}
 145 };
 146
 147 static error_t
 148 argp_version_parser (int key, char *arg, struct argp_state *state)
 149 {
 150   switch (key)
 151     {
 152     case 'V':
 153       if (argp_program_version_hook)
 154         (*argp_program_version_hook) (state->out_stream, state);
 155       else if (argp_program_version)
 156         fprintf (state->out_stream, "%s\n", argp_program_version);
 157       else
 158         __argp_error (state, dgettext (state->root_argp->argp_domain,
 159                                        "(PROGRAM ERROR) No version known!?"));
 160       if (! (state->flags & ARGP_NO_EXIT))
 161         exit (0);
 162       break;
 163     default:
 164       return EBADKEY;
 165     }
 166   return 0;
 167 }
 168
 169 static const struct argp argp_version_argp =
 170   {argp_version_options, &argp_version_parser, NULL, NULL, NULL, NULL, "libc"};
 171 \f
 172 /* Returns the offset into the getopt long options array LONG_OPTIONS of a
 173    long option with called NAME, or -1 if none is found.  Passing NULL as
 174    NAME will return the number of options.  */
 175 static int
 176 find_long_option (struct option *long_options, const char *name)
 177 {
 178   struct option *l = long_options;
 179   while (l->name != NULL)
 180     if (name != NULL && strcmp (l->name, name) == 0)
 181       return l - long_options;
 182     else
 183       l++;
 184   if (name == NULL)
 185     return l - long_options;
 186   else
 187     return -1;
 188 }
 189
 190 \f
 191 /* The state of a `group' during parsing.  Each group corresponds to a
 192    particular argp structure from the tree of such descending from the top
 193    level argp passed to argp_parse.  */
 194 struct group
 195 {
 196   /* This group's parsing function.  */
 197   argp_parser_t parser;
 198
 199   /* Which argp this group is from.  */
 200   const struct argp *argp;
 201
 202   /* Points to the point in SHORT_OPTS corresponding to the end of the short
 203      options for this group.  We use it to determine from which group a
 204      particular short options is from.  */
 205   char *short_end;
 206
 207   /* The number of non-option args sucessfully handled by this parser.  */
 208   unsigned args_processed;
 209
 210   /* This group's parser's parent's group.  */
 211   struct group *parent;
 212   unsigned parent_index;        /* And the our position in the parent.   */
 213
 214   /* These fields are swapped into and out of the state structure when
 215      calling this group's parser.  */
 216   void *input, **child_inputs;
 217   void *hook;
 218 };
 219
 220 /* Call GROUP's parser with KEY and ARG, swapping any group-specific info
 221    from STATE before calling, and back into state afterwards.  If GROUP has
 222    no parser, EBADKEY is returned.  */
 223 static error_t
 224 group_parse (struct group *group, struct argp_state *state, int key, char *arg)
 225 {
 226   if (group->parser)
 227     {
 228       error_t err;
 229       state->hook = group->hook;
 230       state->input = group->input;
 231       state->child_inputs = group->child_inputs;
 232       state->arg_num = group->args_processed;
 233       err = (*group->parser)(key, arg, state);
 234       group->hook = state->hook;
 235       return err;
 236     }
 237   else
 238     return EBADKEY;
 239 }
 240 \f
 241 struct parser
 242 {
 243   const struct argp *argp;
 244
 245   /* SHORT_OPTS is the getopt short options string for the union of all the
 246      groups of options.  */
 247   char *short_opts;
 248   /* LONG_OPTS is the array of getop long option structures for the union of
 249      all the groups of options.  */
 250   struct option *long_opts;
 251   /* OPT_DATA is the getopt data used for the re-entrant getopt.  */
 252   struct _getopt_data opt_data;
 253
 254   /* States of the various parsing groups.  */
 255   struct group *groups;
 256   /* The end of the GROUPS array.  */
 257   struct group *egroup;
 258   /* An vector containing storage for the CHILD_INPUTS field in all groups.  */
 259   void **child_inputs;
 260
 261   /* True if we think using getopt is still useful; if false, then
 262      remaining arguments are just passed verbatim with ARGP_KEY_ARG.  This is
 263      cleared whenever getopt returns KEY_END, but may be set again if the user
 264      moves the next argument pointer backwards.  */
 265   int try_getopt;
 266
 267   /* State block supplied to parsing routines.  */
 268   struct argp_state state;
 269
 270   /* Memory used by this parser.  */
 271   void *storage;
 272 };
 273 \f
 274 /* The next usable entries in the various parser tables being filled in by
 275    convert_options.  */
 276 struct parser_convert_state
 277 {
 278   struct parser *parser;
 279   char *short_end;
 280   struct option *long_end;
 281   void **child_inputs_end;
 282 };
 283
 284 /* Converts all options in ARGP (which is put in GROUP) and ancestors
 285    into getopt options stored in SHORT_OPTS and LONG_OPTS; SHORT_END and
 286    CVT->LONG_END are the points at which new options are added.  Returns the
 287    next unused group entry.  CVT holds state used during the conversion.  */
 288 static struct group *
 289 convert_options (const struct argp *argp,
 290                  struct group *parent, unsigned parent_index,
 291                  struct group *group, struct parser_convert_state *cvt)
 292 {
 293   /* REAL is the most recent non-alias value of OPT.  */
 294   const struct argp_option *real = argp->options;
 295   const struct argp_child *children = argp->children;
 296
 297   if (real || argp->parser)
 298     {
 299       const struct argp_option *opt;
 300
 301       if (real)
 302         for (opt = real; !__option_is_end (opt); opt++)
 303           {
 304             if (! (opt->flags & OPTION_ALIAS))
 305               /* OPT isn't an alias, so we can use values from it.  */
 306               real = opt;
 307
 308             if (! (real->flags & OPTION_DOC))
 309               /* A real option (not just documentation).  */
 310               {
 311                 if (__option_is_short (opt))
 312                   /* OPT can be used as a short option.  */
 313                   {
 314                     *cvt->short_end++ = opt->key;
 315                     if (real->arg)
 316                       {
 317                         *cvt->short_end++ = ':';
 318                         if (real->flags & OPTION_ARG_OPTIONAL)
 319                           *cvt->short_end++ = ':';
 320                       }
 321                     *cvt->short_end = '\0'; /* keep 0 terminated */
 322                   }
 323
 324                 if (opt->name
 325                     && find_long_option (cvt->parser->long_opts, opt->name) < 0)
 326                   /* OPT can be used as a long option.  */
 327                   {
 328                     cvt->long_end->name = opt->name;
 329                     cvt->long_end->has_arg =
 330                       (real->arg
 331                        ? (real->flags & OPTION_ARG_OPTIONAL
 332                           ? optional_argument
 333                           : required_argument)
 334                        : no_argument);
 335                     cvt->long_end->flag = 0;
 336                     /* we add a disambiguating code to all the user's
 337                        values (which is removed before we actually call
 338                        the function to parse the value); this means that
 339                        the user loses use of the high 8 bits in all his
 340                        values (the sign of the lower bits is preserved
 341                        however)...  */
 342                     cvt->long_end->val =
 343                       ((opt->key | real->key) & USER_MASK)
 344                       + (((group - cvt->parser->groups) + 1) << USER_BITS);
 345
 346                     /* Keep the LONG_OPTS list terminated.  */
 347                     (++cvt->long_end)->name = NULL;
 348                   }
 349               }
 350             }
 351
 352       group->parser = argp->parser;
 353       group->argp = argp;
 354       group->short_end = cvt->short_end;
 355       group->args_processed = 0;
 356       group->parent = parent;
 357       group->parent_index = parent_index;
 358       group->input = 0;
 359       group->hook = 0;
 360       group->child_inputs = 0;
 361
 362       if (children)
 363         /* Assign GROUP's CHILD_INPUTS field some space from
 364            CVT->child_inputs_end.*/
 365         {
 366           unsigned num_children = 0;
 367           while (children[num_children].argp)
 368             num_children++;
 369           group->child_inputs = cvt->child_inputs_end;
 370           cvt->child_inputs_end += num_children;
 371         }
 372
 373       parent = group++;
 374     }
 375   else
 376     parent = 0;
 377
 378   if (children)
 379     {
 380       unsigned index = 0;
 381       while (children->argp)
 382         group =
 383           convert_options (children++->argp, parent, index++, group, cvt);
 384     }
 385
 386   return group;
 387 }
 388
 389 /* Find the merged set of getopt options, with keys appropiately prefixed. */
 390 static void
 391 parser_convert (struct parser *parser, const struct argp *argp, int flags)
 392 {
 393   struct parser_convert_state cvt;
 394
 395   cvt.parser = parser;
 396   cvt.short_end = parser->short_opts;
 397   cvt.long_end = parser->long_opts;
 398   cvt.child_inputs_end = parser->child_inputs;
 399
 400   if (flags & ARGP_IN_ORDER)
 401     *cvt.short_end++ = '-';
 402   else if (flags & ARGP_NO_ARGS)
 403     *cvt.short_end++ = '+';
 404   *cvt.short_end = '\0';
 405
 406   cvt.long_end->name = NULL;
 407
 408   parser->argp = argp;
 409
 410   if (argp)
 411     parser->egroup = convert_options (argp, 0, 0, parser->groups, &cvt);
 412   else
 413     parser->egroup = parser->groups; /* No parsers at all! */
 414 }
 415 \f
 416 /* Lengths of various parser fields which we will allocated.  */
 417 struct parser_sizes
 418 {
 419   size_t short_len;             /* Getopt short options string.  */
 420   size_t long_len;              /* Getopt long options vector.  */
 421   size_t num_groups;            /* Group structures we allocate.  */
 422   size_t num_child_inputs;      /* Child input slots.  */
 423 };
 424
 425 /* For ARGP, increments the NUM_GROUPS field in SZS by the total number of
 426  argp structures descended from it, and the SHORT_LEN & LONG_LEN fields by
 427  the maximum lengths of the resulting merged getopt short options string and
 428  long-options array, respectively.  */
 429 static void
 430 calc_sizes (const struct argp *argp,  struct parser_sizes *szs)
 431 {
 432   const struct argp_child *child = argp->children;
 433   const struct argp_option *opt = argp->options;
 434
 435   if (opt || argp->parser)
 436     {
 437       szs->num_groups++;
 438       if (opt)
 439         {
 440           int num_opts = 0;
 441           while (!__option_is_end (opt++))
 442             num_opts++;
 443           szs->short_len += num_opts * 3; /* opt + up to 2 `:'s */
 444           szs->long_len += num_opts;
 445         }
 446     }
 447
 448   if (child)
 449     while (child->argp)
 450       {
 451         calc_sizes ((child++)->argp, szs);
 452         szs->num_child_inputs++;
 453       }
 454 }
 455
 456 /* Initializes PARSER to parse ARGP in a manner described by FLAGS.  */
 457 static error_t
 458 parser_init (struct parser *parser, const struct argp *argp,
 459              int argc, char **argv, int flags, void *input)
 460 {
 461   error_t err = 0;
 462   struct group *group;
 463   struct parser_sizes szs;
 464   struct _getopt_data opt_data = _GETOPT_DATA_INITIALIZER;
 465
 466   szs.short_len = (flags & ARGP_NO_ARGS) ? 0 : 1;
 467   szs.long_len = 0;
 468   szs.num_groups = 0;
 469   szs.num_child_inputs = 0;
 470
 471   if (argp)
 472     calc_sizes (argp, &szs);
 473
 474   /* Lengths of the various bits of storage used by PARSER.  */
 475 #define GLEN (szs.num_groups + 1) * sizeof (struct group)
 476 #define CLEN (szs.num_child_inputs * sizeof (void *))
 477 #define LLEN ((szs.long_len + 1) * sizeof (struct option))
 478 #define SLEN (szs.short_len + 1)
 479
 480   parser->storage = malloc (GLEN + CLEN + LLEN + SLEN);
 481   if (! parser->storage)
 482     return ENOMEM;
 483
 484   parser->groups = parser->storage;
 485   parser->child_inputs = parser->storage + GLEN;
 486   parser->long_opts = parser->storage + GLEN + CLEN;
 487   parser->short_opts = parser->storage + GLEN + CLEN + LLEN;
 488   parser->opt_data = opt_data;
 489
 490   memset (parser->child_inputs, 0, szs.num_child_inputs * sizeof (void *));
 491   parser_convert (parser, argp, flags);
 492
 493   memset (&parser->state, 0, sizeof (struct argp_state));
 494   parser->state.root_argp = parser->argp;
 495   parser->state.argc = argc;
 496   parser->state.argv = argv;
 497   parser->state.flags = flags;
 498   parser->state.err_stream = stderr;
 499   parser->state.out_stream = stdout;
 500   parser->state.next = 0;       /* Tell getopt to initialize.  */
 501   parser->state.pstate = parser;
 502
 503   parser->try_getopt = 1;
 504
 505   /* Call each parser for the first time, giving it a chance to propagate
 506      values to child parsers.  */
 507   if (parser->groups < parser->egroup)
 508     parser->groups->input = input;
 509   for (group = parser->groups;
 510        group < parser->egroup && (!err || err == EBADKEY);
 511        group++)
 512     {
 513       if (group->parent)
 514         /* If a child parser, get the initial input value from the parent. */
 515         group->input = group->parent->child_inputs[group->parent_index];
 516
 517       if (!group->parser
 518           && group->argp->children && group->argp->children->argp)
 519         /* For the special case where no parsing function is supplied for an
 520            argp, propagate its input to its first child, if any (this just
 521            makes very simple wrapper argps more convenient).  */
 522         group->child_inputs[0] = group->input;
 523
 524       err = group_parse (group, &parser->state, ARGP_KEY_INIT, 0);
 525     }
 526   if (err == EBADKEY)
 527     err = 0;                    /* Some parser didn't understand.  */
 528
 529   if (err)
 530     return err;
 531
 532   if (parser->state.flags & ARGP_NO_ERRS)
 533     {
 534       parser->opt_data.opterr = 0;
 535       if (parser->state.flags & ARGP_PARSE_ARGV0)
 536         /* getopt always skips ARGV[0], so we have to fake it out.  As long
 537            as OPTERR is 0, then it shouldn't actually try to access it.  */
 538         parser->state.argv--, parser->state.argc++;
 539     }
 540   else
 541     parser->opt_data.opterr = 1;        /* Print error messages.  */
 542
 543   if (parser->state.argv == argv && argv[0])
 544     /* There's an argv[0]; use it for messages.  */
 545     {
 546       char *short_name = strrchr (argv[0], '/');
 547       parser->state.name = short_name ? short_name + 1 : argv[0];
 548     }
 549   else
 550     parser->state.name = __argp_short_program_name ();
 551
 552   return 0;
 553 }
 554 \f
 555 /* Free any storage consumed by PARSER (but not PARSER itself).  */
 556 static error_t
 557 parser_finalize (struct parser *parser,
 558                  error_t err, int arg_ebadkey, int *end_index)
 559 {
 560   struct group *group;
 561
 562   if (err == EBADKEY && arg_ebadkey)
 563     /* Suppress errors generated by unparsed arguments.  */
 564     err = 0;
 565
 566   if (! err)
 567     {
 568       if (parser->state.next == parser->state.argc)
 569         /* We successfully parsed all arguments!  Call all the parsers again,
 570            just a few more times... */
 571         {
 572           for (group = parser->groups;
 573                group < parser->egroup && (!err || err==EBADKEY);
 574                group++)
 575             if (group->args_processed == 0)
 576               err = group_parse (group, &parser->state, ARGP_KEY_NO_ARGS, 0);
 577           for (group = parser->egroup - 1;
 578                group >= parser->groups && (!err || err==EBADKEY);
 579                group--)
 580             err = group_parse (group, &parser->state, ARGP_KEY_END, 0);
 581
 582           if (err == EBADKEY)
 583             err = 0;            /* Some parser didn't understand.  */
 584
 585           /* Tell the user that all arguments are parsed.  */
 586           if (end_index)
 587             *end_index = parser->state.next;
 588         }
 589       else if (end_index)
 590         /* Return any remaining arguments to the user.  */
 591         *end_index = parser->state.next;
 592       else
 593         /* No way to return the remaining arguments, they must be bogus. */
 594         {
 595           if (!(parser->state.flags & ARGP_NO_ERRS)
 596               && parser->state.err_stream)
 597             fprintf (parser->state.err_stream,
 598                      dgettext (parser->argp->argp_domain,
 599                                "%s: Too many arguments\n"),
 600                      parser->state.name);
 601           err = EBADKEY;
 602         }
 603     }
 604
 605   /* Okay, we're all done, with either an error or success; call the parsers
 606      to indicate which one.  */
 607
 608   if (err)
 609     {
 610       /* Maybe print an error message.  */
 611       if (err == EBADKEY)
 612         /* An appropriate message describing what the error was should have
 613            been printed earlier.  */
 614         __argp_state_help (&parser->state, parser->state.err_stream,
 615                            ARGP_HELP_STD_ERR);
 616
 617       /* Since we didn't exit, give each parser an error indication.  */
 618       for (group = parser->groups; group < parser->egroup; group++)
 619         group_parse (group, &parser->state, ARGP_KEY_ERROR, 0);
 620     }
 621   else
 622     /* Notify parsers of success, and propagate back values from parsers.  */
 623     {
 624       /* We pass over the groups in reverse order so that child groups are
 625          given a chance to do there processing before passing back a value to
 626          the parent.  */
 627       for (group = parser->egroup - 1
 628            ; group >= parser->groups && (!err || err == EBADKEY)
 629            ; group--)
 630         err = group_parse (group, &parser->state, ARGP_KEY_SUCCESS, 0);
 631       if (err == EBADKEY)
 632         err = 0;                /* Some parser didn't understand.  */
 633     }
 634
 635   /* Call parsers once more, to do any final cleanup.  Errors are ignored.  */
 636   for (group = parser->egroup - 1; group >= parser->groups; group--)
 637     group_parse (group, &parser->state, ARGP_KEY_FINI, 0);
 638
 639   if (err == EBADKEY)
 640     err = EINVAL;
 641
 642   free (parser->storage);
 643
 644   return err;
 645 }
 646 \f
 647 /* Call the user parsers to parse the non-option argument VAL, at the current
 648    position, returning any error.  The state NEXT pointer is assumed to have
 649    been adjusted (by getopt) to point after this argument; this function will
 650    adjust it correctly to reflect however many args actually end up being
 651    consumed.  */
 652 static error_t
 653 parser_parse_arg (struct parser *parser, char *val)
 654 {
 655   /* Save the starting value of NEXT, first adjusting it so that the arg
 656      we're parsing is again the front of the arg vector.  */
 657   int index = --parser->state.next;
 658   error_t err = EBADKEY;
 659   struct group *group;
 660   int key = 0;                  /* Which of ARGP_KEY_ARG[S] we used.  */
 661
 662   /* Try to parse the argument in each parser.  */
 663   for (group = parser->groups
 664        ; group < parser->egroup && err == EBADKEY
 665        ; group++)
 666     {
 667       parser->state.next++;     /* For ARGP_KEY_ARG, consume the arg.  */
 668       key = ARGP_KEY_ARG;
 669       err = group_parse (group, &parser->state, key, val);
 670
 671       if (err == EBADKEY)
 672         /* This parser doesn't like ARGP_KEY_ARG; try ARGP_KEY_ARGS instead. */
 673         {
 674           parser->state.next--; /* For ARGP_KEY_ARGS, put back the arg.  */
 675           key = ARGP_KEY_ARGS;
 676           err = group_parse (group, &parser->state, key, 0);
 677         }
 678     }
 679
 680   if (! err)
 681     {
 682       if (key == ARGP_KEY_ARGS)
 683         /* The default for ARGP_KEY_ARGS is to assume that if NEXT isn't
 684            changed by the user, *all* arguments should be considered
 685            consumed.  */
 686         parser->state.next = parser->state.argc;
 687
 688       if (parser->state.next > index)
 689         /* Remember that we successfully processed a non-option
 690            argument -- but only if the user hasn't gotten tricky and set
 691            the clock back.  */
 692         (--group)->args_processed += (parser->state.next - index);
 693       else
 694         /* The user wants to reparse some args, give getopt another try.  */
 695         parser->try_getopt = 1;
 696     }
 697
 698   return err;
 699 }
 700 \f
 701 /* Call the user parsers to parse the option OPT, with argument VAL, at the
 702    current position, returning any error.  */
 703 static error_t
 704 parser_parse_opt (struct parser *parser, int opt, char *val)
 705 {
 706   /* The group key encoded in the high bits; 0 for short opts or
 707      group_number + 1 for long opts.  */
 708   int group_key = opt >> USER_BITS;
 709   error_t err = EBADKEY;
 710
 711   if (group_key == 0)
 712     /* A short option.  By comparing OPT's position in SHORT_OPTS to the
 713        various starting positions in each group's SHORT_END field, we can
 714        determine which group OPT came from.  */
 715     {
 716       struct group *group;
 717       char *short_index = strchr (parser->short_opts, opt);
 718
 719       if (short_index)
 720         for (group = parser->groups; group < parser->egroup; group++)
 721           if (group->short_end > short_index)
 722             {
 723               err = group_parse (group, &parser->state, opt,
 724                                  parser->opt_data.optarg);
 725               break;
 726             }
 727     }
 728   else
 729     /* A long option.  We use shifts instead of masking for extracting
 730        the user value in order to preserve the sign.  */
 731     err =
 732       group_parse (&parser->groups[group_key - 1], &parser->state,
 733                    (opt << GROUP_BITS) >> GROUP_BITS,
 734                    parser->opt_data.optarg);
 735
 736   if (err == EBADKEY)
 737     /* At least currently, an option not recognized is an error in the
 738        parser, because we pre-compute which parser is supposed to deal
 739        with each option.  */
 740     {
 741       static const char bad_key_err[] =
 742         N_("(PROGRAM ERROR) Option should have been recognized!?");
 743       if (group_key == 0)
 744         __argp_error (&parser->state, "-%c: %s", opt,
 745                       dgettext (parser->argp->argp_domain, bad_key_err));
 746       else
 747         {
 748           struct option *long_opt = parser->long_opts;
 749           while (long_opt->val != opt && long_opt->name)
 750             long_opt++;
 751           __argp_error (&parser->state, "--%s: %s",
 752                         long_opt->name ? long_opt->name : "???",
 753                         dgettext (parser->argp->argp_domain, bad_key_err));
 754         }
 755     }
 756
 757   return err;
 758 }
 759 \f
 760 /* Parse the next argument in PARSER (as indicated by PARSER->state.next).
 761    Any error from the parsers is returned, and *ARGP_EBADKEY indicates
 762    whether a value of EBADKEY is due to an unrecognized argument (which is
 763    generally not fatal).  */
 764 static error_t
 765 parser_parse_next (struct parser *parser, int *arg_ebadkey)
 766 {
 767   int opt;
 768   error_t err = 0;
 769
 770   if (parser->state.quoted && parser->state.next < parser->state.quoted)
 771     /* The next argument pointer has been moved to before the quoted
 772        region, so pretend we never saw the quoting `--', and give getopt
 773        another chance.  If the user hasn't removed it, getopt will just
 774        process it again.  */
 775     parser->state.quoted = 0;
 776
 777   if (parser->try_getopt && !parser->state.quoted)
 778     /* Give getopt a chance to parse this.  */
 779     {
 780       /* Put it back in OPTIND for getopt.  */
 781       parser->opt_data.optind = parser->state.next;
 782       /* Distinguish KEY_ERR from a real option.  */
 783       parser->opt_data.optopt = KEY_END;
 784       if (parser->state.flags & ARGP_LONG_ONLY)
 785         opt = _getopt_long_only_r (parser->state.argc, parser->state.argv,
 786                                    parser->short_opts, parser->long_opts, 0,
 787                                    &parser->opt_data);
 788       else
 789         opt = _getopt_long_r (parser->state.argc, parser->state.argv,
 790                               parser->short_opts, parser->long_opts, 0,
 791                               &parser->opt_data);
 792       /* And see what getopt did.  */
 793       parser->state.next = parser->opt_data.optind;
 794
 795       if (opt == KEY_END)
 796         /* Getopt says there are no more options, so stop using
 797            getopt; we'll continue if necessary on our own.  */
 798         {
 799           parser->try_getopt = 0;
 800           if (parser->state.next > 1
 801               && strcmp (parser->state.argv[parser->state.next - 1], QUOTE)
 802                    == 0)
 803             /* Not only is this the end of the options, but it's a
 804                `quoted' region, which may have args that *look* like
 805                options, so we definitely shouldn't try to use getopt past
 806                here, whatever happens.  */
 807             parser->state.quoted = parser->state.next;
 808         }
 809       else if (opt == KEY_ERR && parser->opt_data.optopt != KEY_END)
 810         /* KEY_ERR can have the same value as a valid user short
 811            option, but in the case of a real error, getopt sets OPTOPT
 812            to the offending character, which can never be KEY_END.  */
 813         {
 814           *arg_ebadkey = 0;
 815           return EBADKEY;
 816         }
 817     }
 818   else
 819     opt = KEY_END;
 820
 821   if (opt == KEY_END)
 822     {
 823       /* We're past what getopt considers the options.  */
 824       if (parser->state.next >= parser->state.argc
 825           || (parser->state.flags & ARGP_NO_ARGS))
 826         /* Indicate that we're done.  */
 827         {
 828           *arg_ebadkey = 1;
 829           return EBADKEY;
 830         }
 831       else
 832         /* A non-option arg; simulate what getopt might have done.  */
 833         {
 834           opt = KEY_ARG;
 835           parser->opt_data.optarg = parser->state.argv[parser->state.next++];
 836         }
 837     }
 838
 839   if (opt == KEY_ARG)
 840     /* A non-option argument; try each parser in turn.  */
 841     err = parser_parse_arg (parser, parser->opt_data.optarg);
 842   else
 843     err = parser_parse_opt (parser, opt, parser->opt_data.optarg);
 844
 845   if (err == EBADKEY)
 846     *arg_ebadkey = (opt == KEY_END || opt == KEY_ARG);
 847
 848   return err;
 849 }
 850 \f
 851 /* Parse the options strings in ARGC & ARGV according to the argp in ARGP.
 852    FLAGS is one of the ARGP_ flags above.  If END_INDEX is non-NULL, the
 853    index in ARGV of the first unparsed option is returned in it.  If an
 854    unknown option is present, EINVAL is returned; if some parser routine
 855    returned a non-zero value, it is returned; otherwise 0 is returned.  */
 856 error_t
 857 __argp_parse (const struct argp *argp, int argc, char **argv, unsigned flags,
 858               int *end_index, void *input)
 859 {
 860   error_t err;
 861   struct parser parser;
 862
 863   /* If true, then err == EBADKEY is a result of a non-option argument failing
 864      to be parsed (which in some cases isn't actually an error).  */
 865   int arg_ebadkey = 0;
 866
 867   if (! (flags & ARGP_NO_HELP))
 868     /* Add our own options.  */
 869     {
 870       struct argp_child *child = alloca (4 * sizeof (struct argp_child));
 871       struct argp *top_argp = alloca (sizeof (struct argp));
 872
 873       /* TOP_ARGP has no options, it just serves to group the user & default
 874          argps.  */
 875       memset (top_argp, 0, sizeof (*top_argp));
 876       top_argp->children = child;
 877
 878       memset (child, 0, 4 * sizeof (struct argp_child));
 879
 880       if (argp)
 881         (child++)->argp = argp;
 882       (child++)->argp = &argp_default_argp;
 883       if (argp_program_version || argp_program_version_hook)
 884         (child++)->argp = &argp_version_argp;
 885       child->argp = 0;
 886
 887       argp = top_argp;
 888     }
 889
 890   /* Construct a parser for these arguments.  */
 891   err = parser_init (&parser, argp, argc, argv, flags, input);
 892
 893   if (! err)
 894     /* Parse! */
 895     {
 896       while (! err)
 897         err = parser_parse_next (&parser, &arg_ebadkey);
 898       err = parser_finalize (&parser, err, arg_ebadkey, end_index);
 899     }
 900
 901   return err;
 902 }
 903 #ifdef weak_alias
 904 weak_alias (__argp_parse, argp_parse)
 905 #endif
 906 \f
 907 /* Return the input field for ARGP in the parser corresponding to STATE; used
 908    by the help routines.  */
 909 void *
 910 __argp_input (const struct argp *argp, const struct argp_state *state)
 911 {
 912   if (state)
 913     {
 914       struct group *group;
 915       struct parser *parser = state->pstate;
 916
 917       for (group = parser->groups; group < parser->egroup; group++)
 918         if (group->argp == argp)
 919           return group->input;
 920     }
 921
 922   return 0;
 923 }
 924 #ifdef weak_alias
 925 weak_alias (__argp_input, _argp_input)
 926 #endif