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