|
421
|
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>.
|
|
|
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
|
