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