Don't initialize with 0.
[kopensolaris-gnu/glibc.git] / argp / argp-parse.c
1 /* Hierarchial argument parsing, layered over getopt
2    Copyright (C) 1995, 1996, 1997, 1998, 1999 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 #else
37 # define dgettext(domain, msgid) (msgid)
38 # define gettext(msgid) (msgid)
39 #endif
40 #define N_(msgid) (msgid)
41 #endif
42
43 #if _LIBC - 0
44 #include <bits/libc-lock.h>
45 #else
46 #ifdef HAVE_CTHREADS_H
47 #include <cthreads.h>
48 #endif
49 #endif /* _LIBC */
50
51 #include "argp.h"
52 #include "argp-namefrob.h"
53
54 /* Getopt return values.  */
55 #define KEY_END (-1)            /* The end of the options.  */
56 #define KEY_ARG 1               /* A non-option argument.  */
57 #define KEY_ERR '?'             /* An error parsing the options.  */
58
59 /* The meta-argument used to prevent any further arguments being interpreted
60    as options.  */
61 #define QUOTE "--"
62
63 /* The number of bits we steal in a long-option value for our own use.  */
64 #define GROUP_BITS CHAR_BIT
65
66 /* The number of bits available for the user value.  */
67 #define USER_BITS ((sizeof ((struct option *)0)->val * CHAR_BIT) - GROUP_BITS)
68 #define USER_MASK ((1 << USER_BITS) - 1)
69
70 /* EZ alias for ARGP_ERR_UNKNOWN.  */
71 #define EBADKEY ARGP_ERR_UNKNOWN
72 \f
73 /* Default options.  */
74
75 /* When argp is given the --HANG switch, _ARGP_HANG is set and argp will sleep
76    for one second intervals, decrementing _ARGP_HANG until it's zero.  Thus
77    you can force the program to continue by attaching a debugger and setting
78    it to 0 yourself.  */
79 volatile int _argp_hang;
80
81 #define OPT_PROGNAME    -2
82 #define OPT_USAGE       -3
83 #define OPT_HANG        -4
84
85 static const struct argp_option argp_default_options[] =
86 {
87   {"help",        '?',          0, 0,  N_("Give this help list"), -1},
88   {"usage",       OPT_USAGE,    0, 0,  N_("Give a short usage message")},
89   {"program-name",OPT_PROGNAME,"NAME", OPTION_HIDDEN, N_("Set the program name")},
90   {"HANG",        OPT_HANG,    "SECS", OPTION_ARG_OPTIONAL | OPTION_HIDDEN,
91      N_("Hang for SECS seconds (default 3600)")},
92   {0, 0}
93 };
94
95 static error_t
96 argp_default_parser (int key, char *arg, struct argp_state *state)
97 {
98   switch (key)
99     {
100     case '?':
101       __argp_state_help (state, state->out_stream, ARGP_HELP_STD_HELP);
102       break;
103     case OPT_USAGE:
104       __argp_state_help (state, state->out_stream,
105                        ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
106       break;
107
108     case OPT_PROGNAME:          /* Set the program name.  */
109       program_invocation_name = arg;
110
111       /* [Note that some systems only have PROGRAM_INVOCATION_SHORT_NAME (aka
112          __PROGNAME), in which case, PROGRAM_INVOCATION_NAME is just defined
113          to be that, so we have to be a bit careful here.]  */
114       arg = strrchr (arg, '/');
115       if (arg)
116         program_invocation_short_name = arg + 1;
117       else
118         program_invocation_short_name = program_invocation_name;
119
120       /* Update what we use for messages.  */
121       state->name = program_invocation_short_name;
122
123       if ((state->flags & (ARGP_PARSE_ARGV0 | ARGP_NO_ERRS))
124           == ARGP_PARSE_ARGV0)
125         /* Update what getopt uses too.  */
126         state->argv[0] = program_invocation_name;
127
128       break;
129
130     case OPT_HANG:
131       _argp_hang = atoi (arg ? arg : "3600");
132       while (_argp_hang-- > 0)
133         __sleep (1);
134       break;
135
136     default:
137       return EBADKEY;
138     }
139   return 0;
140 }
141
142 static const struct argp argp_default_argp =
143   {argp_default_options, &argp_default_parser};
144
145 \f
146 static const struct argp_option argp_version_options[] =
147 {
148   {"version",     'V',          0, 0,  N_("Print program version"), -1},
149   {0, 0}
150 };
151
152 static error_t
153 argp_version_parser (int key, char *arg, struct argp_state *state)
154 {
155   switch (key)
156     {
157     case 'V':
158       if (argp_program_version_hook)
159         (*argp_program_version_hook) (state->out_stream, state);
160       else if (argp_program_version)
161         fprintf (state->out_stream, "%s\n", argp_program_version);
162       else
163         __argp_error (state, dgettext (state->root_argp->argp_domain,
164                                        "(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     {
609       if (parser->state.next == parser->state.argc)
610         /* We successfully parsed all arguments!  Call all the parsers again,
611            just a few more times... */
612         {
613           for (group = parser->groups;
614                group < parser->egroup && (!err || err==EBADKEY);
615                group++)
616             if (group->args_processed == 0)
617               err = group_parse (group, &parser->state, ARGP_KEY_NO_ARGS, 0);
618           for (group = parser->groups;
619                group < parser->egroup && (!err || err==EBADKEY);
620                group++)
621             err = group_parse (group, &parser->state, ARGP_KEY_END, 0);
622
623           if (err == EBADKEY)
624             err = 0;            /* Some parser didn't understand.  */
625
626           /* Tell the user that all arguments are parsed.  */
627           if (end_index)
628             *end_index = parser->state.next;
629         }
630       else if (end_index)
631         /* Return any remaining arguments to the user.  */
632         *end_index = parser->state.next;
633       else
634         /* No way to return the remaining arguments, they must be bogus. */
635         {
636           if (!(parser->state.flags & ARGP_NO_ERRS)
637               && parser->state.err_stream)
638             fprintf (parser->state.err_stream,
639                      dgettext (parser->argp->argp_domain,
640                                "%s: Too many arguments\n"),
641                      parser->state.name);
642           err = EBADKEY;
643         }
644     }
645
646   /* Okay, we're all done, with either an error or success; call the parsers
647      to indicate which one.  */
648
649   if (err)
650     {
651       /* Maybe print an error message.  */
652       if (err == EBADKEY)
653         /* An appropriate message describing what the error was should have
654            been printed earlier.  */
655         __argp_state_help (&parser->state, parser->state.err_stream,
656                            ARGP_HELP_STD_ERR);
657
658       /* Since we didn't exit, give each parser an error indication.  */
659       for (group = parser->groups; group < parser->egroup; group++)
660         group_parse (group, &parser->state, ARGP_KEY_ERROR, 0);
661     }
662   else
663     /* Notify parsers of success, and propagate back values from parsers.  */
664     {
665       /* We pass over the groups in reverse order so that child groups are
666          given a chance to do there processing before passing back a value to
667          the parent.  */
668       for (group = parser->egroup - 1
669            ; group >= parser->groups && (!err || err == EBADKEY)
670            ; group--)
671         err = group_parse (group, &parser->state, ARGP_KEY_SUCCESS, 0);
672       if (err == EBADKEY)
673         err = 0;                /* Some parser didn't understand.  */
674     }
675
676   /* Call parsers once more, to do any final cleanup.  Errors are ignored.  */
677   for (group = parser->egroup - 1; group >= parser->groups; group--)
678     group_parse (group, &parser->state, ARGP_KEY_FINI, 0);
679
680   if (err == EBADKEY)
681     err = EINVAL;
682
683   free (parser->storage);
684
685   return err;
686 }
687 \f
688 /* Call the user parsers to parse the non-option argument VAL, at the current
689    position, returning any error.  The state NEXT pointer is assumed to have
690    been adjusted (by getopt) to point after this argument; this function will
691    adjust it correctly to reflect however many args actually end up being
692    consumed.  */
693 static error_t
694 parser_parse_arg (struct parser *parser, char *val)
695 {
696   /* Save the starting value of NEXT, first adjusting it so that the arg
697      we're parsing is again the front of the arg vector.  */
698   int index = --parser->state.next;
699   error_t err = EBADKEY;
700   struct group *group;
701   int key = 0;                  /* Which of ARGP_KEY_ARG[S] we used.  */
702
703   /* Try to parse the argument in each parser.  */
704   for (group = parser->groups
705        ; group < parser->egroup && err == EBADKEY
706        ; group++)
707     {
708       parser->state.next++;     /* For ARGP_KEY_ARG, consume the arg.  */
709       key = ARGP_KEY_ARG;
710       err = group_parse (group, &parser->state, key, val);
711
712       if (err == EBADKEY)
713         /* This parser doesn't like ARGP_KEY_ARG; try ARGP_KEY_ARGS instead. */
714         {
715           parser->state.next--; /* For ARGP_KEY_ARGS, put back the arg.  */
716           key = ARGP_KEY_ARGS;
717           err = group_parse (group, &parser->state, key, 0);
718         }
719     }
720
721   if (! err)
722     {
723       if (key == ARGP_KEY_ARGS)
724         /* The default for ARGP_KEY_ARGS is to assume that if NEXT isn't
725            changed by the user, *all* arguments should be considered
726            consumed.  */
727         parser->state.next = parser->state.argc;
728
729       if (parser->state.next > index)
730         /* Remember that we successfully processed a non-option
731            argument -- but only if the user hasn't gotten tricky and set
732            the clock back.  */
733         (--group)->args_processed += (parser->state.next - index);
734       else
735         /* The user wants to reparse some args, give getopt another try.  */
736         parser->try_getopt = 1;
737     }
738
739   return err;
740 }
741 \f
742 /* Call the user parsers to parse the option OPT, with argument VAL, at the
743    current position, returning any error.  */
744 static error_t
745 parser_parse_opt (struct parser *parser, int opt, char *val)
746 {
747   /* The group key encoded in the high bits; 0 for short opts or
748      group_number + 1 for long opts.  */
749   int group_key = opt >> USER_BITS;
750   error_t err = EBADKEY;
751
752   if (group_key == 0)
753     /* A short option.  By comparing OPT's position in SHORT_OPTS to the
754        various starting positions in each group's SHORT_END field, we can
755        determine which group OPT came from.  */
756     {
757       struct group *group;
758       char *short_index = strchr (parser->short_opts, opt);
759
760       if (short_index)
761         for (group = parser->groups; group < parser->egroup; group++)
762           if (group->short_end > short_index)
763             {
764               err = group_parse (group, &parser->state, opt, optarg);
765               break;
766             }
767     }
768   else
769     /* A long option.  We use shifts instead of masking for extracting
770        the user value in order to preserve the sign.  */
771     err =
772       group_parse (&parser->groups[group_key - 1], &parser->state,
773                    (opt << GROUP_BITS) >> GROUP_BITS, optarg);
774
775   if (err == EBADKEY)
776     /* At least currently, an option not recognized is an error in the
777        parser, because we pre-compute which parser is supposed to deal
778        with each option.  */
779     {
780       static const char bad_key_err[] =
781         N_("(PROGRAM ERROR) Option should have been recognized!?");
782       if (group_key == 0)
783         __argp_error (&parser->state, "-%c: %s", opt,
784                       dgettext (parser->argp->argp_domain, bad_key_err));
785       else
786         {
787           struct option *long_opt = parser->long_opts;
788           while (long_opt->val != opt && long_opt->name)
789             long_opt++;
790           __argp_error (&parser->state, "--%s: %s",
791                         long_opt->name ? long_opt->name : "???",
792                         dgettext (parser->argp->argp_domain, bad_key_err));
793         }
794     }
795
796   return err;
797 }
798 \f
799 /* Parse the next argument in PARSER (as indicated by PARSER->state.next).
800    Any error from the parsers is returned, and *ARGP_EBADKEY indicates
801    whether a value of EBADKEY is due to an unrecognized argument (which is
802    generally not fatal).  */
803 static error_t
804 parser_parse_next (struct parser *parser, int *arg_ebadkey)
805 {
806   int opt;
807   error_t err = 0;
808
809   if (parser->state.quoted && parser->state.next < parser->state.quoted)
810     /* The next argument pointer has been moved to before the quoted
811        region, so pretend we never saw the quoting `--', and give getopt
812        another chance.  If the user hasn't removed it, getopt will just
813        process it again.  */
814     parser->state.quoted = 0;
815
816   if (parser->try_getopt && !parser->state.quoted)
817     /* Give getopt a chance to parse this.  */
818     {
819       optind = parser->state.next; /* Put it back in OPTIND for getopt.  */
820       optopt = KEY_END; /* Distinguish KEY_ERR from a real option.  */
821       if (parser->state.flags & ARGP_LONG_ONLY)
822         opt = getopt_long_only (parser->state.argc, parser->state.argv,
823                                 parser->short_opts, parser->long_opts, 0);
824       else
825         opt = getopt_long (parser->state.argc, parser->state.argv,
826                            parser->short_opts, parser->long_opts, 0);
827       parser->state.next = optind; /* And see what getopt did.  */
828
829       if (opt == KEY_END)
830         /* Getopt says there are no more options, so stop using
831            getopt; we'll continue if necessary on our own.  */
832         {
833           parser->try_getopt = 0;
834           if (parser->state.next > 1
835               && strcmp (parser->state.argv[parser->state.next - 1], QUOTE)
836                    == 0)
837             /* Not only is this the end of the options, but it's a
838                `quoted' region, which may have args that *look* like
839                options, so we definitely shouldn't try to use getopt past
840                here, whatever happens.  */
841             parser->state.quoted = parser->state.next;
842         }
843       else if (opt == KEY_ERR && optopt != KEY_END)
844         /* KEY_ERR can have the same value as a valid user short
845            option, but in the case of a real error, getopt sets OPTOPT
846            to the offending character, which can never be KEY_END.  */
847         {
848           *arg_ebadkey = 0;
849           return EBADKEY;
850         }
851     }
852   else
853     opt = KEY_END;
854
855   if (opt == KEY_END)
856     {
857       /* We're past what getopt considers the options.  */
858       if (parser->state.next >= parser->state.argc
859           || (parser->state.flags & ARGP_NO_ARGS))
860         /* Indicate that we're done.  */
861         {
862           *arg_ebadkey = 1;
863           return EBADKEY;
864         }
865       else
866         /* A non-option arg; simulate what getopt might have done.  */
867         {
868           opt = KEY_ARG;
869           optarg = parser->state.argv[parser->state.next++];
870         }
871     }
872
873   if (opt == KEY_ARG)
874     /* A non-option argument; try each parser in turn.  */
875     err = parser_parse_arg (parser, optarg);
876   else
877     err = parser_parse_opt (parser, opt, optarg);
878
879   if (err == EBADKEY)
880     *arg_ebadkey = (opt == KEY_END || opt == KEY_ARG);
881
882   return err;
883 }
884 \f
885 /* Parse the options strings in ARGC & ARGV according to the argp in ARGP.
886    FLAGS is one of the ARGP_ flags above.  If END_INDEX is non-NULL, the
887    index in ARGV of the first unparsed option is returned in it.  If an
888    unknown option is present, EINVAL is returned; if some parser routine
889    returned a non-zero value, it is returned; otherwise 0 is returned.  */
890 error_t
891 __argp_parse (const struct argp *argp, int argc, char **argv, unsigned flags,
892               int *end_index, void *input)
893 {
894   error_t err;
895   struct parser parser;
896
897   /* If true, then err == EBADKEY is a result of a non-option argument failing
898      to be parsed (which in some cases isn't actually an error).  */
899   int arg_ebadkey = 0;
900
901   if (! (flags & ARGP_NO_HELP))
902     /* Add our own options.  */
903     {
904       struct argp_child *child = alloca (4 * sizeof (struct argp_child));
905       struct argp *top_argp = alloca (sizeof (struct argp));
906
907       /* TOP_ARGP has no options, it just serves to group the user & default
908          argps.  */
909       memset (top_argp, 0, sizeof (*top_argp));
910       top_argp->children = child;
911
912       memset (child, 0, 4 * sizeof (struct argp_child));
913
914       if (argp)
915         (child++)->argp = argp;
916       (child++)->argp = &argp_default_argp;
917       if (argp_program_version || argp_program_version_hook)
918         (child++)->argp = &argp_version_argp;
919       child->argp = 0;
920
921       argp = top_argp;
922     }
923
924   /* Construct a parser for these arguments.  */
925   err = parser_init (&parser, argp, argc, argv, flags, input);
926
927   if (! err)
928     /* Parse! */
929     {
930       while (! err)
931         err = parser_parse_next (&parser, &arg_ebadkey);
932       err = parser_finalize (&parser, err, arg_ebadkey, end_index);
933     }
934
935   return err;
936 }
937 #ifdef weak_alias
938 weak_alias (__argp_parse, argp_parse)
939 #endif
940 \f
941 /* Return the input field for ARGP in the parser corresponding to STATE; used
942    by the help routines.  */
943 void *
944 __argp_input (const struct argp *argp, const struct argp_state *state)
945 {
946   if (state)
947     {
948       struct group *group;
949       struct parser *parser = state->pstate;
950
951       for (group = parser->groups; group < parser->egroup; group++)
952         if (group->argp == argp)
953           return group->input;
954     }
955
956   return 0;
957 }
958 #ifdef weak_alias
959 weak_alias (__argp_input, _argp_input)
960 #endif