Mercurial > hg-old > index.cgi

comparison lib/argp-parse.c @ 265:68fbca173508 2.6

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Added generated files for release
author lost
date Tue, 22 Dec 2009 05:31:23 +0000
parents
children
comparison
equal deleted inserted replaced
264:61d1db1dfe2a 265:68fbca173508
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>.
5
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.
10
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.
15
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/>. */
18
19 #ifdef HAVE_CONFIG_H
20 # include <config.h>
21 #endif
22
23 #include <alloca.h>
24 #include <stddef.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <unistd.h>
28 #include <limits.h>
29 #include <getopt.h>
30 #include <getopt_int.h>
31
32 #ifdef _LIBC
33 # include <libintl.h>
34 # undef dgettext
35 # define dgettext(domain, msgid) \
36 INTUSE(__dcgettext) (domain, msgid, LC_MESSAGES)
37 #else
38 # include "gettext.h"
39 #endif
40 #define N_(msgid) msgid
41
42 #include "argp.h"
43 #include "argp-namefrob.h"
44
45 #define alignof(type) offsetof (struct { char c; type x; }, x)
46 #define alignto(n, d) ((((n) + (d) - 1) / (d)) * (d))
47
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. */
52
53 /* The meta-argument used to prevent any further arguments being interpreted
54 as options. */
55 #define QUOTE "--"
56
57 /* The number of bits we steal in a long-option value for our own use. */
58 #define GROUP_BITS CHAR_BIT
59
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)
63
64 /* EZ alias for ARGP_ERR_UNKNOWN. */
65 #define EBADKEY ARGP_ERR_UNKNOWN
66
67 /* Default options. */
68
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
72 it to 0 yourself. */
73 static volatile int _argp_hang;
74
75 #define OPT_PROGNAME -2
76 #define OPT_USAGE -3
77 #define OPT_HANG -4
78
79 static const struct argp_option argp_default_options[] =
80 {
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}
87 };
88
89 static error_t
90 argp_default_parser (int key, char *arg, struct argp_state *state)
91 {
92 switch (key)
93 {
94 case '?':
95 __argp_state_help (state, state->out_stream, ARGP_HELP_STD_HELP);
96 break;
97 case OPT_USAGE:
98 __argp_state_help (state, state->out_stream,
99 ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
100 break;
101
102 case OPT_PROGNAME: /* Set the program name. */
103 #if defined _LIBC || HAVE_DECL_PROGRAM_INVOCATION_NAME
104 program_invocation_name = arg;
105 #endif
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.] */
109
110 /* Update what we use for messages. */
111 state->name = __argp_base_name (arg);
112
113 #if defined _LIBC || HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME
114 program_invocation_short_name = state->name;
115 #endif
116
117 if ((state->flags & (ARGP_PARSE_ARGV0 | ARGP_NO_ERRS))
118 == ARGP_PARSE_ARGV0)
119 /* Update what getopt uses too. */
120 state->argv[0] = arg;
121
122 break;
123
124 case OPT_HANG:
125 _argp_hang = atoi (arg ? arg : "3600");
126 while (_argp_hang-- > 0)
127 __sleep (1);
128 break;
129
130 default:
131 return EBADKEY;
132 }
133 return 0;
134 }
135
136 static const struct argp argp_default_argp =
137 {argp_default_options, &argp_default_parser, NULL, NULL, NULL, NULL, "libc"};
138
139
140 static const struct argp_option argp_version_options[] =
141 {
142 {"version", 'V', 0, 0, N_("print program version"), -1},
143 {NULL, 0, 0, 0, NULL, 0}
144 };
145
146 static error_t
147 argp_version_parser (int key, char *arg, struct argp_state *state)
148 {
149 switch (key)
150 {
151 case 'V':
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);
156 else
157 __argp_error (state, dgettext (state->root_argp->argp_domain,
158 "(PROGRAM ERROR) No version known!?"));
159 if (! (state->flags & ARGP_NO_EXIT))
160 exit (0);
161 break;
162 default:
163 return EBADKEY;
164 }
165 return 0;
166 }
167
168 static const struct argp argp_version_argp =
169 {argp_version_options, &argp_version_parser, NULL, NULL, NULL, NULL, "libc"};
170
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. */
174 static int
175 find_long_option (struct option *long_options, const char *name)
176 {
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;
181 else
182 l++;
183 if (name == NULL)
184 return l - long_options;
185 else
186 return -1;
187 }
188
189
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. */
193 struct group
194 {
195 /* This group's parsing function. */
196 argp_parser_t parser;
197
198 /* Which argp this group is from. */
199 const struct argp *argp;
200
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. */
204 char *short_end;
205
206 /* The number of non-option args sucessfully handled by this parser. */
207 unsigned args_processed;
208
209 /* This group's parser's parent's group. */
210 struct group *parent;
211 unsigned parent_index; /* And the our position in the parent. */
212
213 /* These fields are swapped into and out of the state structure when
214 calling this group's parser. */
215 void *input, **child_inputs;
216 void *hook;
217 };
218
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. */
222 static error_t
223 group_parse (struct group *group, struct argp_state *state, int key, char *arg)
224 {
225 if (group->parser)
226 {
227 error_t err;
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;
234 return err;
235 }
236 else
237 return EBADKEY;
238 }
239
240 struct parser
241 {
242 const struct argp *argp;
243
244 /* SHORT_OPTS is the getopt short options string for the union of all the
245 groups of options. */
246 char *short_opts;
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;
252
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. */
258 void **child_inputs;
259
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. */
264 int try_getopt;
265
266 /* State block supplied to parsing routines. */
267 struct argp_state state;
268
269 /* Memory used by this parser. */
270 void *storage;
271 };
272
273 /* The next usable entries in the various parser tables being filled in by
274 convert_options. */
275 struct parser_convert_state
276 {
277 struct parser *parser;
278 char *short_end;
279 struct option *long_end;
280 void **child_inputs_end;
281 };
282
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)
291 {
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;
295
296 if (real || argp->parser)
297 {
298 const struct argp_option *opt;
299
300 if (real)
301 for (opt = real; !__option_is_end (opt); opt++)
302 {
303 if (! (opt->flags & OPTION_ALIAS))
304 /* OPT isn't an alias, so we can use values from it. */
305 real = opt;
306
307 if (! (real->flags & OPTION_DOC))
308 /* A real option (not just documentation). */
309 {
310 if (__option_is_short (opt))
311 /* OPT can be used as a short option. */
312 {
313 *cvt->short_end++ = opt->key;
314 if (real->arg)
315 {
316 *cvt->short_end++ = ':';
317 if (real->flags & OPTION_ARG_OPTIONAL)
318 *cvt->short_end++ = ':';
319 }
320 *cvt->short_end = '\0'; /* keep 0 terminated */
321 }
322
323 if (opt->name
324 && find_long_option (cvt->parser->long_opts, opt->name) < 0)
325 /* OPT can be used as a long option. */
326 {
327 cvt->long_end->name = opt->name;
328 cvt->long_end->has_arg =
329 (real->arg
330 ? (real->flags & OPTION_ARG_OPTIONAL
331 ? optional_argument
332 : required_argument)
333 : no_argument);
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
340 however)... */
341 cvt->long_end->val =
342 ((opt->key | real->key) & USER_MASK)
343 + (((group - cvt->parser->groups) + 1) << USER_BITS);
344
345 /* Keep the LONG_OPTS list terminated. */
346 (++cvt->long_end)->name = NULL;
347 }
348 }
349 }
350
351 group->parser = argp->parser;
352 group->argp = argp;
353 group->short_end = cvt->short_end;
354 group->args_processed = 0;
355 group->parent = parent;
356 group->parent_index = parent_index;
357 group->input = 0;
358 group->hook = 0;
359 group->child_inputs = 0;
360
361 if (children)
362 /* Assign GROUP's CHILD_INPUTS field some space from
363 CVT->child_inputs_end.*/
364 {
365 unsigned num_children = 0;
366 while (children[num_children].argp)
367 num_children++;
368 group->child_inputs = cvt->child_inputs_end;
369 cvt->child_inputs_end += num_children;
370 }
371
372 parent = group++;
373 }
374 else
375 parent = 0;
376
377 if (children)
378 {
379 unsigned index = 0;
380 while (children->argp)
381 group =
382 convert_options (children++->argp, parent, index++, group, cvt);
383 }
384
385 return group;
386 }
387
388 /* Find the merged set of getopt options, with keys appropiately prefixed. */
389 static void
390 parser_convert (struct parser *parser, const struct argp *argp, int flags)
391 {
392 struct parser_convert_state cvt;
393
394 cvt.parser = parser;
395 cvt.short_end = parser->short_opts;
396 cvt.long_end = parser->long_opts;
397 cvt.child_inputs_end = parser->child_inputs;
398
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';
404
405 cvt.long_end->name = NULL;
406
407 parser->argp = argp;
408
409 if (argp)
410 parser->egroup = convert_options (argp, 0, 0, parser->groups, &cvt);
411 else
412 parser->egroup = parser->groups; /* No parsers at all! */
413 }
414
415 /* Lengths of various parser fields which we will allocated. */
416 struct parser_sizes
417 {
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. */
422 };
423
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. */
428 static void
429 calc_sizes (const struct argp *argp, struct parser_sizes *szs)
430 {
431 const struct argp_child *child = argp->children;
432 const struct argp_option *opt = argp->options;
433
434 if (opt || argp->parser)
435 {
436 szs->num_groups++;
437 if (opt)
438 {
439 int num_opts = 0;
440 while (!__option_is_end (opt++))
441 num_opts++;
442 szs->short_len += num_opts * 3; /* opt + up to 2 `:'s */
443 szs->long_len += num_opts;
444 }
445 }
446
447 if (child)
448 while (child->argp)
449 {
450 calc_sizes ((child++)->argp, szs);
451 szs->num_child_inputs++;
452 }
453 }
454
455 /* Initializes PARSER to parse ARGP in a manner described by FLAGS. */
456 static error_t
457 parser_init (struct parser *parser, const struct argp *argp,
458 int argc, char **argv, int flags, void *input)
459 {
460 error_t err = 0;
461 struct group *group;
462 struct parser_sizes szs;
463 struct _getopt_data opt_data = _GETOPT_DATA_INITIALIZER;
464 char *storage;
465 size_t glen, gsum;
466 size_t clen, csum;
467 size_t llen, lsum;
468 size_t slen, ssum;
469
470 szs.short_len = (flags & ARGP_NO_ARGS) ? 0 : 1;
471 szs.long_len = 0;
472 szs.num_groups = 0;
473 szs.num_child_inputs = 0;
474
475 if (argp)
476 calc_sizes (argp, &szs);
477
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;
483
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
488 strictly as char. */
489 gsum = glen;
490 csum = alignto (gsum + clen, alignof (struct option));
491 lsum = csum + llen;
492 ssum = lsum + slen;
493
494 parser->storage = malloc (ssum);
495 if (! parser->storage)
496 return ENOMEM;
497
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;
504
505 memset (parser->child_inputs, 0, clen);
506 parser_convert (parser, argp, flags);
507
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;
517
518 parser->try_getopt = 1;
519
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);
526 group++)
527 {
528 if (group->parent)
529 /* If a child parser, get the initial input value from the parent. */
530 group->input = group->parent->child_inputs[group->parent_index];
531
532 if (!group->parser
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;
538
539 err = group_parse (group, &parser->state, ARGP_KEY_INIT, 0);
540 }
541 if (err == EBADKEY)
542 err = 0; /* Some parser didn't understand. */
543
544 if (err)
545 return err;
546
547 if (parser->state.flags & ARGP_NO_ERRS)
548 {
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++;
554 }
555 else
556 parser->opt_data.opterr = 1; /* Print error messages. */
557
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]);
561 else
562 parser->state.name = __argp_short_program_name ();
563
564 return 0;
565 }
566
567 /* Free any storage consumed by PARSER (but not PARSER itself). */
568 static error_t
569 parser_finalize (struct parser *parser,
570 error_t err, int arg_ebadkey, int *end_index)
571 {
572 struct group *group;
573
574 if (err == EBADKEY && arg_ebadkey)
575 /* Suppress errors generated by unparsed arguments. */
576 err = 0;
577
578 if (! err)
579 {
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... */
583 {
584 for (group = parser->groups;
585 group < parser->egroup && (!err || err==EBADKEY);
586 group++)
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);
591 group--)
592 err = group_parse (group, &parser->state, ARGP_KEY_END, 0);
593
594 if (err == EBADKEY)
595 err = 0; /* Some parser didn't understand. */
596
597 /* Tell the user that all arguments are parsed. */
598 if (end_index)
599 *end_index = parser->state.next;
600 }
601 else if (end_index)
602 /* Return any remaining arguments to the user. */
603 *end_index = parser->state.next;
604 else
605 /* No way to return the remaining arguments, they must be bogus. */
606 {
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"),
612 parser->state.name);
613 err = EBADKEY;
614 }
615 }
616
617 /* Okay, we're all done, with either an error or success; call the parsers
618 to indicate which one. */
619
620 if (err)
621 {
622 /* Maybe print an error message. */
623 if (err == EBADKEY)
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,
627 ARGP_HELP_STD_ERR);
628
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);
632 }
633 else
634 /* Notify parsers of success, and propagate back values from parsers. */
635 {
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
638 the parent. */
639 for (group = parser->egroup - 1
640 ; group >= parser->groups && (!err || err == EBADKEY)
641 ; group--)
642 err = group_parse (group, &parser->state, ARGP_KEY_SUCCESS, 0);
643 if (err == EBADKEY)
644 err = 0; /* Some parser didn't understand. */
645 }
646
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);
650
651 if (err == EBADKEY)
652 err = EINVAL;
653
654 free (parser->storage);
655
656 return err;
657 }
658
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
663 consumed. */
664 static error_t
665 parser_parse_arg (struct parser *parser, char *val)
666 {
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;
671 struct group *group;
672 int key = 0; /* Which of ARGP_KEY_ARG[S] we used. */
673
674 /* Try to parse the argument in each parser. */
675 for (group = parser->groups
676 ; group < parser->egroup && err == EBADKEY
677 ; group++)
678 {
679 parser->state.next++; /* For ARGP_KEY_ARG, consume the arg. */
680 key = ARGP_KEY_ARG;
681 err = group_parse (group, &parser->state, key, val);
682
683 if (err == EBADKEY)
684 /* This parser doesn't like ARGP_KEY_ARG; try ARGP_KEY_ARGS instead. */
685 {
686 parser->state.next--; /* For ARGP_KEY_ARGS, put back the arg. */
687 key = ARGP_KEY_ARGS;
688 err = group_parse (group, &parser->state, key, 0);
689 }
690 }
691
692 if (! err)
693 {
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
697 consumed. */
698 parser->state.next = parser->state.argc;
699
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
703 the clock back. */
704 (--group)->args_processed += (parser->state.next - index);
705 else
706 /* The user wants to reparse some args, give getopt another try. */
707 parser->try_getopt = 1;
708 }
709
710 return err;
711 }
712
713 /* Call the user parsers to parse the option OPT, with argument VAL, at the
714 current position, returning any error. */
715 static error_t
716 parser_parse_opt (struct parser *parser, int opt, char *val)
717 {
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;
722
723 if (group_key == 0)
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. */
727 {
728 struct group *group;
729 char *short_index = strchr (parser->short_opts, opt);
730
731 if (short_index)
732 for (group = parser->groups; group < parser->egroup; group++)
733 if (group->short_end > short_index)
734 {
735 err = group_parse (group, &parser->state, opt,
736 parser->opt_data.optarg);
737 break;
738 }
739 }
740 else
741 /* A long option. We use shifts instead of masking for extracting
742 the user value in order to preserve the sign. */
743 err =
744 group_parse (&parser->groups[group_key - 1], &parser->state,
745 (opt << GROUP_BITS) >> GROUP_BITS,
746 parser->opt_data.optarg);
747
748 if (err == EBADKEY)
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
751 with each option. */
752 {
753 static const char bad_key_err[] =
754 N_("(PROGRAM ERROR) Option should have been recognized!?");
755 if (group_key == 0)
756 __argp_error (&parser->state, "-%c: %s", opt,
757 dgettext (parser->argp->argp_domain, bad_key_err));
758 else
759 {
760 struct option *long_opt = parser->long_opts;
761 while (long_opt->val != opt && long_opt->name)
762 long_opt++;
763 __argp_error (&parser->state, "--%s: %s",
764 long_opt->name ? long_opt->name : "???",
765 dgettext (parser->argp->argp_domain, bad_key_err));
766 }
767 }
768
769 return err;
770 }
771
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). */
776 static error_t
777 parser_parse_next (struct parser *parser, int *arg_ebadkey)
778 {
779 int opt;
780 error_t err = 0;
781
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
786 process it again. */
787 parser->state.quoted = 0;
788
789 if (parser->try_getopt && !parser->state.quoted)
790 /* Give getopt a chance to parse this. */
791 {
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,
799 &parser->opt_data);
800 else
801 opt = _getopt_long_r (parser->state.argc, parser->state.argv,
802 parser->short_opts, parser->long_opts, 0,
803 &parser->opt_data);
804 /* And see what getopt did. */
805 parser->state.next = parser->opt_data.optind;
806
807 if (opt == KEY_END)
808 /* Getopt says there are no more options, so stop using
809 getopt; we'll continue if necessary on our own. */
810 {
811 parser->try_getopt = 0;
812 if (parser->state.next > 1
813 && strcmp (parser->state.argv[parser->state.next - 1], QUOTE)
814 == 0)
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;
820 }
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. */
825 {
826 *arg_ebadkey = 0;
827 return EBADKEY;
828 }
829 }
830 else
831 opt = KEY_END;
832
833 if (opt == KEY_END)
834 {
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. */
839 {
840 *arg_ebadkey = 1;
841 return EBADKEY;
842 }
843 else
844 /* A non-option arg; simulate what getopt might have done. */
845 {
846 opt = KEY_ARG;
847 parser->opt_data.optarg = parser->state.argv[parser->state.next++];
848 }
849 }
850
851 if (opt == KEY_ARG)
852 /* A non-option argument; try each parser in turn. */
853 err = parser_parse_arg (parser, parser->opt_data.optarg);
854 else
855 err = parser_parse_opt (parser, opt, parser->opt_data.optarg);
856
857 if (err == EBADKEY)
858 *arg_ebadkey = (opt == KEY_END || opt == KEY_ARG);
859
860 return err;
861 }
862
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. */
868 error_t
869 __argp_parse (const struct argp *argp, int argc, char **argv, unsigned flags,
870 int *end_index, void *input)
871 {
872 error_t err;
873 struct parser parser;
874
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). */
877 int arg_ebadkey = 0;
878
879 #ifndef _LIBC
880 if (!(flags & ARGP_PARSE_ARGV0))
881 {
882 #ifdef HAVE_DECL_PROGRAM_INVOCATION_NAME
883 if (!program_invocation_name)
884 program_invocation_name = argv[0];
885 #endif
886 #ifdef HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME
887 if (!program_invocation_short_name)
888 program_invocation_short_name = __argp_base_name (argv[0]);
889 #endif
890 }
891 #endif
892
893 if (! (flags & ARGP_NO_HELP))
894 /* Add our own options. */
895 {
896 struct argp_child *child = alloca (4 * sizeof (struct argp_child));
897 struct argp *top_argp = alloca (sizeof (struct argp));
898
899 /* TOP_ARGP has no options, it just serves to group the user & default
900 argps. */
901 memset (top_argp, 0, sizeof (*top_argp));
902 top_argp->children = child;
903
904 memset (child, 0, 4 * sizeof (struct argp_child));
905
906 if (argp)
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;
911 child->argp = 0;
912
913 argp = top_argp;
914 }
915
916 /* Construct a parser for these arguments. */
917 err = parser_init (&parser, argp, argc, argv, flags, input);
918
919 if (! err)
920 /* Parse! */
921 {
922 while (! err)
923 err = parser_parse_next (&parser, &arg_ebadkey);
924 err = parser_finalize (&parser, err, arg_ebadkey, end_index);
925 }
926
927 return err;
928 }
929 #ifdef weak_alias
930 weak_alias (__argp_parse, argp_parse)
931 #endif
932
933 /* Return the input field for ARGP in the parser corresponding to STATE; used
934 by the help routines. */
935 void *
936 __argp_input (const struct argp *argp, const struct argp_state *state)
937 {
938 if (state)
939 {
940 struct group *group;
941 struct parser *parser = state->pstate;
942
943 for (group = parser->groups; group < parser->egroup; group++)
944 if (group->argp == argp)
945 return group->input;
946 }
947
948 return 0;
949 }
950 #ifdef weak_alias
951 weak_alias (__argp_input, _argp_input)
952 #endif