maint/gnulib/lib/argp-parse.c

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

DEFINITIONS
