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