1 /* Hierarchial argument parsing, layered over getopt
2 Copyright (C) 1995-2000, 2002, 2003, 2004 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Written by Miles Bader <miles@gnu.ai.mit.edu>.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License along
17 with this program; if not, write to the Free Software Foundation,
18 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
31 #include <getopt_int.h>
36 # define dgettext(domain, msgid) \
37 INTUSE(__dcgettext) (domain, msgid, LC_MESSAGES)
41 #define N_(msgid) (msgid)
44 #include "argp-namefrob.h"
46 #define alignof(type) offsetof (struct { char c; type x; }, x)
47 #define alignto(n, d) ((((n) + (d) - 1) / (d)) * (d))
49 /* Getopt return values. */
50 #define KEY_END (-1) /* The end of the options. */
51 #define KEY_ARG 1 /* A non-option argument. */
52 #define KEY_ERR '?' /* An error parsing the options. */
54 /* The meta-argument used to prevent any further arguments being interpreted
58 /* The number of bits we steal in a long-option value for our own use. */
59 #define GROUP_BITS CHAR_BIT
61 /* The number of bits available for the user value. */
62 #define USER_BITS ((sizeof ((struct option *)0)->val * CHAR_BIT) - GROUP_BITS)
63 #define USER_MASK ((1 << USER_BITS) - 1)
65 /* EZ alias for ARGP_ERR_UNKNOWN. */
66 #define EBADKEY ARGP_ERR_UNKNOWN
68 /* Default options. */
70 /* When argp is given the --HANG switch, _ARGP_HANG is set and argp will sleep
71 for one second intervals, decrementing _ARGP_HANG until it's zero. Thus
72 you can force the program to continue by attaching a debugger and setting
74 static volatile int _argp_hang;
76 #define OPT_PROGNAME -2
80 static const struct argp_option argp_default_options[] =
82 {"help", '?', 0, 0, N_("Give this help list"), -1},
83 {"usage", OPT_USAGE, 0, 0, N_("Give a short usage message"), 0},
84 {"program-name",OPT_PROGNAME,"NAME", OPTION_HIDDEN, N_("Set the program name"), 0},
85 {"HANG", OPT_HANG, "SECS", OPTION_ARG_OPTIONAL | OPTION_HIDDEN,
86 N_("Hang for SECS seconds (default 3600)"), 0},
87 {NULL, 0, 0, 0, NULL, 0}
91 argp_default_parser (int key, char *arg, struct argp_state *state)
96 __argp_state_help (state, state->out_stream, ARGP_HELP_STD_HELP);
99 __argp_state_help (state, state->out_stream,
100 ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
103 case OPT_PROGNAME: /* Set the program name. */
104 #if defined _LIBC || HAVE_DECL_PROGRAM_INVOCATION_NAME
105 program_invocation_name = arg;
107 /* [Note that some systems only have PROGRAM_INVOCATION_SHORT_NAME (aka
108 __PROGNAME), in which case, PROGRAM_INVOCATION_NAME is just defined
109 to be that, so we have to be a bit careful here.] */
111 /* Update what we use for messages. */
112 state->name = strrchr (arg, '/');
118 #if defined _LIBC || HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME
119 program_invocation_short_name = state->name;
122 if ((state->flags & (ARGP_PARSE_ARGV0 | ARGP_NO_ERRS))
124 /* Update what getopt uses too. */
125 state->argv[0] = arg;
130 _argp_hang = atoi (arg ? arg : "3600");
131 while (_argp_hang-- > 0)
141 static const struct argp argp_default_argp =
142 {argp_default_options, &argp_default_parser, NULL, NULL, NULL, NULL, "libc"};
145 static const struct argp_option argp_version_options[] =
147 {"version", 'V', 0, 0, N_("Print program version"), -1},
148 {NULL, 0, 0, 0, NULL, 0}
152 argp_version_parser (int key, char *arg, struct argp_state *state)
157 if (argp_program_version_hook)
158 (*argp_program_version_hook) (state->out_stream, state);
159 else if (argp_program_version)
160 fprintf (state->out_stream, "%s\n", argp_program_version);
162 __argp_error (state, dgettext (state->root_argp->argp_domain,
163 "(PROGRAM ERROR) No version known!?"));
164 if (! (state->flags & ARGP_NO_EXIT))
173 static const struct argp argp_version_argp =
174 {argp_version_options, &argp_version_parser, NULL, NULL, NULL, NULL, "libc"};
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. */
180 find_long_option (struct option *long_options, const char *name)
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;
189 return l - long_options;
195 /* The state of a `group' during parsing. Each group corresponds to a
196 particular argp structure from the tree of such descending from the top
197 level argp passed to argp_parse. */
200 /* This group's parsing function. */
201 argp_parser_t parser;
203 /* Which argp this group is from. */
204 const struct argp *argp;
206 /* Points to the point in SHORT_OPTS corresponding to the end of the short
207 options for this group. We use it to determine from which group a
208 particular short options is from. */
211 /* The number of non-option args sucessfully handled by this parser. */
212 unsigned args_processed;
214 /* This group's parser's parent's group. */
215 struct group *parent;
216 unsigned parent_index; /* And the our position in the parent. */
218 /* These fields are swapped into and out of the state structure when
219 calling this group's parser. */
220 void *input, **child_inputs;
224 /* Call GROUP's parser with KEY and ARG, swapping any group-specific info
225 from STATE before calling, and back into state afterwards. If GROUP has
226 no parser, EBADKEY is returned. */
228 group_parse (struct group *group, struct argp_state *state, int key, char *arg)
233 state->hook = group->hook;
234 state->input = group->input;
235 state->child_inputs = group->child_inputs;
236 state->arg_num = group->args_processed;
237 err = (*group->parser)(key, arg, state);
238 group->hook = state->hook;
247 const struct argp *argp;
249 /* SHORT_OPTS is the getopt short options string for the union of all the
250 groups of options. */
252 /* LONG_OPTS is the array of getop long option structures for the union of
253 all the groups of options. */
254 struct option *long_opts;
255 /* OPT_DATA is the getopt data used for the re-entrant getopt. */
256 struct _getopt_data opt_data;
258 /* States of the various parsing groups. */
259 struct group *groups;
260 /* The end of the GROUPS array. */
261 struct group *egroup;
262 /* An vector containing storage for the CHILD_INPUTS field in all groups. */
265 /* True if we think using getopt is still useful; if false, then
266 remaining arguments are just passed verbatim with ARGP_KEY_ARG. This is
267 cleared whenever getopt returns KEY_END, but may be set again if the user
268 moves the next argument pointer backwards. */
271 /* State block supplied to parsing routines. */
272 struct argp_state state;
274 /* Memory used by this parser. */
278 /* The next usable entries in the various parser tables being filled in by
280 struct parser_convert_state
282 struct parser *parser;
284 struct option *long_end;
285 void **child_inputs_end;
288 /* Converts all options in ARGP (which is put in GROUP) and ancestors
289 into getopt options stored in SHORT_OPTS and LONG_OPTS; SHORT_END and
290 CVT->LONG_END are the points at which new options are added. Returns the
291 next unused group entry. CVT holds state used during the conversion. */
292 static struct group *
293 convert_options (const struct argp *argp,
294 struct group *parent, unsigned parent_index,
295 struct group *group, struct parser_convert_state *cvt)
297 /* REAL is the most recent non-alias value of OPT. */
298 const struct argp_option *real = argp->options;
299 const struct argp_child *children = argp->children;
301 if (real || argp->parser)
303 const struct argp_option *opt;
306 for (opt = real; !__option_is_end (opt); opt++)
308 if (! (opt->flags & OPTION_ALIAS))
309 /* OPT isn't an alias, so we can use values from it. */
312 if (! (real->flags & OPTION_DOC))
313 /* A real option (not just documentation). */
315 if (__option_is_short (opt))
316 /* OPT can be used as a short option. */
318 *cvt->short_end++ = opt->key;
321 *cvt->short_end++ = ':';
322 if (real->flags & OPTION_ARG_OPTIONAL)
323 *cvt->short_end++ = ':';
325 *cvt->short_end = '\0'; /* keep 0 terminated */
329 && find_long_option (cvt->parser->long_opts, opt->name) < 0)
330 /* OPT can be used as a long option. */
332 cvt->long_end->name = opt->name;
333 cvt->long_end->has_arg =
335 ? (real->flags & OPTION_ARG_OPTIONAL
339 cvt->long_end->flag = 0;
340 /* we add a disambiguating code to all the user's
341 values (which is removed before we actually call
342 the function to parse the value); this means that
343 the user loses use of the high 8 bits in all his
344 values (the sign of the lower bits is preserved
347 ((opt->key | real->key) & USER_MASK)
348 + (((group - cvt->parser->groups) + 1) << USER_BITS);
350 /* Keep the LONG_OPTS list terminated. */
351 (++cvt->long_end)->name = NULL;
356 group->parser = argp->parser;
358 group->short_end = cvt->short_end;
359 group->args_processed = 0;
360 group->parent = parent;
361 group->parent_index = parent_index;
364 group->child_inputs = 0;
367 /* Assign GROUP's CHILD_INPUTS field some space from
368 CVT->child_inputs_end.*/
370 unsigned num_children = 0;
371 while (children[num_children].argp)
373 group->child_inputs = cvt->child_inputs_end;
374 cvt->child_inputs_end += num_children;
385 while (children->argp)
387 convert_options (children++->argp, parent, index++, group, cvt);
393 /* Find the merged set of getopt options, with keys appropiately prefixed. */
395 parser_convert (struct parser *parser, const struct argp *argp, int flags)
397 struct parser_convert_state cvt;
400 cvt.short_end = parser->short_opts;
401 cvt.long_end = parser->long_opts;
402 cvt.child_inputs_end = parser->child_inputs;
404 if (flags & ARGP_IN_ORDER)
405 *cvt.short_end++ = '-';
406 else if (flags & ARGP_NO_ARGS)
407 *cvt.short_end++ = '+';
408 *cvt.short_end = '\0';
410 cvt.long_end->name = NULL;
415 parser->egroup = convert_options (argp, 0, 0, parser->groups, &cvt);
417 parser->egroup = parser->groups; /* No parsers at all! */
420 /* Lengths of various parser fields which we will allocated. */
423 size_t short_len; /* Getopt short options string. */
424 size_t long_len; /* Getopt long options vector. */
425 size_t num_groups; /* Group structures we allocate. */
426 size_t num_child_inputs; /* Child input slots. */
429 /* For ARGP, increments the NUM_GROUPS field in SZS by the total number of
430 argp structures descended from it, and the SHORT_LEN & LONG_LEN fields by
431 the maximum lengths of the resulting merged getopt short options string and
432 long-options array, respectively. */
434 calc_sizes (const struct argp *argp, struct parser_sizes *szs)
436 const struct argp_child *child = argp->children;
437 const struct argp_option *opt = argp->options;
439 if (opt || argp->parser)
445 while (!__option_is_end (opt++))
447 szs->short_len += num_opts * 3; /* opt + up to 2 `:'s */
448 szs->long_len += num_opts;
455 calc_sizes ((child++)->argp, szs);
456 szs->num_child_inputs++;
460 /* Initializes PARSER to parse ARGP in a manner described by FLAGS. */
462 parser_init (struct parser *parser, const struct argp *argp,
463 int argc, char **argv, int flags, void *input)
467 struct parser_sizes szs;
468 struct _getopt_data opt_data = _GETOPT_DATA_INITIALIZER;
475 szs.short_len = (flags & ARGP_NO_ARGS) ? 0 : 1;
478 szs.num_child_inputs = 0;
481 calc_sizes (argp, &szs);
483 /* Lengths of the various bits of storage used by PARSER. */
484 glen = (szs.num_groups + 1) * sizeof (struct group);
485 clen = szs.num_child_inputs * sizeof (void *);
486 llen = (szs.long_len + 1) * sizeof (struct option);
487 slen = szs.short_len + 1;
489 /* Sums of previous lengths, properly aligned. There's no need to
490 align gsum, since struct group is aligned at least as strictly as
491 void * (since it contains a void * member). And there's no need
492 to align lsum, since struct option is aligned at least as
495 csum = alignto (gsum + clen, alignof (struct option));
499 parser->storage = malloc (ssum);
500 if (! parser->storage)
503 storage = parser->storage;
504 parser->groups = parser->storage;
505 parser->child_inputs = (void **) (storage + gsum);
506 parser->long_opts = (struct option *) (storage + csum);
507 parser->short_opts = storage + lsum;
508 parser->opt_data = opt_data;
510 memset (parser->child_inputs, 0, clen);
511 parser_convert (parser, argp, flags);
513 memset (&parser->state, 0, sizeof (struct argp_state));
514 parser->state.root_argp = parser->argp;
515 parser->state.argc = argc;
516 parser->state.argv = argv;
517 parser->state.flags = flags;
518 parser->state.err_stream = stderr;
519 parser->state.out_stream = stdout;
520 parser->state.next = 0; /* Tell getopt to initialize. */
521 parser->state.pstate = parser;
523 parser->try_getopt = 1;
525 /* Call each parser for the first time, giving it a chance to propagate
526 values to child parsers. */
527 if (parser->groups < parser->egroup)
528 parser->groups->input = input;
529 for (group = parser->groups;
530 group < parser->egroup && (!err || err == EBADKEY);
534 /* If a child parser, get the initial input value from the parent. */
535 group->input = group->parent->child_inputs[group->parent_index];
538 && group->argp->children && group->argp->children->argp)
539 /* For the special case where no parsing function is supplied for an
540 argp, propagate its input to its first child, if any (this just
541 makes very simple wrapper argps more convenient). */
542 group->child_inputs[0] = group->input;
544 err = group_parse (group, &parser->state, ARGP_KEY_INIT, 0);
547 err = 0; /* Some parser didn't understand. */
552 if (parser->state.flags & ARGP_NO_ERRS)
554 parser->opt_data.opterr = 0;
555 if (parser->state.flags & ARGP_PARSE_ARGV0)
556 /* getopt always skips ARGV[0], so we have to fake it out. As long
557 as OPTERR is 0, then it shouldn't actually try to access it. */
558 parser->state.argv--, parser->state.argc++;
561 parser->opt_data.opterr = 1; /* Print error messages. */
563 if (parser->state.argv == argv && argv[0])
564 /* There's an argv[0]; use it for messages. */
566 char *short_name = strrchr (argv[0], '/');
567 parser->state.name = short_name ? short_name + 1 : argv[0];
570 parser->state.name = __argp_short_program_name ();
575 /* Free any storage consumed by PARSER (but not PARSER itself). */
577 parser_finalize (struct parser *parser,
578 error_t err, int arg_ebadkey, int *end_index)
582 if (err == EBADKEY && arg_ebadkey)
583 /* Suppress errors generated by unparsed arguments. */
588 if (parser->state.next == parser->state.argc)
589 /* We successfully parsed all arguments! Call all the parsers again,
590 just a few more times... */
592 for (group = parser->groups;
593 group < parser->egroup && (!err || err==EBADKEY);
595 if (group->args_processed == 0)
596 err = group_parse (group, &parser->state, ARGP_KEY_NO_ARGS, 0);
597 for (group = parser->egroup - 1;
598 group >= parser->groups && (!err || err==EBADKEY);
600 err = group_parse (group, &parser->state, ARGP_KEY_END, 0);
603 err = 0; /* Some parser didn't understand. */
605 /* Tell the user that all arguments are parsed. */
607 *end_index = parser->state.next;
610 /* Return any remaining arguments to the user. */
611 *end_index = parser->state.next;
613 /* No way to return the remaining arguments, they must be bogus. */
615 if (!(parser->state.flags & ARGP_NO_ERRS)
616 && parser->state.err_stream)
617 fprintf (parser->state.err_stream,
618 dgettext (parser->argp->argp_domain,
619 "%s: Too many arguments\n"),
625 /* Okay, we're all done, with either an error or success; call the parsers
626 to indicate which one. */
630 /* Maybe print an error message. */
632 /* An appropriate message describing what the error was should have
633 been printed earlier. */
634 __argp_state_help (&parser->state, parser->state.err_stream,
637 /* Since we didn't exit, give each parser an error indication. */
638 for (group = parser->groups; group < parser->egroup; group++)
639 group_parse (group, &parser->state, ARGP_KEY_ERROR, 0);
642 /* Notify parsers of success, and propagate back values from parsers. */
644 /* We pass over the groups in reverse order so that child groups are
645 given a chance to do there processing before passing back a value to
647 for (group = parser->egroup - 1
648 ; group >= parser->groups && (!err || err == EBADKEY)
650 err = group_parse (group, &parser->state, ARGP_KEY_SUCCESS, 0);
652 err = 0; /* Some parser didn't understand. */
655 /* Call parsers once more, to do any final cleanup. Errors are ignored. */
656 for (group = parser->egroup - 1; group >= parser->groups; group--)
657 group_parse (group, &parser->state, ARGP_KEY_FINI, 0);
662 free (parser->storage);
667 /* Call the user parsers to parse the non-option argument VAL, at the current
668 position, returning any error. The state NEXT pointer is assumed to have
669 been adjusted (by getopt) to point after this argument; this function will
670 adjust it correctly to reflect however many args actually end up being
673 parser_parse_arg (struct parser *parser, char *val)
675 /* Save the starting value of NEXT, first adjusting it so that the arg
676 we're parsing is again the front of the arg vector. */
677 int index = --parser->state.next;
678 error_t err = EBADKEY;
680 int key = 0; /* Which of ARGP_KEY_ARG[S] we used. */
682 /* Try to parse the argument in each parser. */
683 for (group = parser->groups
684 ; group < parser->egroup && err == EBADKEY
687 parser->state.next++; /* For ARGP_KEY_ARG, consume the arg. */
689 err = group_parse (group, &parser->state, key, val);
692 /* This parser doesn't like ARGP_KEY_ARG; try ARGP_KEY_ARGS instead. */
694 parser->state.next--; /* For ARGP_KEY_ARGS, put back the arg. */
696 err = group_parse (group, &parser->state, key, 0);
702 if (key == ARGP_KEY_ARGS)
703 /* The default for ARGP_KEY_ARGS is to assume that if NEXT isn't
704 changed by the user, *all* arguments should be considered
706 parser->state.next = parser->state.argc;
708 if (parser->state.next > index)
709 /* Remember that we successfully processed a non-option
710 argument -- but only if the user hasn't gotten tricky and set
712 (--group)->args_processed += (parser->state.next - index);
714 /* The user wants to reparse some args, give getopt another try. */
715 parser->try_getopt = 1;
721 /* Call the user parsers to parse the option OPT, with argument VAL, at the
722 current position, returning any error. */
724 parser_parse_opt (struct parser *parser, int opt, char *val)
726 /* The group key encoded in the high bits; 0 for short opts or
727 group_number + 1 for long opts. */
728 int group_key = opt >> USER_BITS;
729 error_t err = EBADKEY;
732 /* A short option. By comparing OPT's position in SHORT_OPTS to the
733 various starting positions in each group's SHORT_END field, we can
734 determine which group OPT came from. */
737 char *short_index = strchr (parser->short_opts, opt);
740 for (group = parser->groups; group < parser->egroup; group++)
741 if (group->short_end > short_index)
743 err = group_parse (group, &parser->state, opt,
744 parser->opt_data.optarg);
749 /* A long option. We use shifts instead of masking for extracting
750 the user value in order to preserve the sign. */
752 group_parse (&parser->groups[group_key - 1], &parser->state,
753 (opt << GROUP_BITS) >> GROUP_BITS,
754 parser->opt_data.optarg);
757 /* At least currently, an option not recognized is an error in the
758 parser, because we pre-compute which parser is supposed to deal
761 static const char bad_key_err[] =
762 N_("(PROGRAM ERROR) Option should have been recognized!?");
764 __argp_error (&parser->state, "-%c: %s", opt,
765 dgettext (parser->argp->argp_domain, bad_key_err));
768 struct option *long_opt = parser->long_opts;
769 while (long_opt->val != opt && long_opt->name)
771 __argp_error (&parser->state, "--%s: %s",
772 long_opt->name ? long_opt->name : "???",
773 dgettext (parser->argp->argp_domain, bad_key_err));
780 /* Parse the next argument in PARSER (as indicated by PARSER->state.next).
781 Any error from the parsers is returned, and *ARGP_EBADKEY indicates
782 whether a value of EBADKEY is due to an unrecognized argument (which is
783 generally not fatal). */
785 parser_parse_next (struct parser *parser, int *arg_ebadkey)
790 if (parser->state.quoted && parser->state.next < parser->state.quoted)
791 /* The next argument pointer has been moved to before the quoted
792 region, so pretend we never saw the quoting `--', and give getopt
793 another chance. If the user hasn't removed it, getopt will just
795 parser->state.quoted = 0;
797 if (parser->try_getopt && !parser->state.quoted)
798 /* Give getopt a chance to parse this. */
800 /* Put it back in OPTIND for getopt. */
801 parser->opt_data.optind = parser->state.next;
802 /* Distinguish KEY_ERR from a real option. */
803 parser->opt_data.optopt = KEY_END;
804 if (parser->state.flags & ARGP_LONG_ONLY)
805 opt = _getopt_long_only_r (parser->state.argc, parser->state.argv,
806 parser->short_opts, parser->long_opts, 0,
809 opt = _getopt_long_r (parser->state.argc, parser->state.argv,
810 parser->short_opts, parser->long_opts, 0,
812 /* And see what getopt did. */
813 parser->state.next = parser->opt_data.optind;
816 /* Getopt says there are no more options, so stop using
817 getopt; we'll continue if necessary on our own. */
819 parser->try_getopt = 0;
820 if (parser->state.next > 1
821 && strcmp (parser->state.argv[parser->state.next - 1], QUOTE)
823 /* Not only is this the end of the options, but it's a
824 `quoted' region, which may have args that *look* like
825 options, so we definitely shouldn't try to use getopt past
826 here, whatever happens. */
827 parser->state.quoted = parser->state.next;
829 else if (opt == KEY_ERR && parser->opt_data.optopt != KEY_END)
830 /* KEY_ERR can have the same value as a valid user short
831 option, but in the case of a real error, getopt sets OPTOPT
832 to the offending character, which can never be KEY_END. */
843 /* We're past what getopt considers the options. */
844 if (parser->state.next >= parser->state.argc
845 || (parser->state.flags & ARGP_NO_ARGS))
846 /* Indicate that we're done. */
852 /* A non-option arg; simulate what getopt might have done. */
855 parser->opt_data.optarg = parser->state.argv[parser->state.next++];
860 /* A non-option argument; try each parser in turn. */
861 err = parser_parse_arg (parser, parser->opt_data.optarg);
863 err = parser_parse_opt (parser, opt, parser->opt_data.optarg);
866 *arg_ebadkey = (opt == KEY_END || opt == KEY_ARG);
871 /* Parse the options strings in ARGC & ARGV according to the argp in ARGP.
872 FLAGS is one of the ARGP_ flags above. If END_INDEX is non-NULL, the
873 index in ARGV of the first unparsed option is returned in it. If an
874 unknown option is present, EINVAL is returned; if some parser routine
875 returned a non-zero value, it is returned; otherwise 0 is returned. */
877 __argp_parse (const struct argp *argp, int argc, char **argv, unsigned flags,
878 int *end_index, void *input)
881 struct parser parser;
883 /* If true, then err == EBADKEY is a result of a non-option argument failing
884 to be parsed (which in some cases isn't actually an error). */
887 if (! (flags & ARGP_NO_HELP))
888 /* Add our own options. */
890 struct argp_child *child = alloca (4 * sizeof (struct argp_child));
891 struct argp *top_argp = alloca (sizeof (struct argp));
893 /* TOP_ARGP has no options, it just serves to group the user & default
895 memset (top_argp, 0, sizeof (*top_argp));
896 top_argp->children = child;
898 memset (child, 0, 4 * sizeof (struct argp_child));
901 (child++)->argp = argp;
902 (child++)->argp = &argp_default_argp;
903 if (argp_program_version || argp_program_version_hook)
904 (child++)->argp = &argp_version_argp;
910 /* Construct a parser for these arguments. */
911 err = parser_init (&parser, argp, argc, argv, flags, input);
917 err = parser_parse_next (&parser, &arg_ebadkey);
918 err = parser_finalize (&parser, err, arg_ebadkey, end_index);
924 weak_alias (__argp_parse, argp_parse)
927 /* Return the input field for ARGP in the parser corresponding to STATE; used
928 by the help routines. */
930 __argp_input (const struct argp *argp, const struct argp_state *state)
935 struct parser *parser = state->pstate;
937 for (group = parser->groups; group < parser->egroup; group++)
938 if (group->argp == argp)
945 weak_alias (__argp_input, _argp_input)