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