doc: document left_inverse
[barvinok.git] / lib / argp-parse.c
bloba7de72902aae7b47feedc243aa1a49c1079b4826
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)
9 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 along
17 with this program; if not, write to the Free Software Foundation,
18 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
20 #ifdef HAVE_CONFIG_H
21 # include <config.h>
22 #endif
24 #include <alloca.h>
25 #include <stddef.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <unistd.h>
29 #include <limits.h>
30 #include <getopt.h>
31 #include <getopt_int.h>
33 #ifdef _LIBC
34 # include <libintl.h>
35 # undef dgettext
36 # define dgettext(domain, msgid) \
37 INTUSE(__dcgettext) (domain, msgid, LC_MESSAGES)
38 #else
39 # include "gettext.h"
40 #endif
41 #define N_(msgid) msgid
43 #include "argp.h"
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
55 as options. */
56 #define QUOTE "--"
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
73 it to 0 yourself. */
74 static volatile int _argp_hang;
76 #define OPT_PROGNAME -2
77 #define OPT_USAGE -3
78 #define OPT_HANG -4
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,N_("NAME"), OPTION_HIDDEN, N_("set the program name"), 0},
85 {"HANG", OPT_HANG, N_("SECS"), OPTION_ARG_OPTIONAL | OPTION_HIDDEN,
86 N_("hang for SECS seconds (default 3600)"), 0},
87 {NULL, 0, 0, 0, NULL, 0}
90 static error_t
91 argp_default_parser (int key, char *arg, struct argp_state *state)
93 switch (key)
95 case '?':
96 __argp_state_help (state, state->out_stream, ARGP_HELP_STD_HELP);
97 break;
98 case OPT_USAGE:
99 __argp_state_help (state, state->out_stream,
100 ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
101 break;
103 case OPT_PROGNAME: /* Set the program name. */
104 #if defined _LIBC || HAVE_DECL_PROGRAM_INVOCATION_NAME
105 program_invocation_name = arg;
106 #endif
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 = __argp_base_name (arg);
114 #if defined _LIBC || HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME
115 program_invocation_short_name = state->name;
116 #endif
118 if ((state->flags & (ARGP_PARSE_ARGV0 | ARGP_NO_ERRS))
119 == ARGP_PARSE_ARGV0)
120 /* Update what getopt uses too. */
121 state->argv[0] = arg;
123 break;
125 case OPT_HANG:
126 _argp_hang = atoi (arg ? arg : "3600");
127 while (_argp_hang-- > 0)
128 __sleep (1);
129 break;
131 default:
132 return EBADKEY;
134 return 0;
137 static const struct argp argp_default_argp =
138 {argp_default_options, &argp_default_parser, NULL, NULL, NULL, NULL, "libc"};
141 static const struct argp_option argp_version_options[] =
143 {"version", 'V', 0, 0, N_("print program version"), -1},
144 {NULL, 0, 0, 0, NULL, 0}
147 static error_t
148 argp_version_parser (int key, char *arg, struct argp_state *state)
150 switch (key)
152 case 'V':
153 if (argp_program_version_hook)
154 (*argp_program_version_hook) (state->out_stream, state);
155 else if (argp_program_version)
156 fprintf (state->out_stream, "%s\n", argp_program_version);
157 else
158 __argp_error (state, dgettext (state->root_argp->argp_domain,
159 "(PROGRAM ERROR) No version known!?"));
160 if (! (state->flags & ARGP_NO_EXIT))
161 exit (0);
162 break;
163 default:
164 return EBADKEY;
166 return 0;
169 static const struct argp argp_version_argp =
170 {argp_version_options, &argp_version_parser, NULL, NULL, NULL, NULL, "libc"};
172 /* Returns the offset into the getopt long options array LONG_OPTIONS of a
173 long option with called NAME, or -1 if none is found. Passing NULL as
174 NAME will return the number of options. */
175 static int
176 find_long_option (struct option *long_options, const char *name)
178 struct option *l = long_options;
179 while (l->name != NULL)
180 if (name != NULL && strcmp (l->name, name) == 0)
181 return l - long_options;
182 else
183 l++;
184 if (name == NULL)
185 return l - long_options;
186 else
187 return -1;
191 /* The state of a `group' during parsing. Each group corresponds to a
192 particular argp structure from the tree of such descending from the top
193 level argp passed to argp_parse. */
194 struct group
196 /* This group's parsing function. */
197 argp_parser_t parser;
199 /* Which argp this group is from. */
200 const struct argp *argp;
202 /* Points to the point in SHORT_OPTS corresponding to the end of the short
203 options for this group. We use it to determine from which group a
204 particular short options is from. */
205 char *short_end;
207 /* The number of non-option args sucessfully handled by this parser. */
208 unsigned args_processed;
210 /* This group's parser's parent's group. */
211 struct group *parent;
212 unsigned parent_index; /* And the our position in the parent. */
214 /* These fields are swapped into and out of the state structure when
215 calling this group's parser. */
216 void *input, **child_inputs;
217 void *hook;
220 /* Call GROUP's parser with KEY and ARG, swapping any group-specific info
221 from STATE before calling, and back into state afterwards. If GROUP has
222 no parser, EBADKEY is returned. */
223 static error_t
224 group_parse (struct group *group, struct argp_state *state, int key, char *arg)
226 if (group->parser)
228 error_t err;
229 state->hook = group->hook;
230 state->input = group->input;
231 state->child_inputs = group->child_inputs;
232 state->arg_num = group->args_processed;
233 err = (*group->parser)(key, arg, state);
234 group->hook = state->hook;
235 return err;
237 else
238 return EBADKEY;
241 struct parser
243 const struct argp *argp;
245 /* SHORT_OPTS is the getopt short options string for the union of all the
246 groups of options. */
247 char *short_opts;
248 /* LONG_OPTS is the array of getop long option structures for the union of
249 all the groups of options. */
250 struct option *long_opts;
251 /* OPT_DATA is the getopt data used for the re-entrant getopt. */
252 struct _getopt_data opt_data;
254 /* States of the various parsing groups. */
255 struct group *groups;
256 /* The end of the GROUPS array. */
257 struct group *egroup;
258 /* An vector containing storage for the CHILD_INPUTS field in all groups. */
259 void **child_inputs;
261 /* True if we think using getopt is still useful; if false, then
262 remaining arguments are just passed verbatim with ARGP_KEY_ARG. This is
263 cleared whenever getopt returns KEY_END, but may be set again if the user
264 moves the next argument pointer backwards. */
265 int try_getopt;
267 /* State block supplied to parsing routines. */
268 struct argp_state state;
270 /* Memory used by this parser. */
271 void *storage;
274 /* The next usable entries in the various parser tables being filled in by
275 convert_options. */
276 struct parser_convert_state
278 struct parser *parser;
279 char *short_end;
280 struct option *long_end;
281 void **child_inputs_end;
284 /* Converts all options in ARGP (which is put in GROUP) and ancestors
285 into getopt options stored in SHORT_OPTS and LONG_OPTS; SHORT_END and
286 CVT->LONG_END are the points at which new options are added. Returns the
287 next unused group entry. CVT holds state used during the conversion. */
288 static struct group *
289 convert_options (const struct argp *argp,
290 struct group *parent, unsigned parent_index,
291 struct group *group, struct parser_convert_state *cvt)
293 /* REAL is the most recent non-alias value of OPT. */
294 const struct argp_option *real = argp->options;
295 const struct argp_child *children = argp->children;
297 if (real || argp->parser)
299 const struct argp_option *opt;
301 if (real)
302 for (opt = real; !__option_is_end (opt); opt++)
304 if (! (opt->flags & OPTION_ALIAS))
305 /* OPT isn't an alias, so we can use values from it. */
306 real = opt;
308 if (! (real->flags & OPTION_DOC))
309 /* A real option (not just documentation). */
311 if (__option_is_short (opt))
312 /* OPT can be used as a short option. */
314 *cvt->short_end++ = opt->key;
315 if (real->arg)
317 *cvt->short_end++ = ':';
318 if (real->flags & OPTION_ARG_OPTIONAL)
319 *cvt->short_end++ = ':';
321 *cvt->short_end = '\0'; /* keep 0 terminated */
324 if (opt->name
325 && find_long_option (cvt->parser->long_opts, opt->name) < 0)
326 /* OPT can be used as a long option. */
328 cvt->long_end->name = opt->name;
329 cvt->long_end->has_arg =
330 (real->arg
331 ? (real->flags & OPTION_ARG_OPTIONAL
332 ? optional_argument
333 : required_argument)
334 : no_argument);
335 cvt->long_end->flag = 0;
336 /* we add a disambiguating code to all the user's
337 values (which is removed before we actually call
338 the function to parse the value); this means that
339 the user loses use of the high 8 bits in all his
340 values (the sign of the lower bits is preserved
341 however)... */
342 cvt->long_end->val =
343 ((opt->key | real->key) & USER_MASK)
344 + (((group - cvt->parser->groups) + 1) << USER_BITS);
346 /* Keep the LONG_OPTS list terminated. */
347 (++cvt->long_end)->name = NULL;
352 group->parser = argp->parser;
353 group->argp = argp;
354 group->short_end = cvt->short_end;
355 group->args_processed = 0;
356 group->parent = parent;
357 group->parent_index = parent_index;
358 group->input = 0;
359 group->hook = 0;
360 group->child_inputs = 0;
362 if (children)
363 /* Assign GROUP's CHILD_INPUTS field some space from
364 CVT->child_inputs_end.*/
366 unsigned num_children = 0;
367 while (children[num_children].argp)
368 num_children++;
369 group->child_inputs = cvt->child_inputs_end;
370 cvt->child_inputs_end += num_children;
373 parent = group++;
375 else
376 parent = 0;
378 if (children)
380 unsigned index = 0;
381 while (children->argp)
382 group =
383 convert_options (children++->argp, parent, index++, group, cvt);
386 return group;
389 /* Find the merged set of getopt options, with keys appropiately prefixed. */
390 static void
391 parser_convert (struct parser *parser, const struct argp *argp, int flags)
393 struct parser_convert_state cvt;
395 cvt.parser = parser;
396 cvt.short_end = parser->short_opts;
397 cvt.long_end = parser->long_opts;
398 cvt.child_inputs_end = parser->child_inputs;
400 if (flags & ARGP_IN_ORDER)
401 *cvt.short_end++ = '-';
402 else if (flags & ARGP_NO_ARGS)
403 *cvt.short_end++ = '+';
404 *cvt.short_end = '\0';
406 cvt.long_end->name = NULL;
408 parser->argp = argp;
410 if (argp)
411 parser->egroup = convert_options (argp, 0, 0, parser->groups, &cvt);
412 else
413 parser->egroup = parser->groups; /* No parsers at all! */
416 /* Lengths of various parser fields which we will allocated. */
417 struct parser_sizes
419 size_t short_len; /* Getopt short options string. */
420 size_t long_len; /* Getopt long options vector. */
421 size_t num_groups; /* Group structures we allocate. */
422 size_t num_child_inputs; /* Child input slots. */
425 /* For ARGP, increments the NUM_GROUPS field in SZS by the total number of
426 argp structures descended from it, and the SHORT_LEN & LONG_LEN fields by
427 the maximum lengths of the resulting merged getopt short options string and
428 long-options array, respectively. */
429 static void
430 calc_sizes (const struct argp *argp, struct parser_sizes *szs)
432 const struct argp_child *child = argp->children;
433 const struct argp_option *opt = argp->options;
435 if (opt || argp->parser)
437 szs->num_groups++;
438 if (opt)
440 int num_opts = 0;
441 while (!__option_is_end (opt++))
442 num_opts++;
443 szs->short_len += num_opts * 3; /* opt + up to 2 `:'s */
444 szs->long_len += num_opts;
448 if (child)
449 while (child->argp)
451 calc_sizes ((child++)->argp, szs);
452 szs->num_child_inputs++;
456 /* Initializes PARSER to parse ARGP in a manner described by FLAGS. */
457 static error_t
458 parser_init (struct parser *parser, const struct argp *argp,
459 int argc, char **argv, int flags, void *input)
461 error_t err = 0;
462 struct group *group;
463 struct parser_sizes szs;
464 struct _getopt_data opt_data = _GETOPT_DATA_INITIALIZER;
465 char *storage;
466 size_t glen, gsum;
467 size_t clen, csum;
468 size_t llen, lsum;
469 size_t slen, ssum;
471 szs.short_len = (flags & ARGP_NO_ARGS) ? 0 : 1;
472 szs.long_len = 0;
473 szs.num_groups = 0;
474 szs.num_child_inputs = 0;
476 if (argp)
477 calc_sizes (argp, &szs);
479 /* Lengths of the various bits of storage used by PARSER. */
480 glen = (szs.num_groups + 1) * sizeof (struct group);
481 clen = szs.num_child_inputs * sizeof (void *);
482 llen = (szs.long_len + 1) * sizeof (struct option);
483 slen = szs.short_len + 1;
485 /* Sums of previous lengths, properly aligned. There's no need to
486 align gsum, since struct group is aligned at least as strictly as
487 void * (since it contains a void * member). And there's no need
488 to align lsum, since struct option is aligned at least as
489 strictly as char. */
490 gsum = glen;
491 csum = alignto (gsum + clen, alignof (struct option));
492 lsum = csum + llen;
493 ssum = lsum + slen;
495 parser->storage = malloc (ssum);
496 if (! parser->storage)
497 return ENOMEM;
499 storage = parser->storage;
500 parser->groups = parser->storage;
501 parser->child_inputs = (void **) (storage + gsum);
502 parser->long_opts = (struct option *) (storage + csum);
503 parser->short_opts = storage + lsum;
504 parser->opt_data = opt_data;
506 memset (parser->child_inputs, 0, clen);
507 parser_convert (parser, argp, flags);
509 memset (&parser->state, 0, sizeof (struct argp_state));
510 parser->state.root_argp = parser->argp;
511 parser->state.argc = argc;
512 parser->state.argv = argv;
513 parser->state.flags = flags;
514 parser->state.err_stream = stderr;
515 parser->state.out_stream = stdout;
516 parser->state.next = 0; /* Tell getopt to initialize. */
517 parser->state.pstate = parser;
519 parser->try_getopt = 1;
521 /* Call each parser for the first time, giving it a chance to propagate
522 values to child parsers. */
523 if (parser->groups < parser->egroup)
524 parser->groups->input = input;
525 for (group = parser->groups;
526 group < parser->egroup && (!err || err == EBADKEY);
527 group++)
529 if (group->parent)
530 /* If a child parser, get the initial input value from the parent. */
531 group->input = group->parent->child_inputs[group->parent_index];
533 if (!group->parser
534 && group->argp->children && group->argp->children->argp)
535 /* For the special case where no parsing function is supplied for an
536 argp, propagate its input to its first child, if any (this just
537 makes very simple wrapper argps more convenient). */
538 group->child_inputs[0] = group->input;
540 err = group_parse (group, &parser->state, ARGP_KEY_INIT, 0);
542 if (err == EBADKEY)
543 err = 0; /* Some parser didn't understand. */
545 if (err)
546 return err;
548 if (parser->state.flags & ARGP_NO_ERRS)
550 parser->opt_data.opterr = 0;
551 if (parser->state.flags & ARGP_PARSE_ARGV0)
552 /* getopt always skips ARGV[0], so we have to fake it out. As long
553 as OPTERR is 0, then it shouldn't actually try to access it. */
554 parser->state.argv--, parser->state.argc++;
556 else
557 parser->opt_data.opterr = 1; /* Print error messages. */
559 if (parser->state.argv == argv && argv[0])
560 /* There's an argv[0]; use it for messages. */
561 parser->state.name = __argp_base_name (argv[0]);
562 else
563 parser->state.name = __argp_short_program_name ();
565 return 0;
568 /* Free any storage consumed by PARSER (but not PARSER itself). */
569 static error_t
570 parser_finalize (struct parser *parser,
571 error_t err, int arg_ebadkey, int *end_index)
573 struct group *group;
575 if (err == EBADKEY && arg_ebadkey)
576 /* Suppress errors generated by unparsed arguments. */
577 err = 0;
579 if (! err)
581 if (parser->state.next == parser->state.argc)
582 /* We successfully parsed all arguments! Call all the parsers again,
583 just a few more times... */
585 for (group = parser->groups;
586 group < parser->egroup && (!err || err==EBADKEY);
587 group++)
588 if (group->args_processed == 0)
589 err = group_parse (group, &parser->state, ARGP_KEY_NO_ARGS, 0);
590 for (group = parser->egroup - 1;
591 group >= parser->groups && (!err || err==EBADKEY);
592 group--)
593 err = group_parse (group, &parser->state, ARGP_KEY_END, 0);
595 if (err == EBADKEY)
596 err = 0; /* Some parser didn't understand. */
598 /* Tell the user that all arguments are parsed. */
599 if (end_index)
600 *end_index = parser->state.next;
602 else if (end_index)
603 /* Return any remaining arguments to the user. */
604 *end_index = parser->state.next;
605 else
606 /* No way to return the remaining arguments, they must be bogus. */
608 if (!(parser->state.flags & ARGP_NO_ERRS)
609 && parser->state.err_stream)
610 fprintf (parser->state.err_stream,
611 dgettext (parser->argp->argp_domain,
612 "%s: Too many arguments\n"),
613 parser->state.name);
614 err = EBADKEY;
618 /* Okay, we're all done, with either an error or success; call the parsers
619 to indicate which one. */
621 if (err)
623 /* Maybe print an error message. */
624 if (err == EBADKEY)
625 /* An appropriate message describing what the error was should have
626 been printed earlier. */
627 __argp_state_help (&parser->state, parser->state.err_stream,
628 ARGP_HELP_STD_ERR);
630 /* Since we didn't exit, give each parser an error indication. */
631 for (group = parser->groups; group < parser->egroup; group++)
632 group_parse (group, &parser->state, ARGP_KEY_ERROR, 0);
634 else
635 /* Notify parsers of success, and propagate back values from parsers. */
637 /* We pass over the groups in reverse order so that child groups are
638 given a chance to do there processing before passing back a value to
639 the parent. */
640 for (group = parser->egroup - 1
641 ; group >= parser->groups && (!err || err == EBADKEY)
642 ; group--)
643 err = group_parse (group, &parser->state, ARGP_KEY_SUCCESS, 0);
644 if (err == EBADKEY)
645 err = 0; /* Some parser didn't understand. */
648 /* Call parsers once more, to do any final cleanup. Errors are ignored. */
649 for (group = parser->egroup - 1; group >= parser->groups; group--)
650 group_parse (group, &parser->state, ARGP_KEY_FINI, 0);
652 if (err == EBADKEY)
653 err = EINVAL;
655 free (parser->storage);
657 return err;
660 /* Call the user parsers to parse the non-option argument VAL, at the current
661 position, returning any error. The state NEXT pointer is assumed to have
662 been adjusted (by getopt) to point after this argument; this function will
663 adjust it correctly to reflect however many args actually end up being
664 consumed. */
665 static error_t
666 parser_parse_arg (struct parser *parser, char *val)
668 /* Save the starting value of NEXT, first adjusting it so that the arg
669 we're parsing is again the front of the arg vector. */
670 int index = --parser->state.next;
671 error_t err = EBADKEY;
672 struct group *group;
673 int key = 0; /* Which of ARGP_KEY_ARG[S] we used. */
675 /* Try to parse the argument in each parser. */
676 for (group = parser->groups
677 ; group < parser->egroup && err == EBADKEY
678 ; group++)
680 parser->state.next++; /* For ARGP_KEY_ARG, consume the arg. */
681 key = ARGP_KEY_ARG;
682 err = group_parse (group, &parser->state, key, val);
684 if (err == EBADKEY)
685 /* This parser doesn't like ARGP_KEY_ARG; try ARGP_KEY_ARGS instead. */
687 parser->state.next--; /* For ARGP_KEY_ARGS, put back the arg. */
688 key = ARGP_KEY_ARGS;
689 err = group_parse (group, &parser->state, key, 0);
693 if (! err)
695 if (key == ARGP_KEY_ARGS)
696 /* The default for ARGP_KEY_ARGS is to assume that if NEXT isn't
697 changed by the user, *all* arguments should be considered
698 consumed. */
699 parser->state.next = parser->state.argc;
701 if (parser->state.next > index)
702 /* Remember that we successfully processed a non-option
703 argument -- but only if the user hasn't gotten tricky and set
704 the clock back. */
705 (--group)->args_processed += (parser->state.next - index);
706 else
707 /* The user wants to reparse some args, give getopt another try. */
708 parser->try_getopt = 1;
711 return err;
714 /* Call the user parsers to parse the option OPT, with argument VAL, at the
715 current position, returning any error. */
716 static error_t
717 parser_parse_opt (struct parser *parser, int opt, char *val)
719 /* The group key encoded in the high bits; 0 for short opts or
720 group_number + 1 for long opts. */
721 int group_key = opt >> USER_BITS;
722 error_t err = EBADKEY;
724 if (group_key == 0)
725 /* A short option. By comparing OPT's position in SHORT_OPTS to the
726 various starting positions in each group's SHORT_END field, we can
727 determine which group OPT came from. */
729 struct group *group;
730 char *short_index = strchr (parser->short_opts, opt);
732 if (short_index)
733 for (group = parser->groups; group < parser->egroup; group++)
734 if (group->short_end > short_index)
736 err = group_parse (group, &parser->state, opt,
737 parser->opt_data.optarg);
738 break;
741 else
742 /* A long option. We use shifts instead of masking for extracting
743 the user value in order to preserve the sign. */
744 err =
745 group_parse (&parser->groups[group_key - 1], &parser->state,
746 (opt << GROUP_BITS) >> GROUP_BITS,
747 parser->opt_data.optarg);
749 if (err == EBADKEY)
750 /* At least currently, an option not recognized is an error in the
751 parser, because we pre-compute which parser is supposed to deal
752 with each option. */
754 static const char bad_key_err[] =
755 N_("(PROGRAM ERROR) Option should have been recognized!?");
756 if (group_key == 0)
757 __argp_error (&parser->state, "-%c: %s", opt,
758 dgettext (parser->argp->argp_domain, bad_key_err));
759 else
761 struct option *long_opt = parser->long_opts;
762 while (long_opt->val != opt && long_opt->name)
763 long_opt++;
764 __argp_error (&parser->state, "--%s: %s",
765 long_opt->name ? long_opt->name : "???",
766 dgettext (parser->argp->argp_domain, bad_key_err));
770 return err;
773 /* Parse the next argument in PARSER (as indicated by PARSER->state.next).
774 Any error from the parsers is returned, and *ARGP_EBADKEY indicates
775 whether a value of EBADKEY is due to an unrecognized argument (which is
776 generally not fatal). */
777 static error_t
778 parser_parse_next (struct parser *parser, int *arg_ebadkey)
780 int opt;
781 error_t err = 0;
783 if (parser->state.quoted && parser->state.next < parser->state.quoted)
784 /* The next argument pointer has been moved to before the quoted
785 region, so pretend we never saw the quoting `--', and give getopt
786 another chance. If the user hasn't removed it, getopt will just
787 process it again. */
788 parser->state.quoted = 0;
790 if (parser->try_getopt && !parser->state.quoted)
791 /* Give getopt a chance to parse this. */
793 /* Put it back in OPTIND for getopt. */
794 parser->opt_data.optind = parser->state.next;
795 /* Distinguish KEY_ERR from a real option. */
796 parser->opt_data.optopt = KEY_END;
797 if (parser->state.flags & ARGP_LONG_ONLY)
798 opt = _getopt_long_only_r (parser->state.argc, parser->state.argv,
799 parser->short_opts, parser->long_opts, 0,
800 &parser->opt_data);
801 else
802 opt = _getopt_long_r (parser->state.argc, parser->state.argv,
803 parser->short_opts, parser->long_opts, 0,
804 &parser->opt_data);
805 /* And see what getopt did. */
806 parser->state.next = parser->opt_data.optind;
808 if (opt == KEY_END)
809 /* Getopt says there are no more options, so stop using
810 getopt; we'll continue if necessary on our own. */
812 parser->try_getopt = 0;
813 if (parser->state.next > 1
814 && strcmp (parser->state.argv[parser->state.next - 1], QUOTE)
815 == 0)
816 /* Not only is this the end of the options, but it's a
817 `quoted' region, which may have args that *look* like
818 options, so we definitely shouldn't try to use getopt past
819 here, whatever happens. */
820 parser->state.quoted = parser->state.next;
822 else if (opt == KEY_ERR && parser->opt_data.optopt != KEY_END)
823 /* KEY_ERR can have the same value as a valid user short
824 option, but in the case of a real error, getopt sets OPTOPT
825 to the offending character, which can never be KEY_END. */
827 *arg_ebadkey = 0;
828 return EBADKEY;
831 else
832 opt = KEY_END;
834 if (opt == KEY_END)
836 /* We're past what getopt considers the options. */
837 if (parser->state.next >= parser->state.argc
838 || (parser->state.flags & ARGP_NO_ARGS))
839 /* Indicate that we're done. */
841 *arg_ebadkey = 1;
842 return EBADKEY;
844 else
845 /* A non-option arg; simulate what getopt might have done. */
847 opt = KEY_ARG;
848 parser->opt_data.optarg = parser->state.argv[parser->state.next++];
852 if (opt == KEY_ARG)
853 /* A non-option argument; try each parser in turn. */
854 err = parser_parse_arg (parser, parser->opt_data.optarg);
855 else
856 err = parser_parse_opt (parser, opt, parser->opt_data.optarg);
858 if (err == EBADKEY)
859 *arg_ebadkey = (opt == KEY_END || opt == KEY_ARG);
861 return err;
864 /* Parse the options strings in ARGC & ARGV according to the argp in ARGP.
865 FLAGS is one of the ARGP_ flags above. If END_INDEX is non-NULL, the
866 index in ARGV of the first unparsed option is returned in it. If an
867 unknown option is present, EINVAL is returned; if some parser routine
868 returned a non-zero value, it is returned; otherwise 0 is returned. */
869 error_t
870 __argp_parse (const struct argp *argp, int argc, char **argv, unsigned flags,
871 int *end_index, void *input)
873 error_t err;
874 struct parser parser;
876 /* If true, then err == EBADKEY is a result of a non-option argument failing
877 to be parsed (which in some cases isn't actually an error). */
878 int arg_ebadkey = 0;
880 #ifndef _LIBC
881 if (!(flags & ARGP_PARSE_ARGV0))
883 #ifdef HAVE_DECL_PROGRAM_INVOCATION_NAME
884 if (!program_invocation_name)
885 program_invocation_name = argv[0];
886 #endif
887 #ifdef HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME
888 if (!program_invocation_short_name)
889 program_invocation_short_name = __argp_base_name (argv[0]);
890 #endif
892 #endif
894 if (! (flags & ARGP_NO_HELP))
895 /* Add our own options. */
897 struct argp_child *child = alloca (4 * sizeof (struct argp_child));
898 struct argp *top_argp = alloca (sizeof (struct argp));
900 /* TOP_ARGP has no options, it just serves to group the user & default
901 argps. */
902 memset (top_argp, 0, sizeof (*top_argp));
903 top_argp->children = child;
905 memset (child, 0, 4 * sizeof (struct argp_child));
907 if (argp)
908 (child++)->argp = argp;
909 (child++)->argp = &argp_default_argp;
910 if (argp_program_version || argp_program_version_hook)
911 (child++)->argp = &argp_version_argp;
912 child->argp = 0;
914 argp = top_argp;
917 /* Construct a parser for these arguments. */
918 err = parser_init (&parser, argp, argc, argv, flags, input);
920 if (! err)
921 /* Parse! */
923 while (! err)
924 err = parser_parse_next (&parser, &arg_ebadkey);
925 err = parser_finalize (&parser, err, arg_ebadkey, end_index);
928 return err;
930 #ifdef weak_alias
931 weak_alias (__argp_parse, argp_parse)
932 #endif
934 /* Return the input field for ARGP in the parser corresponding to STATE; used
935 by the help routines. */
936 void *
937 __argp_input (const struct argp *argp, const struct argp_state *state)
939 if (state)
941 struct group *group;
942 struct parser *parser = state->pstate;
944 for (group = parser->groups; group < parser->egroup; group++)
945 if (group->argp == argp)
946 return group->input;
949 return 0;
951 #ifdef weak_alias
952 weak_alias (__argp_input, _argp_input)
953 #endif