1 /* Hierarchical argument parsing, layered over getopt
2 Copyright (C) 1995-2000, 2002-2004, 2009-2014 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 3 of the License, or
9 (at your option) any later version.
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
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
31 #include <getopt_int.h>
36 # define dgettext(domain, msgid) \
37 INTUSE(__dcgettext) (domain, msgid, LC_MESSAGES)
41 #define N_(msgid) msgid
44 # define ARGP_TEXT_DOMAIN "libc"
46 # ifdef DEFAULT_TEXT_DOMAIN
47 # define ARGP_TEXT_DOMAIN DEFAULT_TEXT_DOMAIN
49 # define ARGP_TEXT_DOMAIN NULL
54 #include "argp-namefrob.h"
56 #define alignto(n, d) ((((n) + (d) - 1) / (d)) * (d))
58 /* Getopt return values. */
59 #define KEY_END (-1) /* The end of the options. */
60 #define KEY_ARG 1 /* A non-option argument. */
61 #define KEY_ERR '?' /* An error parsing the options. */
63 /* The meta-argument used to prevent any further arguments being interpreted
67 /* The number of bits we steal in a long-option value for our own use. */
68 #define GROUP_BITS CHAR_BIT
70 /* The number of bits available for the user value. */
71 #define USER_BITS ((sizeof ((struct option *)0)->val * CHAR_BIT) - GROUP_BITS)
72 #define USER_MASK ((1 << USER_BITS) - 1)
74 /* EZ alias for ARGP_ERR_UNKNOWN. */
75 #define EBADKEY ARGP_ERR_UNKNOWN
77 /* Default options. */
79 /* When argp is given the --HANG switch, _ARGP_HANG is set and argp will sleep
80 for one second intervals, decrementing _ARGP_HANG until it's zero. Thus
81 you can force the program to continue by attaching a debugger and setting
83 static volatile int _argp_hang;
85 #define OPT_PROGNAME -2
89 static const struct argp_option argp_default_options[] =
91 {"help", '?', 0, 0, N_("give this help list"), -1},
92 {"usage", OPT_USAGE, 0, 0, N_("give a short usage message"), 0},
93 {"program-name",OPT_PROGNAME,N_("NAME"), OPTION_HIDDEN, N_("set the program name"), 0},
94 {"HANG", OPT_HANG, N_("SECS"), OPTION_ARG_OPTIONAL | OPTION_HIDDEN,
95 N_("hang for SECS seconds (default 3600)"), 0},
96 {NULL, 0, 0, 0, NULL, 0}
100 argp_default_parser (int key, char *arg, struct argp_state *state)
105 __argp_state_help (state, state->out_stream, ARGP_HELP_STD_HELP);
108 __argp_state_help (state, state->out_stream,
109 ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
112 case OPT_PROGNAME: /* Set the program name. */
113 #if defined _LIBC || HAVE_DECL_PROGRAM_INVOCATION_NAME
114 program_invocation_name = arg;
116 /* [Note that some systems only have PROGRAM_INVOCATION_SHORT_NAME (aka
117 __PROGNAME), in which case, PROGRAM_INVOCATION_NAME is just defined
118 to be that, so we have to be a bit careful here.] */
120 /* Update what we use for messages. */
121 state->name = __argp_base_name (arg);
123 #if defined _LIBC || HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME
124 program_invocation_short_name = state->name;
127 if ((state->flags & (ARGP_PARSE_ARGV0 | ARGP_NO_ERRS))
129 /* Update what getopt uses too. */
130 state->argv[0] = arg;
135 _argp_hang = atoi (arg ? arg : "3600");
136 while (_argp_hang-- > 0)
146 static const struct argp argp_default_argp =
147 {argp_default_options, &argp_default_parser, NULL, NULL, NULL, NULL,
151 static const struct argp_option argp_version_options[] =
153 {"version", 'V', 0, 0, N_("print program version"), -1},
154 {NULL, 0, 0, 0, NULL, 0}
158 argp_version_parser (int key, char *arg, struct argp_state *state)
163 if (argp_program_version_hook)
164 (*argp_program_version_hook) (state->out_stream, state);
165 else if (argp_program_version)
166 fprintf (state->out_stream, "%s\n", argp_program_version);
168 __argp_error (state, "%s",
169 dgettext (ARGP_TEXT_DOMAIN,
170 "(PROGRAM ERROR) No version known!?"));
171 if (! (state->flags & ARGP_NO_EXIT))
180 static const struct argp argp_version_argp =
181 {argp_version_options, &argp_version_parser, NULL, NULL, NULL, NULL,
184 /* Returns the offset into the getopt long options array LONG_OPTIONS of a
185 long option with called NAME, or -1 if none is found. Passing NULL as
186 NAME will return the number of options. */
188 find_long_option (struct option *long_options, const char *name)
190 struct option *l = long_options;
191 while (l->name != NULL)
192 if (name != NULL && strcmp (l->name, name) == 0)
193 return l - long_options;
197 return l - long_options;
203 /* The state of a "group" during parsing. Each group corresponds to a
204 particular argp structure from the tree of such descending from the top
205 level argp passed to argp_parse. */
208 /* This group's parsing function. */
209 argp_parser_t parser;
211 /* Which argp this group is from. */
212 const struct argp *argp;
214 /* Points to the point in SHORT_OPTS corresponding to the end of the short
215 options for this group. We use it to determine from which group a
216 particular short options is from. */
219 /* The number of non-option args successfully handled by this parser. */
220 unsigned args_processed;
222 /* This group's parser's parent's group. */
223 struct group *parent;
224 unsigned parent_index; /* And the our position in the parent. */
226 /* These fields are swapped into and out of the state structure when
227 calling this group's parser. */
228 void *input, **child_inputs;
232 /* Call GROUP's parser with KEY and ARG, swapping any group-specific info
233 from STATE before calling, and back into state afterwards. If GROUP has
234 no parser, EBADKEY is returned. */
236 group_parse (struct group *group, struct argp_state *state, int key, char *arg)
241 state->hook = group->hook;
242 state->input = group->input;
243 state->child_inputs = group->child_inputs;
244 state->arg_num = group->args_processed;
245 err = (*group->parser)(key, arg, state);
246 group->hook = state->hook;
255 const struct argp *argp;
257 /* SHORT_OPTS is the getopt short options string for the union of all the
258 groups of options. */
260 /* LONG_OPTS is the array of getop long option structures for the union of
261 all the groups of options. */
262 struct option *long_opts;
263 /* OPT_DATA is the getopt data used for the re-entrant getopt. */
264 struct _getopt_data opt_data;
266 /* States of the various parsing groups. */
267 struct group *groups;
268 /* The end of the GROUPS array. */
269 struct group *egroup;
270 /* A vector containing storage for the CHILD_INPUTS field in all groups. */
273 /* True if we think using getopt is still useful; if false, then
274 remaining arguments are just passed verbatim with ARGP_KEY_ARG. This is
275 cleared whenever getopt returns KEY_END, but may be set again if the user
276 moves the next argument pointer backwards. */
279 /* State block supplied to parsing routines. */
280 struct argp_state state;
282 /* Memory used by this parser. */
286 /* The next usable entries in the various parser tables being filled in by
288 struct parser_convert_state
290 struct parser *parser;
292 struct option *long_end;
293 void **child_inputs_end;
296 /* Converts all options in ARGP (which is put in GROUP) and ancestors
297 into getopt options stored in SHORT_OPTS and LONG_OPTS; SHORT_END and
298 CVT->LONG_END are the points at which new options are added. Returns the
299 next unused group entry. CVT holds state used during the conversion. */
300 static struct group *
301 convert_options (const struct argp *argp,
302 struct group *parent, unsigned parent_index,
303 struct group *group, struct parser_convert_state *cvt)
305 /* REAL is the most recent non-alias value of OPT. */
306 const struct argp_option *real = argp->options;
307 const struct argp_child *children = argp->children;
309 if (real || argp->parser)
311 const struct argp_option *opt;
314 for (opt = real; !__option_is_end (opt); opt++)
316 if (! (opt->flags & OPTION_ALIAS))
317 /* OPT isn't an alias, so we can use values from it. */
320 if (! (real->flags & OPTION_DOC))
321 /* A real option (not just documentation). */
323 if (__option_is_short (opt))
324 /* OPT can be used as a short option. */
326 *cvt->short_end++ = opt->key;
329 *cvt->short_end++ = ':';
330 if (real->flags & OPTION_ARG_OPTIONAL)
331 *cvt->short_end++ = ':';
333 *cvt->short_end = '\0'; /* keep 0 terminated */
337 && find_long_option (cvt->parser->long_opts, opt->name) < 0)
338 /* OPT can be used as a long option. */
340 cvt->long_end->name = opt->name;
341 cvt->long_end->has_arg =
343 ? (real->flags & OPTION_ARG_OPTIONAL
347 cvt->long_end->flag = 0;
348 /* we add a disambiguating code to all the user's
349 values (which is removed before we actually call
350 the function to parse the value); this means that
351 the user loses use of the high 8 bits in all his
352 values (the sign of the lower bits is preserved
355 ((opt->key ? opt->key : real->key) & USER_MASK)
356 + (((group - cvt->parser->groups) + 1) << USER_BITS);
358 /* Keep the LONG_OPTS list terminated. */
359 (++cvt->long_end)->name = NULL;
364 group->parser = argp->parser;
366 group->short_end = cvt->short_end;
367 group->args_processed = 0;
368 group->parent = parent;
369 group->parent_index = parent_index;
372 group->child_inputs = 0;
375 /* Assign GROUP's CHILD_INPUTS field some space from
376 CVT->child_inputs_end.*/
378 unsigned num_children = 0;
379 while (children[num_children].argp)
381 group->child_inputs = cvt->child_inputs_end;
382 cvt->child_inputs_end += num_children;
393 while (children->argp)
395 convert_options (children++->argp, parent, index++, group, cvt);
401 /* Find the merged set of getopt options, with keys appropriately prefixed. */
403 parser_convert (struct parser *parser, const struct argp *argp, int flags)
405 struct parser_convert_state cvt;
408 cvt.short_end = parser->short_opts;
409 cvt.long_end = parser->long_opts;
410 cvt.child_inputs_end = parser->child_inputs;
412 if (flags & ARGP_IN_ORDER)
413 *cvt.short_end++ = '-';
414 else if (flags & ARGP_NO_ARGS)
415 *cvt.short_end++ = '+';
416 *cvt.short_end = '\0';
418 cvt.long_end->name = NULL;
423 parser->egroup = convert_options (argp, 0, 0, parser->groups, &cvt);
425 parser->egroup = parser->groups; /* No parsers at all! */
428 /* Lengths of various parser fields which we will allocated. */
431 size_t short_len; /* Getopt short options string. */
432 size_t long_len; /* Getopt long options vector. */
433 size_t num_groups; /* Group structures we allocate. */
434 size_t num_child_inputs; /* Child input slots. */
437 /* For ARGP, increments the NUM_GROUPS field in SZS by the total number of
438 argp structures descended from it, and the SHORT_LEN & LONG_LEN fields by
439 the maximum lengths of the resulting merged getopt short options string and
440 long-options array, respectively. */
442 calc_sizes (const struct argp *argp, struct parser_sizes *szs)
444 const struct argp_child *child = argp->children;
445 const struct argp_option *opt = argp->options;
447 if (opt || argp->parser)
453 while (!__option_is_end (opt++))
455 szs->short_len += num_opts * 3; /* opt + up to 2 ':'s */
456 szs->long_len += num_opts;
463 calc_sizes ((child++)->argp, szs);
464 szs->num_child_inputs++;
468 /* Initializes PARSER to parse ARGP in a manner described by FLAGS. */
470 parser_init (struct parser *parser, const struct argp *argp,
471 int argc, char **argv, int flags, void *input)
475 struct parser_sizes szs;
476 struct _getopt_data opt_data = _GETOPT_DATA_INITIALIZER;
483 szs.short_len = (flags & ARGP_NO_ARGS) ? 0 : 1;
486 szs.num_child_inputs = 0;
489 calc_sizes (argp, &szs);
491 /* Lengths of the various bits of storage used by PARSER. */
492 glen = (szs.num_groups + 1) * sizeof (struct group);
493 clen = szs.num_child_inputs * sizeof (void *);
494 llen = (szs.long_len + 1) * sizeof (struct option);
495 slen = szs.short_len + 1;
497 /* Sums of previous lengths, properly aligned. There's no need to
498 align gsum, since struct group is aligned at least as strictly as
499 void * (since it contains a void * member). And there's no need
500 to align lsum, since struct option is aligned at least as
503 csum = alignto (gsum + clen, alignof (struct option));
507 parser->storage = malloc (ssum);
508 if (! parser->storage)
511 storage = parser->storage;
512 parser->groups = parser->storage;
513 parser->child_inputs = (void **) (storage + gsum);
514 parser->long_opts = (struct option *) (storage + csum);
515 parser->short_opts = storage + lsum;
516 parser->opt_data = opt_data;
518 memset (parser->child_inputs, 0, clen);
519 parser_convert (parser, argp, flags);
521 memset (&parser->state, 0, sizeof (struct argp_state));
522 parser->state.root_argp = parser->argp;
523 parser->state.argc = argc;
524 parser->state.argv = argv;
525 parser->state.flags = flags;
526 parser->state.err_stream = stderr;
527 parser->state.out_stream = stdout;
528 parser->state.next = 0; /* Tell getopt to initialize. */
529 parser->state.pstate = parser;
531 parser->try_getopt = 1;
533 /* Call each parser for the first time, giving it a chance to propagate
534 values to child parsers. */
535 if (parser->groups < parser->egroup)
536 parser->groups->input = input;
537 for (group = parser->groups;
538 group < parser->egroup && (!err || err == EBADKEY);
542 /* If a child parser, get the initial input value from the parent. */
543 group->input = group->parent->child_inputs[group->parent_index];
546 && group->argp->children && group->argp->children->argp)
547 /* For the special case where no parsing function is supplied for an
548 argp, propagate its input to its first child, if any (this just
549 makes very simple wrapper argps more convenient). */
550 group->child_inputs[0] = group->input;
552 err = group_parse (group, &parser->state, ARGP_KEY_INIT, 0);
555 err = 0; /* Some parser didn't understand. */
560 if (parser->state.flags & ARGP_NO_ERRS)
562 parser->opt_data.opterr = 0;
563 if (parser->state.flags & ARGP_PARSE_ARGV0)
564 /* getopt always skips ARGV[0], so we have to fake it out. As long
565 as OPTERR is 0, then it shouldn't actually try to access it. */
566 parser->state.argv--, parser->state.argc++;
569 parser->opt_data.opterr = 1; /* Print error messages. */
571 if (parser->state.argv == argv && argv[0])
572 /* There's an argv[0]; use it for messages. */
573 parser->state.name = __argp_base_name (argv[0]);
575 parser->state.name = __argp_short_program_name ();
580 /* Free any storage consumed by PARSER (but not PARSER itself). */
582 parser_finalize (struct parser *parser,
583 error_t err, int arg_ebadkey, int *end_index)
587 if (err == EBADKEY && arg_ebadkey)
588 /* Suppress errors generated by unparsed arguments. */
593 if (parser->state.next == parser->state.argc)
594 /* We successfully parsed all arguments! Call all the parsers again,
595 just a few more times... */
597 for (group = parser->groups;
598 group < parser->egroup && (!err || err==EBADKEY);
600 if (group->args_processed == 0)
601 err = group_parse (group, &parser->state, ARGP_KEY_NO_ARGS, 0);
602 for (group = parser->egroup - 1;
603 group >= parser->groups && (!err || err==EBADKEY);
605 err = group_parse (group, &parser->state, ARGP_KEY_END, 0);
608 err = 0; /* Some parser didn't understand. */
610 /* Tell the user that all arguments are parsed. */
612 *end_index = parser->state.next;
615 /* Return any remaining arguments to the user. */
616 *end_index = parser->state.next;
618 /* No way to return the remaining arguments, they must be bogus. */
620 if (!(parser->state.flags & ARGP_NO_ERRS)
621 && parser->state.err_stream)
622 fprintf (parser->state.err_stream,
623 dgettext (ARGP_TEXT_DOMAIN, "%s: Too many arguments\n"),
629 /* Okay, we're all done, with either an error or success; call the parsers
630 to indicate which one. */
634 /* Maybe print an error message. */
636 /* An appropriate message describing what the error was should have
637 been printed earlier. */
638 __argp_state_help (&parser->state, parser->state.err_stream,
641 /* Since we didn't exit, give each parser an error indication. */
642 for (group = parser->groups; group < parser->egroup; group++)
643 group_parse (group, &parser->state, ARGP_KEY_ERROR, 0);
646 /* Notify parsers of success, and propagate back values from parsers. */
648 /* We pass over the groups in reverse order so that child groups are
649 given a chance to do there processing before passing back a value to
651 for (group = parser->egroup - 1
652 ; group >= parser->groups && (!err || err == EBADKEY)
654 err = group_parse (group, &parser->state, ARGP_KEY_SUCCESS, 0);
656 err = 0; /* Some parser didn't understand. */
659 /* Call parsers once more, to do any final cleanup. Errors are ignored. */
660 for (group = parser->egroup - 1; group >= parser->groups; group--)
661 group_parse (group, &parser->state, ARGP_KEY_FINI, 0);
666 free (parser->storage);
671 /* Call the user parsers to parse the non-option argument VAL, at the current
672 position, returning any error. The state NEXT pointer is assumed to have
673 been adjusted (by getopt) to point after this argument; this function will
674 adjust it correctly to reflect however many args actually end up being
677 parser_parse_arg (struct parser *parser, char *val)
679 /* Save the starting value of NEXT, first adjusting it so that the arg
680 we're parsing is again the front of the arg vector. */
681 int index = --parser->state.next;
682 error_t err = EBADKEY;
684 int key = 0; /* Which of ARGP_KEY_ARG[S] we used. */
686 /* Try to parse the argument in each parser. */
687 for (group = parser->groups
688 ; group < parser->egroup && err == EBADKEY
691 parser->state.next++; /* For ARGP_KEY_ARG, consume the arg. */
693 err = group_parse (group, &parser->state, key, val);
696 /* This parser doesn't like ARGP_KEY_ARG; try ARGP_KEY_ARGS instead. */
698 parser->state.next--; /* For ARGP_KEY_ARGS, put back the arg. */
700 err = group_parse (group, &parser->state, key, 0);
706 if (key == ARGP_KEY_ARGS)
707 /* The default for ARGP_KEY_ARGS is to assume that if NEXT isn't
708 changed by the user, *all* arguments should be considered
710 parser->state.next = parser->state.argc;
712 if (parser->state.next > index)
713 /* Remember that we successfully processed a non-option
714 argument -- but only if the user hasn't gotten tricky and set
716 (--group)->args_processed += (parser->state.next - index);
718 /* The user wants to reparse some args, give getopt another try. */
719 parser->try_getopt = 1;
725 /* Call the user parsers to parse the option OPT, with argument VAL, at the
726 current position, returning any error. */
728 parser_parse_opt (struct parser *parser, int opt, char *val)
730 /* The group key encoded in the high bits; 0 for short opts or
731 group_number + 1 for long opts. */
732 int group_key = opt >> USER_BITS;
733 error_t err = EBADKEY;
736 /* A short option. By comparing OPT's position in SHORT_OPTS to the
737 various starting positions in each group's SHORT_END field, we can
738 determine which group OPT came from. */
741 char *short_index = strchr (parser->short_opts, opt);
744 for (group = parser->groups; group < parser->egroup; group++)
745 if (group->short_end > short_index)
747 err = group_parse (group, &parser->state, opt,
748 parser->opt_data.optarg);
753 /* A long option. We use shifts instead of masking for extracting
754 the user value in order to preserve the sign. */
756 group_parse (&parser->groups[group_key - 1], &parser->state,
757 (opt << GROUP_BITS) >> GROUP_BITS,
758 parser->opt_data.optarg);
761 /* At least currently, an option not recognized is an error in the
762 parser, because we pre-compute which parser is supposed to deal
765 static const char bad_key_err[] =
766 N_("(PROGRAM ERROR) Option should have been recognized!?");
768 __argp_error (&parser->state, "-%c: %s", opt,
769 dgettext (ARGP_TEXT_DOMAIN, bad_key_err));
772 struct option *long_opt = parser->long_opts;
773 while (long_opt->val != opt && long_opt->name)
775 __argp_error (&parser->state, "--%s: %s",
776 long_opt->name ? long_opt->name : "???",
777 dgettext (ARGP_TEXT_DOMAIN, bad_key_err));
784 /* Parse the next argument in PARSER (as indicated by PARSER->state.next).
785 Any error from the parsers is returned, and *ARGP_EBADKEY indicates
786 whether a value of EBADKEY is due to an unrecognized argument (which is
787 generally not fatal). */
789 parser_parse_next (struct parser *parser, int *arg_ebadkey)
794 if (parser->state.quoted && parser->state.next < parser->state.quoted)
795 /* The next argument pointer has been moved to before the quoted
796 region, so pretend we never saw the quoting "--", and give getopt
797 another chance. If the user hasn't removed it, getopt will just
799 parser->state.quoted = 0;
801 if (parser->try_getopt && !parser->state.quoted)
802 /* Give getopt a chance to parse this. */
804 /* Put it back in OPTIND for getopt. */
805 parser->opt_data.optind = parser->state.next;
806 /* Distinguish KEY_ERR from a real option. */
807 parser->opt_data.optopt = KEY_END;
808 if (parser->state.flags & ARGP_LONG_ONLY)
809 opt = _getopt_long_only_r (parser->state.argc, parser->state.argv,
810 parser->short_opts, parser->long_opts, 0,
813 opt = _getopt_long_r (parser->state.argc, parser->state.argv,
814 parser->short_opts, parser->long_opts, 0,
816 /* And see what getopt did. */
817 parser->state.next = parser->opt_data.optind;
820 /* Getopt says there are no more options, so stop using
821 getopt; we'll continue if necessary on our own. */
823 parser->try_getopt = 0;
824 if (parser->state.next > 1
825 && strcmp (parser->state.argv[parser->state.next - 1], QUOTE)
827 /* Not only is this the end of the options, but it's a
828 "quoted" region, which may have args that *look* like
829 options, so we definitely shouldn't try to use getopt past
830 here, whatever happens. */
831 parser->state.quoted = parser->state.next;
833 else if (opt == KEY_ERR && parser->opt_data.optopt != KEY_END)
834 /* KEY_ERR can have the same value as a valid user short
835 option, but in the case of a real error, getopt sets OPTOPT
836 to the offending character, which can never be KEY_END. */
847 /* We're past what getopt considers the options. */
848 if (parser->state.next >= parser->state.argc
849 || (parser->state.flags & ARGP_NO_ARGS))
850 /* Indicate that we're done. */
856 /* A non-option arg; simulate what getopt might have done. */
859 parser->opt_data.optarg = parser->state.argv[parser->state.next++];
864 /* A non-option argument; try each parser in turn. */
865 err = parser_parse_arg (parser, parser->opt_data.optarg);
867 err = parser_parse_opt (parser, opt, parser->opt_data.optarg);
870 *arg_ebadkey = (opt == KEY_END || opt == KEY_ARG);
875 /* Parse the options strings in ARGC & ARGV according to the argp in ARGP.
876 FLAGS is one of the ARGP_ flags above. If END_INDEX is non-NULL, the
877 index in ARGV of the first unparsed option is returned in it. If an
878 unknown option is present, EINVAL is returned; if some parser routine
879 returned a non-zero value, it is returned; otherwise 0 is returned. */
881 __argp_parse (const struct argp *argp, int argc, char **argv, unsigned flags,
882 int *end_index, void *input)
885 struct parser parser;
887 /* If true, then err == EBADKEY is a result of a non-option argument failing
888 to be parsed (which in some cases isn't actually an error). */
892 if (!(flags & ARGP_PARSE_ARGV0))
894 #if HAVE_DECL_PROGRAM_INVOCATION_NAME
895 if (!program_invocation_name)
896 program_invocation_name = argv[0];
898 #if HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME
899 if (!program_invocation_short_name)
900 program_invocation_short_name = __argp_base_name (argv[0]);
905 if (! (flags & ARGP_NO_HELP))
906 /* Add our own options. */
908 struct argp_child *child = alloca (4 * sizeof (struct argp_child));
909 struct argp *top_argp = alloca (sizeof (struct argp));
911 /* TOP_ARGP has no options, it just serves to group the user & default
913 memset (top_argp, 0, sizeof (*top_argp));
914 top_argp->children = child;
916 memset (child, 0, 4 * sizeof (struct argp_child));
919 (child++)->argp = argp;
920 (child++)->argp = &argp_default_argp;
921 if (argp_program_version || argp_program_version_hook)
922 (child++)->argp = &argp_version_argp;
928 /* Construct a parser for these arguments. */
929 err = parser_init (&parser, argp, argc, argv, flags, input);
935 err = parser_parse_next (&parser, &arg_ebadkey);
936 err = parser_finalize (&parser, err, arg_ebadkey, end_index);
942 weak_alias (__argp_parse, argp_parse)
945 /* Return the input field for ARGP in the parser corresponding to STATE; used
946 by the help routines. */
948 __argp_input (const struct argp *argp, const struct argp_state *state)
953 struct parser *parser = state->pstate;
955 for (group = parser->groups; group < parser->egroup; group++)
956 if (group->argp == argp)
963 weak_alias (__argp_input, _argp_input)