1/* Hierarchial argument parsing, layered over getopt
2 Copyright (C) 1995-2024 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 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2.1 of the License, or (at your option) any later version.
10
11 The GNU C Library 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 GNU
14 Lesser General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; if not, see
18 <https://www.gnu.org/licenses/>. */
19
20#ifdef HAVE_CONFIG_H
21#include <config.h>
22#endif
23
24#include <stdlib.h>
25#include <string.h>
26#include <unistd.h>
27#include <limits.h>
28#include <getopt.h>
29#include <getopt_int.h>
30
31#ifndef _
32/* This is for other GNU distributions with internationalized messages.
33 When compiling libc, the _ macro is predefined. */
34# if defined HAVE_LIBINTL_H || defined _LIBC
35# include <libintl.h>
36# ifdef _LIBC
37# undef dgettext
38# define dgettext(domain, msgid) \
39 __dcgettext (domain, msgid, LC_MESSAGES)
40# endif
41# else
42# define dgettext(domain, msgid) (msgid)
43# define gettext(msgid) (msgid)
44# endif
45#endif
46#ifndef N_
47# define N_(msgid) (msgid)
48#endif
49
50#include <argp.h>
51#include "argp-namefrob.h"
52
53/* Getopt return values. */
54#define KEY_END (-1) /* The end of the options. */
55#define KEY_ARG 1 /* A non-option argument. */
56#define KEY_ERR '?' /* An error parsing the options. */
57
58/* The meta-argument used to prevent any further arguments being interpreted
59 as options. */
60#define QUOTE "--"
61
62/* The number of bits we steal in a long-option value for our own use. */
63#define GROUP_BITS CHAR_BIT
64
65/* The number of bits available for the user value. */
66#define USER_BITS ((sizeof ((struct option *)0)->val * CHAR_BIT) - GROUP_BITS)
67#define USER_MASK ((1 << USER_BITS) - 1)
68
69/* EZ alias for ARGP_ERR_UNKNOWN. */
70#define EBADKEY ARGP_ERR_UNKNOWN
71
72/* Default options. */
73
74/* When argp is given the --HANG switch, _ARGP_HANG is set and argp will sleep
75 for one second intervals, decrementing _ARGP_HANG until it's zero. Thus
76 you can force the program to continue by attaching a debugger and setting
77 it to 0 yourself. */
78static volatile int _argp_hang;
79
80#define OPT_PROGNAME -2
81#define OPT_USAGE -3
82#define OPT_HANG -4
83
84static const struct argp_option argp_default_options[] =
85{
86 {"help", '?', 0, 0, N_("Give this help list"), -1},
87 {"usage", OPT_USAGE, 0, 0, N_("Give a short usage message")},
88 {"program-name",OPT_PROGNAME, N_("NAME"), OPTION_HIDDEN,
89 N_("Set the program name")},
90 {"HANG", OPT_HANG, N_("SECS"), OPTION_ARG_OPTIONAL | OPTION_HIDDEN,
91 N_("Hang for SECS seconds (default 3600)")},
92 {0, 0}
93};
94
95static error_t
96argp_default_parser (int key, char *arg, struct argp_state *state)
97{
98 switch (key)
99 {
100 case '?':
101 __argp_state_help (state, state->out_stream, ARGP_HELP_STD_HELP);
102 break;
103 case OPT_USAGE:
104 __argp_state_help (state, state->out_stream,
105 ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
106 break;
107
108 case OPT_PROGNAME: /* Set the program name. */
109#if defined _LIBC || HAVE_DECL_PROGRAM_INVOCATION_NAME
110 program_invocation_name = arg;
111#endif
112 /* [Note that some systems only have PROGRAM_INVOCATION_SHORT_NAME (aka
113 __PROGNAME), in which case, PROGRAM_INVOCATION_NAME is just defined
114 to be that, so we have to be a bit careful here.] */
115
116 /* Update what we use for messages. */
117 state->name = strrchr (arg, '/');
118 if (state->name)
119 state->name++;
120 else
121 state->name = arg;
122
123#if defined _LIBC || HAVE_DECL_PROGRAM_INVOCATION_SHORT_NAME
124 program_invocation_short_name = state->name;
125#endif
126
127 if ((state->flags & (ARGP_PARSE_ARGV0 | ARGP_NO_ERRS))
128 == ARGP_PARSE_ARGV0)
129 /* Update what getopt uses too. */
130 state->argv[0] = arg;
131
132 break;
133
134 case OPT_HANG:
135 _argp_hang = arg ? strtol (arg, NULL, 10) : 3600;
136 while (_argp_hang-- > 0)
137 __sleep (seconds: 1);
138 break;
139
140 default:
141 return EBADKEY;
142 }
143 return 0;
144}
145
146static const struct argp argp_default_argp =
147 {argp_default_options, &argp_default_parser, NULL, NULL, NULL, NULL, "libc"};
148
149
150static const struct argp_option argp_version_options[] =
151{
152 {"version", 'V', 0, 0, N_("Print program version"), -1},
153 {0, 0}
154};
155
156static error_t
157argp_version_parser (int key, char *arg, struct argp_state *state)
158{
159 switch (key)
160 {
161 case 'V':
162 if (argp_program_version_hook)
163 (*argp_program_version_hook) (state->out_stream, state);
164 else if (argp_program_version)
165 fprintf (state->out_stream, "%s\n", argp_program_version);
166 else
167 __argp_error (state, dgettext (state->root_argp->argp_domain,
168 "(PROGRAM ERROR) No version known!?"));
169 if (! (state->flags & ARGP_NO_EXIT))
170 exit (0);
171 break;
172 default:
173 return EBADKEY;
174 }
175 return 0;
176}
177
178static const struct argp argp_version_argp =
179 {argp_version_options, &argp_version_parser, NULL, NULL, NULL, NULL, "libc"};
180
181/* Returns the offset into the getopt long options array LONG_OPTIONS of a
182 long option with called NAME, or -1 if none is found. Passing NULL as
183 NAME will return the number of options. */
184static int
185find_long_option (struct option *long_options, const char *name)
186{
187 struct option *l = long_options;
188 while (l->name != NULL)
189 if (name != NULL && strcmp (l->name, name) == 0)
190 return l - long_options;
191 else
192 l++;
193 if (name == NULL)
194 return l - long_options;
195 else
196 return -1;
197}
198
199
200/* The state of a `group' during parsing. Each group corresponds to a
201 particular argp structure from the tree of such descending from the top
202 level argp passed to argp_parse. */
203struct group
204{
205 /* This group's parsing function. */
206 argp_parser_t parser;
207
208 /* Which argp this group is from. */
209 const struct argp *argp;
210
211 /* Points to the point in SHORT_OPTS corresponding to the end of the short
212 options for this group. We use it to determine from which group a
213 particular short options is from. */
214 char *short_end;
215
216 /* The number of non-option args successfully handled by this parser. */
217 unsigned args_processed;
218
219 /* This group's parser's parent's group. */
220 struct group *parent;
221 unsigned parent_index; /* And the our position in the parent. */
222
223 /* These fields are swapped into and out of the state structure when
224 calling this group's parser. */
225 void *input, **child_inputs;
226 void *hook;
227};
228
229/* Call GROUP's parser with KEY and ARG, swapping any group-specific info
230 from STATE before calling, and back into state afterwards. If GROUP has
231 no parser, EBADKEY is returned. */
232static error_t
233group_parse (struct group *group, struct argp_state *state, int key, char *arg)
234{
235 if (group->parser)
236 {
237 error_t err;
238 state->hook = group->hook;
239 state->input = group->input;
240 state->child_inputs = group->child_inputs;
241 state->arg_num = group->args_processed;
242 err = (*group->parser)(key, arg, state);
243 group->hook = state->hook;
244 return err;
245 }
246 else
247 return EBADKEY;
248}
249
250struct parser
251{
252 const struct argp *argp;
253
254 /* SHORT_OPTS is the getopt short options string for the union of all the
255 groups of options. */
256 char *short_opts;
257 /* LONG_OPTS is the array of getop long option structures for the union of
258 all the groups of options. */
259 struct option *long_opts;
260 /* OPT_DATA is the getopt data used for the re-entrant getopt. */
261 struct _getopt_data opt_data;
262
263 /* States of the various parsing groups. */
264 struct group *groups;
265 /* The end of the GROUPS array. */
266 struct group *egroup;
267 /* An vector containing storage for the CHILD_INPUTS field in all groups. */
268 void **child_inputs;
269
270 /* True if we think using getopt is still useful; if false, then
271 remaining arguments are just passed verbatim with ARGP_KEY_ARG. This is
272 cleared whenever getopt returns KEY_END, but may be set again if the user
273 moves the next argument pointer backwards. */
274 int try_getopt;
275
276 /* State block supplied to parsing routines. */
277 struct argp_state state;
278
279 /* Memory used by this parser. */
280 void *storage;
281};
282
283/* The next usable entries in the various parser tables being filled in by
284 convert_options. */
285struct parser_convert_state
286{
287 struct parser *parser;
288 char *short_end;
289 struct option *long_end;
290 void **child_inputs_end;
291};
292
293/* Converts all options in ARGP (which is put in GROUP) and ancestors
294 into getopt options stored in SHORT_OPTS and LONG_OPTS; SHORT_END and
295 CVT->LONG_END are the points at which new options are added. Returns the
296 next unused group entry. CVT holds state used during the conversion. */
297static struct group *
298convert_options (const struct argp *argp,
299 struct group *parent, unsigned parent_index,
300 struct group *group, struct parser_convert_state *cvt)
301{
302 /* REAL is the most recent non-alias value of OPT. */
303 const struct argp_option *real = argp->options;
304 const struct argp_child *children = argp->children;
305
306 if (real || argp->parser)
307 {
308 const struct argp_option *opt;
309
310 if (real)
311 for (opt = real; !__option_is_end (opt: opt); opt++)
312 {
313 if (! (opt->flags & OPTION_ALIAS))
314 /* OPT isn't an alias, so we can use values from it. */
315 real = opt;
316
317 if (! (real->flags & OPTION_DOC))
318 /* A real option (not just documentation). */
319 {
320 if (__option_is_short (opt: opt))
321 /* OPT can be used as a short option. */
322 {
323 *cvt->short_end++ = opt->key;
324 if (real->arg)
325 {
326 *cvt->short_end++ = ':';
327 if (real->flags & OPTION_ARG_OPTIONAL)
328 *cvt->short_end++ = ':';
329 }
330 *cvt->short_end = '\0'; /* keep 0 terminated */
331 }
332
333 if (opt->name
334 && find_long_option (long_options: cvt->parser->long_opts, name: opt->name) < 0)
335 /* OPT can be used as a long option. */
336 {
337 cvt->long_end->name = opt->name;
338 cvt->long_end->has_arg =
339 (real->arg
340 ? (real->flags & OPTION_ARG_OPTIONAL
341 ? optional_argument
342 : required_argument)
343 : no_argument);
344 cvt->long_end->flag = 0;
345 /* we add a disambiguating code to all the user's
346 values (which is removed before we actually call
347 the function to parse the value); this means that
348 the user loses use of the high 8 bits in all his
349 values (the sign of the lower bits is preserved
350 however)... */
351 cvt->long_end->val =
352 ((opt->key ? opt->key : real->key) & USER_MASK)
353 + (((group - cvt->parser->groups) + 1) << USER_BITS);
354
355 /* Keep the LONG_OPTS list terminated. */
356 (++cvt->long_end)->name = NULL;
357 }
358 }
359 }
360
361 group->parser = argp->parser;
362 group->argp = argp;
363 group->short_end = cvt->short_end;
364 group->args_processed = 0;
365 group->parent = parent;
366 group->parent_index = parent_index;
367 group->input = 0;
368 group->hook = 0;
369 group->child_inputs = 0;
370
371 if (children)
372 /* Assign GROUP's CHILD_INPUTS field some space from
373 CVT->child_inputs_end.*/
374 {
375 unsigned num_children = 0;
376 while (children[num_children].argp)
377 num_children++;
378 group->child_inputs = cvt->child_inputs_end;
379 cvt->child_inputs_end += num_children;
380 }
381
382 parent = group++;
383 }
384 else
385 parent = 0;
386
387 if (children)
388 {
389 unsigned index = 0;
390 while (children->argp)
391 group =
392 convert_options (argp: children++->argp, parent, parent_index: index++, group, cvt);
393 }
394
395 return group;
396}
397
398/* Find the merged set of getopt options, with keys appropriately prefixed. */
399static void
400parser_convert (struct parser *parser, const struct argp *argp, int flags)
401{
402 struct parser_convert_state cvt;
403
404 cvt.parser = parser;
405 cvt.short_end = parser->short_opts;
406 cvt.long_end = parser->long_opts;
407 cvt.child_inputs_end = parser->child_inputs;
408
409 if (flags & ARGP_IN_ORDER)
410 *cvt.short_end++ = '-';
411 else if (flags & ARGP_NO_ARGS)
412 *cvt.short_end++ = '+';
413 *cvt.short_end = '\0';
414
415 cvt.long_end->name = NULL;
416
417 parser->argp = argp;
418
419 if (argp)
420 parser->egroup = convert_options (argp, parent: 0, parent_index: 0, group: parser->groups, cvt: &cvt);
421 else
422 parser->egroup = parser->groups; /* No parsers at all! */
423}
424
425/* Lengths of various parser fields which we will allocated. */
426struct parser_sizes
427{
428 size_t short_len; /* Getopt short options string. */
429 size_t long_len; /* Getopt long options vector. */
430 size_t num_groups; /* Group structures we allocate. */
431 size_t num_child_inputs; /* Child input slots. */
432};
433
434/* For ARGP, increments the NUM_GROUPS field in SZS by the total number of
435 argp structures descended from it, and the SHORT_LEN & LONG_LEN fields by
436 the maximum lengths of the resulting merged getopt short options string and
437 long-options array, respectively. */
438static void
439calc_sizes (const struct argp *argp, struct parser_sizes *szs)
440{
441 const struct argp_child *child = argp->children;
442 const struct argp_option *opt = argp->options;
443
444 if (opt || argp->parser)
445 {
446 szs->num_groups++;
447 if (opt)
448 {
449 int num_opts = 0;
450 while (!__option_is_end (opt: opt++))
451 num_opts++;
452 szs->short_len += num_opts * 3; /* opt + up to 2 `:'s */
453 szs->long_len += num_opts;
454 }
455 }
456
457 if (child)
458 while (child->argp)
459 {
460 calc_sizes (argp: (child++)->argp, szs);
461 szs->num_child_inputs++;
462 }
463}
464
465/* Initializes PARSER to parse ARGP in a manner described by FLAGS. */
466static error_t
467parser_init (struct parser *parser, const struct argp *argp,
468 int argc, char **argv, int flags, void *input)
469{
470 error_t err = 0;
471 struct group *group;
472 struct parser_sizes szs;
473 struct _getopt_data opt_data = _GETOPT_DATA_INITIALIZER;
474
475 szs.short_len = (flags & ARGP_NO_ARGS) ? 0 : 1;
476 szs.long_len = 0;
477 szs.num_groups = 0;
478 szs.num_child_inputs = 0;
479
480 if (argp)
481 calc_sizes (argp, szs: &szs);
482
483 /* Lengths of the various bits of storage used by PARSER. */
484#define GLEN (szs.num_groups + 1) * sizeof (struct group)
485#define CLEN (szs.num_child_inputs * sizeof (void *))
486#define LLEN ((szs.long_len + 1) * sizeof (struct option))
487#define SLEN (szs.short_len + 1)
488
489 parser->storage = malloc (GLEN + CLEN + LLEN + SLEN);
490 if (! parser->storage)
491 return ENOMEM;
492
493 parser->groups = parser->storage;
494 parser->child_inputs = parser->storage + GLEN;
495 parser->long_opts = parser->storage + GLEN + CLEN;
496 parser->short_opts = parser->storage + GLEN + CLEN + LLEN;
497 parser->opt_data = opt_data;
498
499 memset (parser->child_inputs, 0, szs.num_child_inputs * sizeof (void *));
500 parser_convert (parser, argp, flags);
501
502 memset (&parser->state, 0, sizeof (struct argp_state));
503 parser->state.root_argp = parser->argp;
504 parser->state.argc = argc;
505 parser->state.argv = argv;
506 parser->state.flags = flags;
507 parser->state.err_stream = stderr;
508 parser->state.out_stream = stdout;
509 parser->state.next = 0; /* Tell getopt to initialize. */
510 parser->state.pstate = parser;
511
512 parser->try_getopt = 1;
513
514 /* Call each parser for the first time, giving it a chance to propagate
515 values to child parsers. */
516 if (parser->groups < parser->egroup)
517 parser->groups->input = input;
518 for (group = parser->groups;
519 group < parser->egroup && (!err || err == EBADKEY);
520 group++)
521 {
522 if (group->parent)
523 /* If a child parser, get the initial input value from the parent. */
524 group->input = group->parent->child_inputs[group->parent_index];
525
526 if (!group->parser
527 && group->argp->children && group->argp->children->argp)
528 /* For the special case where no parsing function is supplied for an
529 argp, propagate its input to its first child, if any (this just
530 makes very simple wrapper argps more convenient). */
531 group->child_inputs[0] = group->input;
532
533 err = group_parse (group, state: &parser->state, ARGP_KEY_INIT, arg: 0);
534 }
535 if (err == EBADKEY)
536 err = 0; /* Some parser didn't understand. */
537
538 if (err)
539 return err;
540
541 if (parser->state.flags & ARGP_NO_ERRS)
542 {
543 parser->opt_data.opterr = 0;
544 if (parser->state.flags & ARGP_PARSE_ARGV0)
545 /* getopt always skips ARGV[0], so we have to fake it out. As long
546 as OPTERR is 0, then it shouldn't actually try to access it. */
547 parser->state.argv--, parser->state.argc++;
548 }
549 else
550 parser->opt_data.opterr = 1; /* Print error messages. */
551
552 if (parser->state.argv == argv && argv[0])
553 /* There's an argv[0]; use it for messages. */
554 {
555 char *short_name = strrchr (argv[0], '/');
556 parser->state.name = short_name ? short_name + 1 : argv[0];
557 }
558 else
559 parser->state.name = __argp_short_program_name ();
560
561 return 0;
562}
563
564/* Free any storage consumed by PARSER (but not PARSER itself). */
565static error_t
566parser_finalize (struct parser *parser,
567 error_t err, int arg_ebadkey, int *end_index)
568{
569 struct group *group;
570
571 if (err == EBADKEY && arg_ebadkey)
572 /* Suppress errors generated by unparsed arguments. */
573 err = 0;
574
575 if (! err)
576 {
577 if (parser->state.next == parser->state.argc)
578 /* We successfully parsed all arguments! Call all the parsers again,
579 just a few more times... */
580 {
581 for (group = parser->groups;
582 group < parser->egroup && (!err || err==EBADKEY);
583 group++)
584 if (group->args_processed == 0)
585 err = group_parse (group, state: &parser->state, ARGP_KEY_NO_ARGS, arg: 0);
586 for (group = parser->egroup - 1;
587 group >= parser->groups && (!err || err==EBADKEY);
588 group--)
589 err = group_parse (group, state: &parser->state, ARGP_KEY_END, arg: 0);
590
591 if (err == EBADKEY)
592 err = 0; /* Some parser didn't understand. */
593
594 /* Tell the user that all arguments are parsed. */
595 if (end_index)
596 *end_index = parser->state.next;
597 }
598 else if (end_index)
599 /* Return any remaining arguments to the user. */
600 *end_index = parser->state.next;
601 else
602 /* No way to return the remaining arguments, they must be bogus. */
603 {
604 if (!(parser->state.flags & ARGP_NO_ERRS)
605 && parser->state.err_stream)
606 fprintf (parser->state.err_stream,
607 dgettext (parser->argp->argp_domain,
608 "%s: Too many arguments\n"),
609 parser->state.name);
610 err = EBADKEY;
611 }
612 }
613
614 /* Okay, we're all done, with either an error or success; call the parsers
615 to indicate which one. */
616
617 if (err)
618 {
619 /* Maybe print an error message. */
620 if (err == EBADKEY)
621 /* An appropriate message describing what the error was should have
622 been printed earlier. */
623 __argp_state_help (&parser->state, parser->state.err_stream,
624 ARGP_HELP_STD_ERR);
625
626 /* Since we didn't exit, give each parser an error indication. */
627 for (group = parser->groups; group < parser->egroup; group++)
628 group_parse (group, state: &parser->state, ARGP_KEY_ERROR, arg: 0);
629 }
630 else
631 /* Notify parsers of success, and propagate back values from parsers. */
632 {
633 /* We pass over the groups in reverse order so that child groups are
634 given a chance to do there processing before passing back a value to
635 the parent. */
636 for (group = parser->egroup - 1
637 ; group >= parser->groups && (!err || err == EBADKEY)
638 ; group--)
639 err = group_parse (group, state: &parser->state, ARGP_KEY_SUCCESS, arg: 0);
640 if (err == EBADKEY)
641 err = 0; /* Some parser didn't understand. */
642 }
643
644 /* Call parsers once more, to do any final cleanup. Errors are ignored. */
645 for (group = parser->egroup - 1; group >= parser->groups; group--)
646 group_parse (group, state: &parser->state, ARGP_KEY_FINI, arg: 0);
647
648 if (err == EBADKEY)
649 err = EINVAL;
650
651 free (ptr: parser->storage);
652
653 return err;
654}
655
656/* Call the user parsers to parse the non-option argument VAL, at the current
657 position, returning any error. The state NEXT pointer is assumed to have
658 been adjusted (by getopt) to point after this argument; this function will
659 adjust it correctly to reflect however many args actually end up being
660 consumed. */
661static error_t
662parser_parse_arg (struct parser *parser, char *val)
663{
664 /* Save the starting value of NEXT, first adjusting it so that the arg
665 we're parsing is again the front of the arg vector. */
666 int index = --parser->state.next;
667 error_t err = EBADKEY;
668 struct group *group;
669 int key = 0; /* Which of ARGP_KEY_ARG[S] we used. */
670
671 /* Try to parse the argument in each parser. */
672 for (group = parser->groups
673 ; group < parser->egroup && err == EBADKEY
674 ; group++)
675 {
676 parser->state.next++; /* For ARGP_KEY_ARG, consume the arg. */
677 key = ARGP_KEY_ARG;
678 err = group_parse (group, state: &parser->state, key, arg: val);
679
680 if (err == EBADKEY)
681 /* This parser doesn't like ARGP_KEY_ARG; try ARGP_KEY_ARGS instead. */
682 {
683 parser->state.next--; /* For ARGP_KEY_ARGS, put back the arg. */
684 key = ARGP_KEY_ARGS;
685 err = group_parse (group, state: &parser->state, key, arg: 0);
686 }
687 }
688
689 if (! err)
690 {
691 if (key == ARGP_KEY_ARGS)
692 /* The default for ARGP_KEY_ARGS is to assume that if NEXT isn't
693 changed by the user, *all* arguments should be considered
694 consumed. */
695 parser->state.next = parser->state.argc;
696
697 if (parser->state.next > index)
698 /* Remember that we successfully processed a non-option
699 argument -- but only if the user hasn't gotten tricky and set
700 the clock back. */
701 (--group)->args_processed += (parser->state.next - index);
702 else
703 /* The user wants to reparse some args, give getopt another try. */
704 parser->try_getopt = 1;
705 }
706
707 return err;
708}
709
710/* Call the user parsers to parse the option OPT, with argument VAL, at the
711 current position, returning any error. */
712static error_t
713parser_parse_opt (struct parser *parser, int opt, char *val)
714{
715 /* The group key encoded in the high bits; 0 for short opts or
716 group_number + 1 for long opts. */
717 int group_key = opt >> USER_BITS;
718 error_t err = EBADKEY;
719
720 if (group_key == 0)
721 /* A short option. By comparing OPT's position in SHORT_OPTS to the
722 various starting positions in each group's SHORT_END field, we can
723 determine which group OPT came from. */
724 {
725 struct group *group;
726 char *short_index = strchr (parser->short_opts, opt);
727
728 if (short_index)
729 for (group = parser->groups; group < parser->egroup; group++)
730 if (group->short_end > short_index)
731 {
732 err = group_parse (group, state: &parser->state, key: opt,
733 arg: parser->opt_data.optarg);
734 break;
735 }
736 }
737 else
738 /* A long option. We use shifts instead of masking for extracting
739 the user value in order to preserve the sign. */
740 err =
741 group_parse (group: &parser->groups[group_key - 1], state: &parser->state,
742 key: (opt << GROUP_BITS) >> GROUP_BITS,
743 arg: parser->opt_data.optarg);
744
745 if (err == EBADKEY)
746 /* At least currently, an option not recognized is an error in the
747 parser, because we pre-compute which parser is supposed to deal
748 with each option. */
749 {
750 static const char bad_key_err[] =
751 N_("(PROGRAM ERROR) Option should have been recognized!?");
752 if (group_key == 0)
753 __argp_error (&parser->state, "-%c: %s", opt,
754 dgettext (parser->argp->argp_domain, bad_key_err));
755 else
756 {
757 struct option *long_opt = parser->long_opts;
758 while (long_opt->val != opt && long_opt->name)
759 long_opt++;
760 __argp_error (&parser->state, "--%s: %s",
761 long_opt->name ? long_opt->name : "???",
762 dgettext (parser->argp->argp_domain, bad_key_err));
763 }
764 }
765
766 return err;
767}
768
769/* Parse the next argument in PARSER (as indicated by PARSER->state.next).
770 Any error from the parsers is returned, and *ARGP_EBADKEY indicates
771 whether a value of EBADKEY is due to an unrecognized argument (which is
772 generally not fatal). */
773static error_t
774parser_parse_next (struct parser *parser, int *arg_ebadkey)
775{
776 int opt;
777 error_t err = 0;
778
779 if (parser->state.quoted && parser->state.next < parser->state.quoted)
780 /* The next argument pointer has been moved to before the quoted
781 region, so pretend we never saw the quoting `--', and give getopt
782 another chance. If the user hasn't removed it, getopt will just
783 process it again. */
784 parser->state.quoted = 0;
785
786 if (parser->try_getopt && !parser->state.quoted)
787 /* Give getopt a chance to parse this. */
788 {
789 /* Put it back in OPTIND for getopt. */
790 parser->opt_data.optind = parser->state.next;
791 /* Distinguish KEY_ERR from a real option. */
792 parser->opt_data.optopt = KEY_END;
793 if (parser->state.flags & ARGP_LONG_ONLY)
794 opt = _getopt_long_only_r (argc: parser->state.argc, argv: parser->state.argv,
795 shortopts: parser->short_opts, longopts: parser->long_opts, longind: 0,
796 data: &parser->opt_data);
797 else
798 opt = _getopt_long_r (argc: parser->state.argc, argv: parser->state.argv,
799 shortopts: parser->short_opts, longopts: parser->long_opts, longind: 0,
800 data: &parser->opt_data);
801 /* And see what getopt did. */
802 parser->state.next = parser->opt_data.optind;
803
804 if (opt == KEY_END)
805 /* Getopt says there are no more options, so stop using
806 getopt; we'll continue if necessary on our own. */
807 {
808 parser->try_getopt = 0;
809 if (parser->state.next > 1
810 && strcmp (parser->state.argv[parser->state.next - 1], QUOTE)
811 == 0)
812 /* Not only is this the end of the options, but it's a
813 `quoted' region, which may have args that *look* like
814 options, so we definitely shouldn't try to use getopt past
815 here, whatever happens. */
816 parser->state.quoted = parser->state.next;
817 }
818 else if (opt == KEY_ERR && parser->opt_data.optopt != KEY_END)
819 /* KEY_ERR can have the same value as a valid user short
820 option, but in the case of a real error, getopt sets OPTOPT
821 to the offending character, which can never be KEY_END. */
822 {
823 *arg_ebadkey = 0;
824 return EBADKEY;
825 }
826 }
827 else
828 opt = KEY_END;
829
830 if (opt == KEY_END)
831 {
832 /* We're past what getopt considers the options. */
833 if (parser->state.next >= parser->state.argc
834 || (parser->state.flags & ARGP_NO_ARGS))
835 /* Indicate that we're done. */
836 {
837 *arg_ebadkey = 1;
838 return EBADKEY;
839 }
840 else
841 /* A non-option arg; simulate what getopt might have done. */
842 {
843 opt = KEY_ARG;
844 parser->opt_data.optarg = parser->state.argv[parser->state.next++];
845 }
846 }
847
848 if (opt == KEY_ARG)
849 /* A non-option argument; try each parser in turn. */
850 err = parser_parse_arg (parser, val: parser->opt_data.optarg);
851 else
852 err = parser_parse_opt (parser, opt, val: parser->opt_data.optarg);
853
854 if (err == EBADKEY)
855 *arg_ebadkey = (opt == KEY_END || opt == KEY_ARG);
856
857 return err;
858}
859
860/* Parse the options strings in ARGC & ARGV according to the argp in ARGP.
861 FLAGS is one of the ARGP_ flags above. If END_INDEX is non-NULL, the
862 index in ARGV of the first unparsed option is returned in it. If an
863 unknown option is present, EINVAL is returned; if some parser routine
864 returned a non-zero value, it is returned; otherwise 0 is returned. */
865error_t
866__argp_parse (const struct argp *argp, int argc, char **argv, unsigned flags,
867 int *end_index, void *input)
868{
869 error_t err;
870 struct parser parser;
871
872 struct argp_child child[4];
873 struct argp top_argp;
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 if (! (flags & ARGP_NO_HELP))
880 /* Add our own options. */
881 {
882 int child_index = 0;
883
884 /* TOP_ARGP has no options, it just serves to group the user & default
885 argps. */
886 memset (&top_argp, 0, sizeof (struct argp));
887 top_argp.children = child;
888
889 memset (child, 0, 4 * sizeof (struct argp_child));
890
891 if (argp)
892 child[child_index++].argp = argp;
893 child[child_index++].argp = &argp_default_argp;
894 if (argp_program_version || argp_program_version_hook)
895 child[child_index++].argp = &argp_version_argp;
896 child[child_index].argp = 0;
897
898 argp = &top_argp;
899 }
900
901 /* Construct a parser for these arguments. */
902 err = parser_init (parser: &parser, argp, argc, argv, flags, input);
903
904 if (! err)
905 /* Parse! */
906 {
907 while (! err)
908 err = parser_parse_next (parser: &parser, arg_ebadkey: &arg_ebadkey);
909 err = parser_finalize (parser: &parser, err, arg_ebadkey, end_index);
910 }
911
912 return err;
913}
914#ifdef weak_alias
915weak_alias (__argp_parse, argp_parse)
916#endif
917
918/* Return the input field for ARGP in the parser corresponding to STATE; used
919 by the help routines. */
920void *
921__argp_input (const struct argp *argp, const struct argp_state *state)
922{
923 if (state)
924 {
925 struct group *group;
926 struct parser *parser = state->pstate;
927
928 for (group = parser->groups; group < parser->egroup; group++)
929 if (group->argp == argp)
930 return group->input;
931 }
932
933 return 0;
934}
935#ifdef weak_alias
936weak_alias (__argp_input, _argp_input)
937#endif
938

source code of glibc/argp/argp-parse.c