1
/* Hierarchial argument parsing, layered over getopt
2
Copyright (C) 1995-2000, 2002-2004, 2009-2010 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/>. */
30
#include <getopt_int.h>
35
# define dgettext(domain, msgid) \
36
INTUSE(__dcgettext) (domain, msgid, LC_MESSAGES)
40
#define N_(msgid) msgid
43
#include "argp-namefrob.h"
45
#define alignof(type) offsetof (struct { char c; type x; }, x)
46
#define alignto(n, d) ((((n) + (d) - 1) / (d)) * (d))
48
/* Getopt return values. */
49
#define KEY_END (-1) /* The end of the options. */
50
#define KEY_ARG 1 /* A non-option argument. */
51
#define KEY_ERR '?' /* An error parsing the options. */
53
/* The meta-argument used to prevent any further arguments being interpreted
57
/* The number of bits we steal in a long-option value for our own use. */
58
#define GROUP_BITS CHAR_BIT
60
/* The number of bits available for the user value. */
61
#define USER_BITS ((sizeof ((struct option *)0)->val * CHAR_BIT) - GROUP_BITS)
62
#define USER_MASK ((1 << USER_BITS) - 1)
64
/* EZ alias for ARGP_ERR_UNKNOWN. */
65
#define EBADKEY ARGP_ERR_UNKNOWN
67
/* Default options. */
69
/* When argp is given the --HANG switch, _ARGP_HANG is set and argp will sleep
70
for one second intervals, decrementing _ARGP_HANG until it's zero. Thus
71
you can force the program to continue by attaching a debugger and setting
73
static volatile int _argp_hang;
75
#define OPT_PROGNAME -2
79
static const struct argp_option argp_default_options[] =
81
{"help", '?', 0, 0, N_("give this help list"), -1},
82
{"usage", OPT_USAGE, 0, 0, N_("give a short usage message"), 0},
83
{"program-name",OPT_PROGNAME,N_("NAME"), OPTION_HIDDEN, N_("set the program name"), 0},
84
{"HANG", OPT_HANG, N_("SECS"), OPTION_ARG_OPTIONAL | OPTION_HIDDEN,
85
N_("hang for SECS seconds (default 3600)"), 0},
86
{NULL, 0, 0, 0, NULL, 0}
90
argp_default_parser (int key, char *arg, struct argp_state *state)
95
__argp_state_help (state, state->out_stream, ARGP_HELP_STD_HELP);
98
__argp_state_help (state, state->out_stream,
99
ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
102
case OPT_PROGNAME: /* Set the program name. */
103
#if defined _LIBC || HAVE_DECL_PROGRAM_INVOCATION_NAME
104
program_invocation_name = arg;
106
/* [Note that some systems only have PROGRAM_INVOCATION_SHORT_NAME (aka
107
__PROGNAME), in which case, PROGRAM_INVOCATION_NAME is just defined
108
to be that, so we have to be a bit careful here.] */
110
/* Update what we use for messages. */
111
state->name = __argp_base_name (arg);
113
#if defined _LIBC || HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME
114
program_invocation_short_name = state->name;
117
if ((state->flags & (ARGP_PARSE_ARGV0 | ARGP_NO_ERRS))
119
/* Update what getopt uses too. */
120
state->argv[0] = arg;
125
_argp_hang = atoi (arg ? arg : "3600");
126
while (_argp_hang-- > 0)
136
static const struct argp argp_default_argp =
137
{argp_default_options, &argp_default_parser, NULL, NULL, NULL, NULL, "libc"};
140
static const struct argp_option argp_version_options[] =
142
{"version", 'V', 0, 0, N_("print program version"), -1},
143
{NULL, 0, 0, 0, NULL, 0}
147
argp_version_parser (int key, char *arg, struct argp_state *state)
152
if (argp_program_version_hook)
153
(*argp_program_version_hook) (state->out_stream, state);
154
else if (argp_program_version)
155
fprintf (state->out_stream, "%s\n", argp_program_version);
157
__argp_error (state, dgettext (state->root_argp->argp_domain,
158
"(PROGRAM ERROR) No version known!?"));
159
if (! (state->flags & ARGP_NO_EXIT))
168
static const struct argp argp_version_argp =
169
{argp_version_options, &argp_version_parser, NULL, NULL, NULL, NULL, "libc"};
171
/* Returns the offset into the getopt long options array LONG_OPTIONS of a
172
long option with called NAME, or -1 if none is found. Passing NULL as
173
NAME will return the number of options. */
175
find_long_option (struct option *long_options, const char *name)
177
struct option *l = long_options;
178
while (l->name != NULL)
179
if (name != NULL && strcmp (l->name, name) == 0)
180
return l - long_options;
184
return l - long_options;
190
/* The state of a `group' during parsing. Each group corresponds to a
191
particular argp structure from the tree of such descending from the top
192
level argp passed to argp_parse. */
195
/* This group's parsing function. */
196
argp_parser_t parser;
198
/* Which argp this group is from. */
199
const struct argp *argp;
201
/* Points to the point in SHORT_OPTS corresponding to the end of the short
202
options for this group. We use it to determine from which group a
203
particular short options is from. */
206
/* The number of non-option args sucessfully handled by this parser. */
207
unsigned args_processed;
209
/* This group's parser's parent's group. */
210
struct group *parent;
211
unsigned parent_index; /* And the our position in the parent. */
213
/* These fields are swapped into and out of the state structure when
214
calling this group's parser. */
215
void *input, **child_inputs;
219
/* Call GROUP's parser with KEY and ARG, swapping any group-specific info
220
from STATE before calling, and back into state afterwards. If GROUP has
221
no parser, EBADKEY is returned. */
223
group_parse (struct group *group, struct argp_state *state, int key, char *arg)
228
state->hook = group->hook;
229
state->input = group->input;
230
state->child_inputs = group->child_inputs;
231
state->arg_num = group->args_processed;
232
err = (*group->parser)(key, arg, state);
233
group->hook = state->hook;
242
const struct argp *argp;
244
/* SHORT_OPTS is the getopt short options string for the union of all the
245
groups of options. */
247
/* LONG_OPTS is the array of getop long option structures for the union of
248
all the groups of options. */
249
struct option *long_opts;
250
/* OPT_DATA is the getopt data used for the re-entrant getopt. */
251
struct _getopt_data opt_data;
253
/* States of the various parsing groups. */
254
struct group *groups;
255
/* The end of the GROUPS array. */
256
struct group *egroup;
257
/* An vector containing storage for the CHILD_INPUTS field in all groups. */
260
/* True if we think using getopt is still useful; if false, then
261
remaining arguments are just passed verbatim with ARGP_KEY_ARG. This is
262
cleared whenever getopt returns KEY_END, but may be set again if the user
263
moves the next argument pointer backwards. */
266
/* State block supplied to parsing routines. */
267
struct argp_state state;
269
/* Memory used by this parser. */
273
/* The next usable entries in the various parser tables being filled in by
275
struct parser_convert_state
277
struct parser *parser;
279
struct option *long_end;
280
void **child_inputs_end;
283
/* Converts all options in ARGP (which is put in GROUP) and ancestors
284
into getopt options stored in SHORT_OPTS and LONG_OPTS; SHORT_END and
285
CVT->LONG_END are the points at which new options are added. Returns the
286
next unused group entry. CVT holds state used during the conversion. */
287
static struct group *
288
convert_options (const struct argp *argp,
289
struct group *parent, unsigned parent_index,
290
struct group *group, struct parser_convert_state *cvt)
292
/* REAL is the most recent non-alias value of OPT. */
293
const struct argp_option *real = argp->options;
294
const struct argp_child *children = argp->children;
296
if (real || argp->parser)
298
const struct argp_option *opt;
301
for (opt = real; !__option_is_end (opt); opt++)
303
if (! (opt->flags & OPTION_ALIAS))
304
/* OPT isn't an alias, so we can use values from it. */
307
if (! (real->flags & OPTION_DOC))
308
/* A real option (not just documentation). */
310
if (__option_is_short (opt))
311
/* OPT can be used as a short option. */
313
*cvt->short_end++ = opt->key;
316
*cvt->short_end++ = ':';
317
if (real->flags & OPTION_ARG_OPTIONAL)
318
*cvt->short_end++ = ':';
320
*cvt->short_end = '\0'; /* keep 0 terminated */
324
&& find_long_option (cvt->parser->long_opts, opt->name) < 0)
325
/* OPT can be used as a long option. */
327
cvt->long_end->name = opt->name;
328
cvt->long_end->has_arg =
330
? (real->flags & OPTION_ARG_OPTIONAL
334
cvt->long_end->flag = 0;
335
/* we add a disambiguating code to all the user's
336
values (which is removed before we actually call
337
the function to parse the value); this means that
338
the user loses use of the high 8 bits in all his
339
values (the sign of the lower bits is preserved
342
((opt->key ? opt->key : real->key) & USER_MASK)
343
+ (((group - cvt->parser->groups) + 1) << USER_BITS);
345
/* Keep the LONG_OPTS list terminated. */
346
(++cvt->long_end)->name = NULL;
351
group->parser = argp->parser;
353
group->short_end = cvt->short_end;
354
group->args_processed = 0;
355
group->parent = parent;
356
group->parent_index = parent_index;
359
group->child_inputs = 0;
362
/* Assign GROUP's CHILD_INPUTS field some space from
363
CVT->child_inputs_end.*/
365
unsigned num_children = 0;
366
while (children[num_children].argp)
368
group->child_inputs = cvt->child_inputs_end;
369
cvt->child_inputs_end += num_children;
380
while (children->argp)
382
convert_options (children++->argp, parent, index++, group, cvt);
388
/* Find the merged set of getopt options, with keys appropiately prefixed. */
390
parser_convert (struct parser *parser, const struct argp *argp, int flags)
392
struct parser_convert_state cvt;
395
cvt.short_end = parser->short_opts;
396
cvt.long_end = parser->long_opts;
397
cvt.child_inputs_end = parser->child_inputs;
399
if (flags & ARGP_IN_ORDER)
400
*cvt.short_end++ = '-';
401
else if (flags & ARGP_NO_ARGS)
402
*cvt.short_end++ = '+';
403
*cvt.short_end = '\0';
405
cvt.long_end->name = NULL;
410
parser->egroup = convert_options (argp, 0, 0, parser->groups, &cvt);
412
parser->egroup = parser->groups; /* No parsers at all! */
415
/* Lengths of various parser fields which we will allocated. */
418
size_t short_len; /* Getopt short options string. */
419
size_t long_len; /* Getopt long options vector. */
420
size_t num_groups; /* Group structures we allocate. */
421
size_t num_child_inputs; /* Child input slots. */
424
/* For ARGP, increments the NUM_GROUPS field in SZS by the total number of
425
argp structures descended from it, and the SHORT_LEN & LONG_LEN fields by
426
the maximum lengths of the resulting merged getopt short options string and
427
long-options array, respectively. */
429
calc_sizes (const struct argp *argp, struct parser_sizes *szs)
431
const struct argp_child *child = argp->children;
432
const struct argp_option *opt = argp->options;
434
if (opt || argp->parser)
440
while (!__option_is_end (opt++))
442
szs->short_len += num_opts * 3; /* opt + up to 2 `:'s */
443
szs->long_len += num_opts;
450
calc_sizes ((child++)->argp, szs);
451
szs->num_child_inputs++;
455
/* Initializes PARSER to parse ARGP in a manner described by FLAGS. */
457
parser_init (struct parser *parser, const struct argp *argp,
458
int argc, char **argv, int flags, void *input)
462
struct parser_sizes szs;
463
struct _getopt_data opt_data = _GETOPT_DATA_INITIALIZER;
470
szs.short_len = (flags & ARGP_NO_ARGS) ? 0 : 1;
473
szs.num_child_inputs = 0;
476
calc_sizes (argp, &szs);
478
/* Lengths of the various bits of storage used by PARSER. */
479
glen = (szs.num_groups + 1) * sizeof (struct group);
480
clen = szs.num_child_inputs * sizeof (void *);
481
llen = (szs.long_len + 1) * sizeof (struct option);
482
slen = szs.short_len + 1;
484
/* Sums of previous lengths, properly aligned. There's no need to
485
align gsum, since struct group is aligned at least as strictly as
486
void * (since it contains a void * member). And there's no need
487
to align lsum, since struct option is aligned at least as
490
csum = alignto (gsum + clen, alignof (struct option));
494
parser->storage = malloc (ssum);
495
if (! parser->storage)
498
storage = parser->storage;
499
parser->groups = parser->storage;
500
parser->child_inputs = (void **) (storage + gsum);
501
parser->long_opts = (struct option *) (storage + csum);
502
parser->short_opts = storage + lsum;
503
parser->opt_data = opt_data;
505
memset (parser->child_inputs, 0, clen);
506
parser_convert (parser, argp, flags);
508
memset (&parser->state, 0, sizeof (struct argp_state));
509
parser->state.root_argp = parser->argp;
510
parser->state.argc = argc;
511
parser->state.argv = argv;
512
parser->state.flags = flags;
513
parser->state.err_stream = stderr;
514
parser->state.out_stream = stdout;
515
parser->state.next = 0; /* Tell getopt to initialize. */
516
parser->state.pstate = parser;
518
parser->try_getopt = 1;
520
/* Call each parser for the first time, giving it a chance to propagate
521
values to child parsers. */
522
if (parser->groups < parser->egroup)
523
parser->groups->input = input;
524
for (group = parser->groups;
525
group < parser->egroup && (!err || err == EBADKEY);
529
/* If a child parser, get the initial input value from the parent. */
530
group->input = group->parent->child_inputs[group->parent_index];
533
&& group->argp->children && group->argp->children->argp)
534
/* For the special case where no parsing function is supplied for an
535
argp, propagate its input to its first child, if any (this just
536
makes very simple wrapper argps more convenient). */
537
group->child_inputs[0] = group->input;
539
err = group_parse (group, &parser->state, ARGP_KEY_INIT, 0);
542
err = 0; /* Some parser didn't understand. */
547
if (parser->state.flags & ARGP_NO_ERRS)
549
parser->opt_data.opterr = 0;
550
if (parser->state.flags & ARGP_PARSE_ARGV0)
551
/* getopt always skips ARGV[0], so we have to fake it out. As long
552
as OPTERR is 0, then it shouldn't actually try to access it. */
553
parser->state.argv--, parser->state.argc++;
556
parser->opt_data.opterr = 1; /* Print error messages. */
558
if (parser->state.argv == argv && argv[0])
559
/* There's an argv[0]; use it for messages. */
560
parser->state.name = __argp_base_name (argv[0]);
562
parser->state.name = __argp_short_program_name ();
567
/* Free any storage consumed by PARSER (but not PARSER itself). */
569
parser_finalize (struct parser *parser,
570
error_t err, int arg_ebadkey, int *end_index)
574
if (err == EBADKEY && arg_ebadkey)
575
/* Suppress errors generated by unparsed arguments. */
580
if (parser->state.next == parser->state.argc)
581
/* We successfully parsed all arguments! Call all the parsers again,
582
just a few more times... */
584
for (group = parser->groups;
585
group < parser->egroup && (!err || err==EBADKEY);
587
if (group->args_processed == 0)
588
err = group_parse (group, &parser->state, ARGP_KEY_NO_ARGS, 0);
589
for (group = parser->egroup - 1;
590
group >= parser->groups && (!err || err==EBADKEY);
592
err = group_parse (group, &parser->state, ARGP_KEY_END, 0);
595
err = 0; /* Some parser didn't understand. */
597
/* Tell the user that all arguments are parsed. */
599
*end_index = parser->state.next;
602
/* Return any remaining arguments to the user. */
603
*end_index = parser->state.next;
605
/* No way to return the remaining arguments, they must be bogus. */
607
if (!(parser->state.flags & ARGP_NO_ERRS)
608
&& parser->state.err_stream)
609
fprintf (parser->state.err_stream,
610
dgettext (parser->argp->argp_domain,
611
"%s: Too many arguments\n"),
617
/* Okay, we're all done, with either an error or success; call the parsers
618
to indicate which one. */
622
/* Maybe print an error message. */
624
/* An appropriate message describing what the error was should have
625
been printed earlier. */
626
__argp_state_help (&parser->state, parser->state.err_stream,
629
/* Since we didn't exit, give each parser an error indication. */
630
for (group = parser->groups; group < parser->egroup; group++)
631
group_parse (group, &parser->state, ARGP_KEY_ERROR, 0);
634
/* Notify parsers of success, and propagate back values from parsers. */
636
/* We pass over the groups in reverse order so that child groups are
637
given a chance to do there processing before passing back a value to
639
for (group = parser->egroup - 1
640
; group >= parser->groups && (!err || err == EBADKEY)
642
err = group_parse (group, &parser->state, ARGP_KEY_SUCCESS, 0);
644
err = 0; /* Some parser didn't understand. */
647
/* Call parsers once more, to do any final cleanup. Errors are ignored. */
648
for (group = parser->egroup - 1; group >= parser->groups; group--)
649
group_parse (group, &parser->state, ARGP_KEY_FINI, 0);
654
free (parser->storage);
659
/* Call the user parsers to parse the non-option argument VAL, at the current
660
position, returning any error. The state NEXT pointer is assumed to have
661
been adjusted (by getopt) to point after this argument; this function will
662
adjust it correctly to reflect however many args actually end up being
665
parser_parse_arg (struct parser *parser, char *val)
667
/* Save the starting value of NEXT, first adjusting it so that the arg
668
we're parsing is again the front of the arg vector. */
669
int index = --parser->state.next;
670
error_t err = EBADKEY;
672
int key = 0; /* Which of ARGP_KEY_ARG[S] we used. */
674
/* Try to parse the argument in each parser. */
675
for (group = parser->groups
676
; group < parser->egroup && err == EBADKEY
679
parser->state.next++; /* For ARGP_KEY_ARG, consume the arg. */
681
err = group_parse (group, &parser->state, key, val);
684
/* This parser doesn't like ARGP_KEY_ARG; try ARGP_KEY_ARGS instead. */
686
parser->state.next--; /* For ARGP_KEY_ARGS, put back the arg. */
688
err = group_parse (group, &parser->state, key, 0);
694
if (key == ARGP_KEY_ARGS)
695
/* The default for ARGP_KEY_ARGS is to assume that if NEXT isn't
696
changed by the user, *all* arguments should be considered
698
parser->state.next = parser->state.argc;
700
if (parser->state.next > index)
701
/* Remember that we successfully processed a non-option
702
argument -- but only if the user hasn't gotten tricky and set
704
(--group)->args_processed += (parser->state.next - index);
706
/* The user wants to reparse some args, give getopt another try. */
707
parser->try_getopt = 1;
713
/* Call the user parsers to parse the option OPT, with argument VAL, at the
714
current position, returning any error. */
716
parser_parse_opt (struct parser *parser, int opt, char *val)
718
/* The group key encoded in the high bits; 0 for short opts or
719
group_number + 1 for long opts. */
720
int group_key = opt >> USER_BITS;
721
error_t err = EBADKEY;
724
/* A short option. By comparing OPT's position in SHORT_OPTS to the
725
various starting positions in each group's SHORT_END field, we can
726
determine which group OPT came from. */
729
char *short_index = strchr (parser->short_opts, opt);
732
for (group = parser->groups; group < parser->egroup; group++)
733
if (group->short_end > short_index)
735
err = group_parse (group, &parser->state, opt,
736
parser->opt_data.optarg);
741
/* A long option. We use shifts instead of masking for extracting
742
the user value in order to preserve the sign. */
744
group_parse (&parser->groups[group_key - 1], &parser->state,
745
(opt << GROUP_BITS) >> GROUP_BITS,
746
parser->opt_data.optarg);
749
/* At least currently, an option not recognized is an error in the
750
parser, because we pre-compute which parser is supposed to deal
753
static const char bad_key_err[] =
754
N_("(PROGRAM ERROR) Option should have been recognized!?");
756
__argp_error (&parser->state, "-%c: %s", opt,
757
dgettext (parser->argp->argp_domain, bad_key_err));
760
struct option *long_opt = parser->long_opts;
761
while (long_opt->val != opt && long_opt->name)
763
__argp_error (&parser->state, "--%s: %s",
764
long_opt->name ? long_opt->name : "???",
765
dgettext (parser->argp->argp_domain, bad_key_err));
772
/* Parse the next argument in PARSER (as indicated by PARSER->state.next).
773
Any error from the parsers is returned, and *ARGP_EBADKEY indicates
774
whether a value of EBADKEY is due to an unrecognized argument (which is
775
generally not fatal). */
777
parser_parse_next (struct parser *parser, int *arg_ebadkey)
782
if (parser->state.quoted && parser->state.next < parser->state.quoted)
783
/* The next argument pointer has been moved to before the quoted
784
region, so pretend we never saw the quoting `--', and give getopt
785
another chance. If the user hasn't removed it, getopt will just
787
parser->state.quoted = 0;
789
if (parser->try_getopt && !parser->state.quoted)
790
/* Give getopt a chance to parse this. */
792
/* Put it back in OPTIND for getopt. */
793
parser->opt_data.optind = parser->state.next;
794
/* Distinguish KEY_ERR from a real option. */
795
parser->opt_data.optopt = KEY_END;
796
if (parser->state.flags & ARGP_LONG_ONLY)
797
opt = _getopt_long_only_r (parser->state.argc, parser->state.argv,
798
parser->short_opts, parser->long_opts, 0,
801
opt = _getopt_long_r (parser->state.argc, parser->state.argv,
802
parser->short_opts, parser->long_opts, 0,
804
/* And see what getopt did. */
805
parser->state.next = parser->opt_data.optind;
808
/* Getopt says there are no more options, so stop using
809
getopt; we'll continue if necessary on our own. */
811
parser->try_getopt = 0;
812
if (parser->state.next > 1
813
&& strcmp (parser->state.argv[parser->state.next - 1], QUOTE)
815
/* Not only is this the end of the options, but it's a
816
`quoted' region, which may have args that *look* like
817
options, so we definitely shouldn't try to use getopt past
818
here, whatever happens. */
819
parser->state.quoted = parser->state.next;
821
else if (opt == KEY_ERR && parser->opt_data.optopt != KEY_END)
822
/* KEY_ERR can have the same value as a valid user short
823
option, but in the case of a real error, getopt sets OPTOPT
824
to the offending character, which can never be KEY_END. */
835
/* We're past what getopt considers the options. */
836
if (parser->state.next >= parser->state.argc
837
|| (parser->state.flags & ARGP_NO_ARGS))
838
/* Indicate that we're done. */
844
/* A non-option arg; simulate what getopt might have done. */
847
parser->opt_data.optarg = parser->state.argv[parser->state.next++];
852
/* A non-option argument; try each parser in turn. */
853
err = parser_parse_arg (parser, parser->opt_data.optarg);
855
err = parser_parse_opt (parser, opt, parser->opt_data.optarg);
858
*arg_ebadkey = (opt == KEY_END || opt == KEY_ARG);
863
/* Parse the options strings in ARGC & ARGV according to the argp in ARGP.
864
FLAGS is one of the ARGP_ flags above. If END_INDEX is non-NULL, the
865
index in ARGV of the first unparsed option is returned in it. If an
866
unknown option is present, EINVAL is returned; if some parser routine
867
returned a non-zero value, it is returned; otherwise 0 is returned. */
869
__argp_parse (const struct argp *argp, int argc, char **argv, unsigned flags,
870
int *end_index, void *input)
873
struct parser parser;
875
/* If true, then err == EBADKEY is a result of a non-option argument failing
876
to be parsed (which in some cases isn't actually an error). */
880
if (!(flags & ARGP_PARSE_ARGV0))
882
#ifdef HAVE_DECL_PROGRAM_INVOCATION_NAME
883
if (!program_invocation_name)
884
program_invocation_name = argv[0];
886
#ifdef HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME
887
if (!program_invocation_short_name)
888
program_invocation_short_name = __argp_base_name (argv[0]);
893
if (! (flags & ARGP_NO_HELP))
894
/* Add our own options. */
896
struct argp_child *child = alloca (4 * sizeof (struct argp_child));
897
struct argp *top_argp = alloca (sizeof (struct argp));
899
/* TOP_ARGP has no options, it just serves to group the user & default
901
memset (top_argp, 0, sizeof (*top_argp));
902
top_argp->children = child;
904
memset (child, 0, 4 * sizeof (struct argp_child));
907
(child++)->argp = argp;
908
(child++)->argp = &argp_default_argp;
909
if (argp_program_version || argp_program_version_hook)
910
(child++)->argp = &argp_version_argp;
916
/* Construct a parser for these arguments. */
917
err = parser_init (&parser, argp, argc, argv, flags, input);
923
err = parser_parse_next (&parser, &arg_ebadkey);
924
err = parser_finalize (&parser, err, arg_ebadkey, end_index);
930
weak_alias (__argp_parse, argp_parse)
933
/* Return the input field for ARGP in the parser corresponding to STATE; used
934
by the help routines. */
936
__argp_input (const struct argp *argp, const struct argp_state *state)
941
struct parser *parser = state->pstate;
943
for (group = parser->groups; group < parser->egroup; group++)
944
if (group->argp == argp)
951
weak_alias (__argp_input, _argp_input)
added
removed
grub-core/gnulib/argp-parse.c
