argp-parse.c 33.8 KB
Newer Older
Niels Möller's avatar
Niels Möller committed
1
/* Hierarchial argument parsing, layered over getopt
Niels Möller's avatar
Niels Möller committed
2
   Copyright (C) 1995, 96, 97, 98, 99, 2000 Free Software Foundation, Inc.
Niels Möller's avatar
Niels Möller committed
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
   This file is part of the GNU C Library.
   Written by Miles Bader <miles@gnu.ai.mit.edu>.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with the GNU C Library; see the file COPYING.LIB.  If not,
   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

21
22
23
24
#ifndef _GNU_SOURCE
# define _GNU_SOURCE	1
#endif

Niels Möller's avatar
Niels Möller committed
25
26
27
28
29
30
31
32
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <limits.h>
33
#include <assert.h>
Niels Möller's avatar
Niels Möller committed
34

Niels Möller's avatar
Niels Möller committed
35
36
37
38
39
40
41
42
#ifndef UNUSED
# if __GNUC__ >= 2
#  define UNUSED __attribute__ ((__unused__))
# else
#  define UNUSED
# endif
#endif

Niels Möller's avatar
Niels Möller committed
43
44
45
#ifndef _
/* This is for other GNU distributions with internationalized messages.
   When compiling libc, the _ macro is predefined.  */
Niels Möller's avatar
Niels Möller committed
46
47
48
49
50
51
52
53
54
55
# if defined HAVE_LIBINTL_H || defined _LIBC
#  include <libintl.h>
#  ifdef _LIBC
#   undef dgettext
#   define dgettext(domain, msgid) __dcgettext (domain, msgid, LC_MESSAGES)
#  endif
# else
#  define dgettext(domain, msgid) (msgid)
#  define gettext(msgid) (msgid)
# endif
Niels Möller's avatar
Niels Möller committed
56
#endif
Niels Möller's avatar
Niels Möller committed
57
58
#ifndef N_
# define N_(msgid) (msgid)
Niels Möller's avatar
Niels Möller committed
59
60
#endif

Niels Möller's avatar
Niels Möller committed
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
#if _LIBC - 0
#include <bits/libc-lock.h>
#else
#ifdef HAVE_CTHREADS_H
#include <cthreads.h>
#endif
#endif /* _LIBC */

#include "argp.h"
#include "argp-namefrob.h"


/* The meta-argument used to prevent any further arguments being interpreted
   as options.  */
#define QUOTE "--"

/* EZ alias for ARGP_ERR_UNKNOWN.  */
#define EBADKEY ARGP_ERR_UNKNOWN
79

Niels Möller's avatar
Niels Möller committed
80
81
82
83
84
85
86

/* Default options.  */

/* When argp is given the --HANG switch, _ARGP_HANG is set and argp will sleep
   for one second intervals, decrementing _ARGP_HANG until it's zero.  Thus
   you can force the program to continue by attaching a debugger and setting
   it to 0 yourself.  */
Niels Möller's avatar
Niels Möller committed
87
volatile int _argp_hang;
Niels Möller's avatar
Niels Möller committed
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

#define OPT_PROGNAME	-2
#define OPT_USAGE	-3
#define OPT_HANG	-4

static const struct argp_option argp_default_options[] =
{
  {"help",	  '?',    	0, 0,  N_("Give this help list"), -1},
  {"usage",	  OPT_USAGE,	0, 0,  N_("Give a short usage message")},
  {"program-name",OPT_PROGNAME,"NAME", OPTION_HIDDEN, N_("Set the program name")},
  {"HANG",	  OPT_HANG,    "SECS", OPTION_ARG_OPTIONAL | OPTION_HIDDEN,
     N_("Hang for SECS seconds (default 3600)")},
  {0, 0}
};

static error_t
argp_default_parser (int key, char *arg, struct argp_state *state)
{
  switch (key)
    {
    case '?':
      __argp_state_help (state, state->out_stream, ARGP_HELP_STD_HELP);
      break;
    case OPT_USAGE:
      __argp_state_help (state, state->out_stream,
		       ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
      break;

    case OPT_PROGNAME:		/* Set the program name.  */
Niels Möller's avatar
Niels Möller committed
117
#if HAVE_PROGRAM_INVOCATION_NAME
Niels Möller's avatar
Niels Möller committed
118
      program_invocation_name = arg;
Niels Möller's avatar
Niels Möller committed
119
#endif
Niels Möller's avatar
Niels Möller committed
120
121
122
123
124
      /* [Note that some systems only have PROGRAM_INVOCATION_SHORT_NAME (aka
	 __PROGNAME), in which case, PROGRAM_INVOCATION_NAME is just defined
	 to be that, so we have to be a bit careful here.]  */

      /* Update what we use for messages.  */
Niels Möller's avatar
Niels Möller committed
125

126
      state->name = __argp_basename(arg);
Niels Möller's avatar
Niels Möller committed
127
128
129
130
      
#if HAVE_PROGRAM_INVOCATION_SHORT_NAME
      program_invocation_short_name = state->name;
#endif
Niels Möller's avatar
Niels Möller committed
131
132
133
134

      if ((state->flags & (ARGP_PARSE_ARGV0 | ARGP_NO_ERRS))
	  == ARGP_PARSE_ARGV0)
	/* Update what getopt uses too.  */
Niels Möller's avatar
Niels Möller committed
135
	state->argv[0] = arg;
Niels Möller's avatar
Niels Möller committed
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

      break;

    case OPT_HANG:
      _argp_hang = atoi (arg ? arg : "3600");
      while (_argp_hang-- > 0)
	__sleep (1);
      break;

    default:
      return EBADKEY;
    }
  return 0;
}

static const struct argp argp_default_argp =
Niels Möller's avatar
Niels Möller committed
152
  {argp_default_options, &argp_default_parser, NULL, NULL, NULL, NULL, "libc"};
Niels Möller's avatar
Niels Möller committed
153
154
155
156
157
158
159
160
161


static const struct argp_option argp_version_options[] =
{
  {"version",	  'V',    	0, 0,  N_("Print program version"), -1},
  {0, 0}
};

static error_t
Niels Möller's avatar
Niels Möller committed
162
argp_version_parser (int key, char *arg UNUSED, struct argp_state *state)
Niels Möller's avatar
Niels Möller committed
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
{
  switch (key)
    {
    case 'V':
      if (argp_program_version_hook)
	(*argp_program_version_hook) (state->out_stream, state);
      else if (argp_program_version)
	fprintf (state->out_stream, "%s\n", argp_program_version);
      else
	__argp_error (state, dgettext (state->root_argp->argp_domain,
				       "(PROGRAM ERROR) No version known!?"));
      if (! (state->flags & ARGP_NO_EXIT))
	exit (0);
      break;
    default:
      return EBADKEY;
    }
  return 0;
}

static const struct argp argp_version_argp =
Niels Möller's avatar
Niels Möller committed
184
  {argp_version_options, &argp_version_parser, NULL, NULL, NULL, NULL, "libc"};
Niels Möller's avatar
Niels Möller committed
185
186
187
188
189
190
191
192
193
194
195
196
197
198



/* The state of a `group' during parsing.  Each group corresponds to a
   particular argp structure from the tree of such descending from the top
   level argp passed to argp_parse.  */
struct group
{
  /* This group's parsing function.  */
  argp_parser_t parser;

  /* Which argp this group is from.  */
  const struct argp *argp;

199
#if 0
Niels Möller's avatar
Niels Möller committed
200
201
202
203
  /* Points to the point in SHORT_OPTS corresponding to the end of the short
     options for this group.  We use it to determine from which group a
     particular short options is from.  */
  char *short_end;
204
#endif
Niels Möller's avatar
Niels Möller committed
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
  /* The number of non-option args sucessfully handled by this parser.  */
  unsigned args_processed;

  /* This group's parser's parent's group.  */
  struct group *parent;
  unsigned parent_index;	/* And the our position in the parent.   */

  /* These fields are swapped into and out of the state structure when
     calling this group's parser.  */
  void *input, **child_inputs;
  void *hook;
};

/* Call GROUP's parser with KEY and ARG, swapping any group-specific info
   from STATE before calling, and back into state afterwards.  If GROUP has
   no parser, EBADKEY is returned.  */
static error_t
group_parse (struct group *group, struct argp_state *state, int key, char *arg)
{
  if (group->parser)
    {
      error_t err;
      state->hook = group->hook;
      state->input = group->input;
      state->child_inputs = group->child_inputs;
      state->arg_num = group->args_processed;
      err = (*group->parser)(key, arg, state);
      group->hook = state->hook;
      return err;
    }
  else
    return EBADKEY;
}

struct parser
{
  const struct argp *argp;

243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
  const char *posixly_correct;

  /* Describe how to deal with options that follow non-option ARGV-elements.

     If the caller did not specify anything, the default is
     REQUIRE_ORDER if the environment variable POSIXLY_CORRECT is
     defined, PERMUTE otherwise.

     REQUIRE_ORDER means don't recognize them as options; stop option
     processing when the first non-option is seen. This is what Unix
     does. This mode of operation is selected by either setting the
     environment variable POSIXLY_CORRECT, or using `+' as the first
     character of the list of option characters.

     PERMUTE is the default. We permute the contents of ARGV as we
     scan, so that eventually all the non-options are at the end. This
     allows options to be given in any order, even with programs that
     were not written to expect this.

     RETURN_IN_ORDER is an option available to programs that were
     written to expect options and other ARGV-elements in any order
     and that care about the ordering of the two. We describe each
     non-option ARGV-element as if it were the argument of an option
     with character code 1. Using `-' as the first character of the
     list of option characters selects this mode of operation.

  */
  enum { REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER } ordering;
  
272
  /* String of all recognized short options. Needed for ARGP_LONG_ONLY. */
Niels Möller's avatar
Niels Möller committed
273
274
  char *short_opts;

275
276
277
  /* For parsing combined short options. */
  char *nextchar;
  
Niels Möller's avatar
Niels Möller committed
278
279
280
281
282
283
  /* States of the various parsing groups.  */
  struct group *groups;
  /* The end of the GROUPS array.  */
  struct group *egroup;
  /* An vector containing storage for the CHILD_INPUTS field in all groups.  */
  void **child_inputs;
284
  
Niels Möller's avatar
Niels Möller committed
285
286
287
288
289
290
  /* State block supplied to parsing routines.  */
  struct argp_state state;

  /* Memory used by this parser.  */
  void *storage;
};
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336

/* Search for a group defining a short option. */
static const struct argp_option *
find_short_option(struct parser *parser, int key, struct group **p)
{
  struct group *group;
  
  assert(key >= 0);
  assert(isascii(key));

  for (group = parser->groups; group < parser->egroup; group++)
    {
      const struct argp_option *opts;

      for (opts = group->argp->options; !__option_is_end(opts); opts++)
	if (opts->key == key)
	  {
	    *p = group;
	    return opts;
	  }
    }
  return NULL;
}

enum match_result { MATCH_EXACT, MATCH_PARTIAL, MATCH_NO };

/* Matches an encountern long-option argument ARG against an option NAME.
 * ARG is terminated by NUL or '='.
 *
 * For partial matches, *QUALITY is set to the length of the common
 * prefix. */
static enum match_result
match_option(const char *arg, const char *name,
	     unsigned *quality)
{
  unsigned i;
  for (i = 0;; i++)
    {
      if ( !arg[i] || (arg[i] == '='))
	{
	  if (!name[i])
	    return MATCH_EXACT;
	}
      else if (!name[i])
	/* The argument is longer than the option name */
	return MATCH_NO;
337
      else if (arg[i] != name[i])
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
	{
	  *quality = i;
	  return MATCH_PARTIAL;
	}
    }
}

static const struct argp_option *
find_long_option(struct parser *parser,
		 const char *arg,
		 struct group **p)
{
  struct group *group;

  /* Best match found so far. */
  unsigned best_match = 0;    /* Match length */
  struct group *best_group = NULL;
  const struct argp_option *best_option = NULL;

  /* True if we get several "best" matches. (A best_match of zero is
     always ambigous). */
  int ambiguous = 1;

  for (group = parser->groups; group < parser->egroup; group++)
    {
      const struct argp_option *opts;

      for (opts = group->argp->options; !__option_is_end(opts); opts++)
	{
	  unsigned prefix;
	  
	  if (!opts->name)
	    continue;
	  switch (match_option(arg, opts->name, &prefix))
	    {
	    case MATCH_NO:
	      break;
	    case MATCH_PARTIAL:
	      if (prefix > best_match)
		{
		  ambiguous = 0;
		  best_match = prefix;
		  best_group = group;
		  best_option = opts;
		}
	      else if (prefix == best_match)
		ambiguous = 1;

	      break;
	    case MATCH_EXACT:
	      /* Exact match. */
	      *p = group;
	      return opts;
	    }
	}
    }
  if (!ambiguous)
    {
      *p = best_group;
      return best_option;
    }

  return NULL;
}

Niels Möller's avatar
Niels Möller committed
403
404
405
406
407
408
409
410
411
412

/* The next usable entries in the various parser tables being filled in by
   convert_options.  */
struct parser_convert_state
{
  struct parser *parser;
  char *short_end;
  void **child_inputs_end;
};

413
414
415
/* Initialize GROUP from ARGP. If CVT->SHORT_END is non-NULL, short
   options are recorded in the short options string. Returns the next
   unused group entry. CVT holds state used during the conversion. */
Niels Möller's avatar
Niels Möller committed
416
417
418
419
420
static struct group *
convert_options (const struct argp *argp,
		 struct group *parent, unsigned parent_index,
		 struct group *group, struct parser_convert_state *cvt)
{
421
  const struct argp_option *opt = argp->options;
Niels Möller's avatar
Niels Möller committed
422
423
  const struct argp_child *children = argp->children;

424
  if (opt || argp->parser)
Niels Möller's avatar
Niels Möller committed
425
    {
426
      /* This parser needs a group. */
427
428
429
430
431
432
433
434
      if (cvt->short_end)
	{
	  /* Record any short options. */
	  for ( ; !__option_is_end (opt); opt++)
	    if (__option_is_short(opt))
	      *cvt->short_end++ = opt->key;
	}
      
Niels Möller's avatar
Niels Möller committed
435
436
437
438
439
440
441
442
      group->parser = argp->parser;
      group->argp = argp;
      group->args_processed = 0;
      group->parent = parent;
      group->parent_index = parent_index;
      group->input = 0;
      group->hook = 0;
      group->child_inputs = 0;
443
      
Niels Möller's avatar
Niels Möller committed
444
445
      if (children)
	/* Assign GROUP's CHILD_INPUTS field some space from
446
	   CVT->child_inputs_end.*/
Niels Möller's avatar
Niels Möller committed
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
	{
	  unsigned num_children = 0;
	  while (children[num_children].argp)
	    num_children++;
	  group->child_inputs = cvt->child_inputs_end;
	  cvt->child_inputs_end += num_children;
	}
      parent = group++;
    }
  else
    parent = 0;

  if (children)
    {
      unsigned index = 0;
      while (children->argp)
	group =
	  convert_options (children++->argp, parent, index++, group, cvt);
    }

  return group;
}
469
470
471
/* Allocate and initialize the group structures, so that they are
   ordered as if by traversing the corresponding argp parser tree in
   pre-order. Also build the list of short options, if that is needed. */
Niels Möller's avatar
Niels Möller committed
472
static void
473
parser_convert (struct parser *parser, const struct argp *argp)
Niels Möller's avatar
Niels Möller committed
474
475
476
477
478
479
480
481
482
483
484
485
486
{
  struct parser_convert_state cvt;

  cvt.parser = parser;
  cvt.short_end = parser->short_opts;
  cvt.child_inputs_end = parser->child_inputs;

  parser->argp = argp;

  if (argp)
    parser->egroup = convert_options (argp, 0, 0, parser->groups, &cvt);
  else
    parser->egroup = parser->groups; /* No parsers at all! */
487
488
489

  if (parser->short_opts)
    *cvt.short_end ='\0';
Niels Möller's avatar
Niels Möller committed
490
491
492
493
494
}

/* Lengths of various parser fields which we will allocated.  */
struct parser_sizes
{
495
496
497
  /* Needed only ARGP_LONG_ONLY */
  size_t short_len;		/* Number of short options.  */

Niels Möller's avatar
Niels Möller committed
498
499
500
501
  size_t num_groups;		/* Group structures we allocate.  */
  size_t num_child_inputs;	/* Child input slots.  */
};

502
503
504
/* For ARGP, increments the NUM_GROUPS field in SZS by the total
   number of argp structures descended from it, and the SHORT_LEN by
   the total number of short options. */
Niels Möller's avatar
Niels Möller committed
505
506
507
508
509
510
511
512
static void
calc_sizes (const struct argp *argp,  struct parser_sizes *szs)
{
  const struct argp_child *child = argp->children;
  const struct argp_option *opt = argp->options;

  if (opt || argp->parser)
    {
513
      /* This parser needs a group. */
Niels Möller's avatar
Niels Möller committed
514
515
516
      szs->num_groups++;
      if (opt)
	{
517
518
	  while (__option_is_short (opt++))
	    szs->short_len++;
Niels Möller's avatar
Niels Möller committed
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
	}
    }

  if (child)
    while (child->argp)
      {
	calc_sizes ((child++)->argp, szs);
	szs->num_child_inputs++;
      }
}

/* Initializes PARSER to parse ARGP in a manner described by FLAGS.  */
static error_t
parser_init (struct parser *parser, const struct argp *argp,
	     int argc, char **argv, int flags, void *input)
{
  error_t err = 0;
  struct group *group;
  struct parser_sizes szs;

539
540
541
542
543
544
545
546
547
548
549
  parser->posixly_correct = getenv ("POSIXLY_CORRECT");

  if (flags & ARGP_IN_ORDER)
    parser->ordering = RETURN_IN_ORDER;
  else if (flags & ARGP_NO_ARGS)
    parser->ordering = REQUIRE_ORDER;
  else if (parser->posixly_correct)
    parser->ordering = REQUIRE_ORDER;
  else
    parser->ordering = PERMUTE;
  
550
  szs.short_len = 0;
Niels Möller's avatar
Niels Möller committed
551
552
553
554
555
556
  szs.num_groups = 0;
  szs.num_child_inputs = 0;

  if (argp)
    calc_sizes (argp, &szs);

557
558
559
560
  if (!(flags & ARGP_LONG_ONLY))
    /* We have no use for the short option array. */
    szs.short_len = 0;
  
Niels Möller's avatar
Niels Möller committed
561
562
563
564
  /* Lengths of the various bits of storage used by PARSER.  */
#define GLEN (szs.num_groups + 1) * sizeof (struct group)
#define CLEN (szs.num_child_inputs * sizeof (void *))
#define SLEN (szs.short_len + 1)
565
#define STORAGE(offset) ((void *) (((char *) parser->storage) + (offset)))
Niels Möller's avatar
Niels Möller committed
566

567
  parser->storage = malloc (GLEN + CLEN + SLEN);
Niels Möller's avatar
Niels Möller committed
568
569
570
571
572
  if (! parser->storage)
    return ENOMEM;

  parser->groups = parser->storage;

573
  parser->child_inputs = STORAGE(GLEN);
Niels Möller's avatar
Niels Möller committed
574
  memset (parser->child_inputs, 0, szs.num_child_inputs * sizeof (void *));
575
576
577
578
579
580
581

  if (flags & ARGP_LONG_ONLY)
    parser->short_opts = STORAGE(GLEN + CLEN);
  else
    parser->short_opts = NULL;

  parser_convert (parser, argp);
Niels Möller's avatar
Niels Möller committed
582
583

  memset (&parser->state, 0, sizeof (struct argp_state));
584
  
Niels Möller's avatar
Niels Möller committed
585
586
587
588
589
590
591
592
593
  parser->state.root_argp = parser->argp;
  parser->state.argc = argc;
  parser->state.argv = argv;
  parser->state.flags = flags;
  parser->state.err_stream = stderr;
  parser->state.out_stream = stdout;
  parser->state.next = 0;	/* Tell getopt to initialize.  */
  parser->state.pstate = parser;

594
  parser->nextchar = NULL;
Niels Möller's avatar
Niels Möller committed
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622

  /* Call each parser for the first time, giving it a chance to propagate
     values to child parsers.  */
  if (parser->groups < parser->egroup)
    parser->groups->input = input;
  for (group = parser->groups;
       group < parser->egroup && (!err || err == EBADKEY);
       group++)
    {
      if (group->parent)
	/* If a child parser, get the initial input value from the parent. */
	group->input = group->parent->child_inputs[group->parent_index];

      if (!group->parser
	  && group->argp->children && group->argp->children->argp)
	/* For the special case where no parsing function is supplied for an
	   argp, propagate its input to its first child, if any (this just
	   makes very simple wrapper argps more convenient).  */
	group->child_inputs[0] = group->input;

      err = group_parse (group, &parser->state, ARGP_KEY_INIT, 0);
    }
  if (err == EBADKEY)
    err = 0;			/* Some parser didn't understand.  */

  if (err)
    return err;

623
  if (argv[0] && !(parser->state.flags & ARGP_PARSE_ARGV0))
Niels Möller's avatar
Niels Möller committed
624
625
    /* There's an argv[0]; use it for messages.  */
    {
626
      parser->state.name = __argp_basename(argv[0]);
627
628
629

      /* Don't parse it as an argument. */
      parser->state.next = 1;
Niels Möller's avatar
Niels Möller committed
630
631
    }
  else
Niels Möller's avatar
Niels Möller committed
632
633
  {
#if HAVE_PROGRAM_INVOCATION_SHORT_NAME
Niels Möller's avatar
Niels Möller committed
634
    parser->state.name = program_invocation_short_name;
Niels Möller's avatar
Niels Möller committed
635
#elif HAVE_PROGRAM_INVOCATION_NAME
636
    parser->state.name = __argp_basename(program_invocation_name);
Niels Möller's avatar
Niels Möller committed
637
#else
638
639
640
    /* FIXME: What now? Miles suggests that it is better to use NULL,
       but currently the value is passed on directly to
       fputs_unlocked(), so that requires more changes. */
Niels Möller's avatar
Niels Möller committed
641
642
643
    parser->state.name = "";
#endif
  }
Niels Möller's avatar
Niels Möller committed
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
  return 0;
}

/* Free any storage consumed by PARSER (but not PARSER itself).  */
static error_t
parser_finalize (struct parser *parser,
		 error_t err, int arg_ebadkey, int *end_index)
{
  struct group *group;

  if (err == EBADKEY && arg_ebadkey)
    /* Suppress errors generated by unparsed arguments.  */
    err = 0;

  if (! err)
    {
      if (parser->state.next == parser->state.argc)
	/* We successfully parsed all arguments!  Call all the parsers again,
	   just a few more times... */
	{
	  for (group = parser->groups;
	       group < parser->egroup && (!err || err==EBADKEY);
	       group++)
	    if (group->args_processed == 0)
	      err = group_parse (group, &parser->state, ARGP_KEY_NO_ARGS, 0);
Niels Möller's avatar
Niels Möller committed
669
670
671
	  for (group = parser->egroup - 1;
	       group >= parser->groups && (!err || err==EBADKEY);
	       group--)
Niels Möller's avatar
Niels Möller committed
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
	    err = group_parse (group, &parser->state, ARGP_KEY_END, 0);

	  if (err == EBADKEY)
	    err = 0;		/* Some parser didn't understand.  */

	  /* Tell the user that all arguments are parsed.  */
	  if (end_index)
	    *end_index = parser->state.next;
	}
      else if (end_index)
	/* Return any remaining arguments to the user.  */
	*end_index = parser->state.next;
      else
	/* No way to return the remaining arguments, they must be bogus. */
	{
	  if (!(parser->state.flags & ARGP_NO_ERRS)
	      && parser->state.err_stream)
	    fprintf (parser->state.err_stream,
		     dgettext (parser->argp->argp_domain,
			       "%s: Too many arguments\n"),
		     parser->state.name);
	  err = EBADKEY;
	}
    }

  /* Okay, we're all done, with either an error or success; call the parsers
     to indicate which one.  */

  if (err)
    {
      /* Maybe print an error message.  */
      if (err == EBADKEY)
	/* An appropriate message describing what the error was should have
	   been printed earlier.  */
	__argp_state_help (&parser->state, parser->state.err_stream,
			   ARGP_HELP_STD_ERR);

      /* Since we didn't exit, give each parser an error indication.  */
      for (group = parser->groups; group < parser->egroup; group++)
	group_parse (group, &parser->state, ARGP_KEY_ERROR, 0);
    }
  else
    /* Notify parsers of success, and propagate back values from parsers.  */
    {
      /* We pass over the groups in reverse order so that child groups are
	 given a chance to do there processing before passing back a value to
	 the parent.  */
      for (group = parser->egroup - 1
	   ; group >= parser->groups && (!err || err == EBADKEY)
	   ; group--)
	err = group_parse (group, &parser->state, ARGP_KEY_SUCCESS, 0);
      if (err == EBADKEY)
	err = 0;		/* Some parser didn't understand.  */
    }

  /* Call parsers once more, to do any final cleanup.  Errors are ignored.  */
  for (group = parser->egroup - 1; group >= parser->groups; group--)
    group_parse (group, &parser->state, ARGP_KEY_FINI, 0);

  if (err == EBADKEY)
    err = EINVAL;

  free (parser->storage);

  return err;
}

/* Call the user parsers to parse the non-option argument VAL, at the current
   position, returning any error.  The state NEXT pointer is assumed to have
   been adjusted (by getopt) to point after this argument; this function will
   adjust it correctly to reflect however many args actually end up being
   consumed.  */
static error_t
parser_parse_arg (struct parser *parser, char *val)
{
  /* Save the starting value of NEXT, first adjusting it so that the arg
     we're parsing is again the front of the arg vector.  */
  int index = --parser->state.next;
  error_t err = EBADKEY;
  struct group *group;
  int key = 0;			/* Which of ARGP_KEY_ARG[S] we used.  */

  /* Try to parse the argument in each parser.  */
  for (group = parser->groups
       ; group < parser->egroup && err == EBADKEY
       ; group++)
    {
      parser->state.next++;	/* For ARGP_KEY_ARG, consume the arg.  */
      key = ARGP_KEY_ARG;
      err = group_parse (group, &parser->state, key, val);

      if (err == EBADKEY)
	/* This parser doesn't like ARGP_KEY_ARG; try ARGP_KEY_ARGS instead. */
	{
	  parser->state.next--;	/* For ARGP_KEY_ARGS, put back the arg.  */
	  key = ARGP_KEY_ARGS;
	  err = group_parse (group, &parser->state, key, 0);
	}
    }

  if (! err)
    {
      if (key == ARGP_KEY_ARGS)
	/* The default for ARGP_KEY_ARGS is to assume that if NEXT isn't
	   changed by the user, *all* arguments should be considered
	   consumed.  */
	parser->state.next = parser->state.argc;

      if (parser->state.next > index)
	/* Remember that we successfully processed a non-option
	   argument -- but only if the user hasn't gotten tricky and set
	   the clock back.  */
	(--group)->args_processed += (parser->state.next - index);
785
#if 0
Niels Möller's avatar
Niels Möller committed
786
787
788
      else
	/* The user wants to reparse some args, give getopt another try.  */
	parser->try_getopt = 1;
789
#endif
Niels Möller's avatar
Niels Möller committed
790
791
792
793
794
    }

  return err;
}

795
#if 0
Niels Möller's avatar
Niels Möller committed
796
797
798
/* Call the user parsers to parse the option OPT, with argument VAL, at the
   current position, returning any error.  */
static error_t
Niels Möller's avatar
Niels Möller committed
799
parser_parse_opt (struct parser *parser, int opt, char *val UNUSED)
Niels Möller's avatar
Niels Möller committed
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
{
  /* The group key encoded in the high bits; 0 for short opts or
     group_number + 1 for long opts.  */
  int group_key = opt >> USER_BITS;
  error_t err = EBADKEY;

  if (group_key == 0)
    /* A short option.  By comparing OPT's position in SHORT_OPTS to the
       various starting positions in each group's SHORT_END field, we can
       determine which group OPT came from.  */
    {
      struct group *group;
      char *short_index = strchr (parser->short_opts, opt);

      if (short_index)
	for (group = parser->groups; group < parser->egroup; group++)
	  if (group->short_end > short_index)
	    {
	      err = group_parse (group, &parser->state, opt, optarg);
	      break;
	    }
    }
  else
    /* A long option.  We use shifts instead of masking for extracting
       the user value in order to preserve the sign.  */
    err =
      group_parse (&parser->groups[group_key - 1], &parser->state,
		   (opt << GROUP_BITS) >> GROUP_BITS, optarg);

  if (err == EBADKEY)
    /* At least currently, an option not recognized is an error in the
       parser, because we pre-compute which parser is supposed to deal
       with each option.  */
    {
      static const char bad_key_err[] =
	N_("(PROGRAM ERROR) Option should have been recognized!?");
      if (group_key == 0)
	__argp_error (&parser->state, "-%c: %s", opt,
		      dgettext (parser->argp->argp_domain, bad_key_err));
      else
	{
	  struct option *long_opt = parser->long_opts;
	  while (long_opt->val != opt && long_opt->name)
	    long_opt++;
	  __argp_error (&parser->state, "--%s: %s",
			long_opt->name ? long_opt->name : "???",
			dgettext (parser->argp->argp_domain, bad_key_err));
	}
    }

  return err;
}
852
#endif
Niels Möller's avatar
Niels Möller committed
853

854
855
856
enum arg_type { ARG_ARG, ARG_SHORT_OPTION,
		ARG_LONG_OPTION, ARG_LONG_ONLY_OPTION,
		ARG_QUOTE };
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900

static enum arg_type
classify_arg(struct parser *parser, char *arg, char **opt)
{
  if (arg[0] == '-')
    /* Looks like an option... */
    switch (arg[1])
      {
      case '\0':
	/* "-" is not an option. */
	return ARG_ARG;
      case '-':
	/* Long option, or quote. */
	if (!arg[2])
	  return ARG_QUOTE;
	  
	/* A long option. */
	*opt = arg + 2;
	return ARG_LONG_OPTION;

      default:
	/* Short option. But if ARGP_LONG_ONLY, it can also be a long option. */

	*opt = arg + 1;
	if (parser->state.flags & ARGP_LONG_ONLY)
	  {
	    /* Rules from getopt.c:

	       If long_only and the ARGV-element has the form "-f",
	       where f is a valid short option, don't consider it an
	       abbreviated form of a long option that starts with f.
	       Otherwise there would be no way to give the -f short
	       option.

	       On the other hand, if there's a long option "fubar" and
	       the ARGV-element is "-fu", do consider that an
	       abbreviation of the long option, just like "--fu", and
	       not "-f" with arg "u".

	       This distinction seems to be the most useful approach. */

	    assert(parser->short_opts);
	    
	    if (arg[2] || !strchr(parser->short_opts, arg[1]))
901
	      return ARG_LONG_ONLY_OPTION;
902
903
904
905
906
907
908
909
910
	  }

	return ARG_SHORT_OPTION;
      }
  
  else
    return ARG_ARG;
}

Niels Möller's avatar
Niels Möller committed
911
912
913
914
915
916
917
918
919
920
921
922
923
924
/* Parse the next argument in PARSER (as indicated by PARSER->state.next).
   Any error from the parsers is returned, and *ARGP_EBADKEY indicates
   whether a value of EBADKEY is due to an unrecognized argument (which is
   generally not fatal).  */
static error_t
parser_parse_next (struct parser *parser, int *arg_ebadkey)
{
  if (parser->state.quoted && parser->state.next < parser->state.quoted)
    /* The next argument pointer has been moved to before the quoted
       region, so pretend we never saw the quoting `--', and give getopt
       another chance.  If the user hasn't removed it, getopt will just
       process it again.  */
    parser->state.quoted = 0;

925
926
  if (parser->nextchar)
    /* Deal with short options. */
Niels Möller's avatar
Niels Möller committed
927
    {
928
      struct group *group;
929
      char c;
930
931
      const struct argp_option *option;
      char *value = NULL;;
Niels Möller's avatar
Niels Möller committed
932

933
      assert(!parser->state.quoted);
934
935
936
937

      c = *parser->nextchar++;
      
      option = find_short_option(parser, c, &group);
938
      if (!option)
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
	{
	  if (parser->posixly_correct)
	    /* 1003.2 specifies the format of this message.  */
	    fprintf (parser->state.err_stream,
		     dgettext(parser->state.root_argp->argp_domain,
			      "%s: illegal option -- %c\n"),
		     parser->state.name, c);
	  else
	    fprintf (parser->state.err_stream,
		     dgettext(parser->state.root_argp->argp_domain,
			      "%s: invalid option -- %c\n"),
		     parser->state.name, c);

	  *arg_ebadkey = 0;
	  return EBADKEY;
	}
955
956
957
958
959

      if (!*parser->nextchar)
	parser->nextchar = NULL;

      if (option->arg)
Niels Möller's avatar
Niels Möller committed
960
	{
961
962
963
964
965
966
967
968
969
	  value = parser->nextchar;
	  parser->nextchar = NULL;
	      
	  if (!value
	      && !(option->flags & OPTION_ARG_OPTIONAL))
	    /* We need an mandatory argument. */
	    {
	      if (parser->state.next == parser->state.argc)
		/* Missing argument */
970
971
972
973
974
975
976
977
978
979
		{
		  /* 1003.2 specifies the format of this message.  */
		  fprintf (parser->state.err_stream,
			   dgettext(parser->state.root_argp->argp_domain,
				    "%s: option requires an argument -- %c\n"),
			   parser->state.name, c);

		  *arg_ebadkey = 0;
		  return EBADKEY;
		}
980
981
	      value = parser->state.argv[parser->state.next++];
	    }
Niels Möller's avatar
Niels Möller committed
982
	}
983
984
      return group_parse(group, &parser->state,
			 option->key, value);
Niels Möller's avatar
Niels Möller committed
985
986
987
    }
  else
    {
988
989
990
      char *arg;
      
      if (parser->state.next >= parser->state.argc)
Niels Möller's avatar
Niels Möller committed
991
992
993
994
995
	/* Indicate that we're done.  */
	{
	  *arg_ebadkey = 1;
	  return EBADKEY;
	}
996
997
998
999
      
      arg = parser->state.argv[parser->state.next++];

      if (parser->state.quoted)
Niels Möller's avatar
Niels Möller committed
1000
	{
1001
1002
	  *arg_ebadkey = 1;
	  return parser_parse_arg(parser, arg);
Niels Möller's avatar
Niels Möller committed
1003
	}
1004
1005
1006
1007
      else
	/* Look for options. */
	{
	  char *optstart;
1008
1009
1010
	  enum arg_type token = classify_arg(parser, arg, &optstart);
	  
	  switch (token)
1011
1012
	    {
	    case ARG_ARG:
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
	      switch (parser->ordering)
		{
		case PERMUTE:
		  /* FIXME: Permute arguments, unless ARGP_IN_ORDER is
		   * used. */
		  *arg_ebadkey = 1;
		  return parser_parse_arg(parser, arg);
		case REQUIRE_ORDER:
		  /* Implicit quote before the first argument.
		   *
		   * It would make more sense to set quoted = next - 1
		   * (i.e. say that this is the first quoted argument),
		   * but that may cause quoted = 0, which would be wrong. */
		  parser->state.quoted = parser->state.next;

		  /* Fall through */
		case RETURN_IN_ORDER:
		  *arg_ebadkey = 1;
		  return parser_parse_arg(parser, arg);
		default:
		  abort();
		}
1035
1036
1037
	    case ARG_QUOTE:
	      parser->state.quoted = parser->state.next;
	      return 0;
Niels Möller's avatar
Niels Möller committed
1038

1039
	    case ARG_LONG_ONLY_OPTION:
1040
1041
1042
1043
1044
1045
	    case ARG_LONG_OPTION:
	      {
		struct group *group;
		const struct argp_option *option;
		char *value;
		      
1046
		option = find_long_option(parser, optstart, &group);
1047
1048
		
		if (!option)
1049
1050
1051
1052
1053
1054
1055
1056
1057
		  {
		    /* NOTE: This includes any "=something" in the output. */
		    fprintf (parser->state.err_stream,
			     dgettext(parser->state.root_argp->argp_domain,
				      "%s: unrecognized option `%s'\n"),
			     parser->state.name, arg);
		    *arg_ebadkey = 0;
		    return EBADKEY;
		  }
1058
1059
1060
1061
1062
1063
1064

		value = strchr(optstart, '=');
		if (value)
		  value++;
		
		if (value && !option->arg)
		  /* Unexpected argument. */
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
		  {
		    if (token == ARG_LONG_OPTION)
		      /* --option */
		      fprintf (parser->state.err_stream,
			       dgettext(parser->state.root_argp->argp_domain,
					"%s: option `--%s' doesn't allow an argument\n"),
			       parser->state.name, option->name);
		    else
		      /* +option or -option */
		      fprintf (parser->state.err_stream,
			       dgettext(parser->state.root_argp->argp_domain,
					"%s: option `%c%s' doesn't allow an argument\n"),
			       parser->state.name, arg[0], option->name);

		    *arg_ebadkey = 0;
		    return EBADKEY;
		  }
		
1083
1084
1085
1086
1087
1088
		if (option->arg && !value
		    && !(option->flags & OPTION_ARG_OPTIONAL))
		  /* We need an mandatory argument. */
		  {
		    if (parser->state.next == parser->state.argc)
		      /* Missing argument */
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
		      {
			if (token == ARG_LONG_OPTION)
			  /* --option */
			  fprintf (parser->state.err_stream,
				   dgettext(parser->state.root_argp->argp_domain,
					    "%s: option `--%s' requires an argument\n"),
				 parser->state.name, option->name);
			else
			  /* +option or -option */
			  fprintf (parser->state.err_stream,
				   dgettext(parser->state.root_argp->argp_domain,
					    "%s: option `%c%s' requires an argument\n"),
				   parser->state.name, arg[0], option->name);

			*arg_ebadkey = 0;
			return EBADKEY;
		      }
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121

		    value = parser->state.argv[parser->state.next++];
		  }
		*arg_ebadkey = 0;
		return group_parse(group, &parser->state,
				   option->key, value);
	      }
	    case ARG_SHORT_OPTION:
	      parser->nextchar = optstart;
	      return 0;

	    default:
	      abort();
	    }
	}
    }
Niels Möller's avatar
Niels Möller committed
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
}

/* Parse the options strings in ARGC & ARGV according to the argp in ARGP.
   FLAGS is one of the ARGP_ flags above.  If END_INDEX is non-NULL, the
   index in ARGV of the first unparsed option is returned in it.  If an
   unknown option is present, EINVAL is returned; if some parser routine
   returned a non-zero value, it is returned; otherwise 0 is returned.  */
error_t
__argp_parse (const struct argp *argp, int argc, char **argv, unsigned flags,
	      int *end_index, void *input)
{
  error_t err;
  struct parser parser;

  /* If true, then err == EBADKEY is a result of a non-option argument failing
     to be parsed (which in some cases isn't actually an error).  */
  int arg_ebadkey = 0;

  if (! (flags & ARGP_NO_HELP))
    /* Add our own options.  */
    {
      struct argp_child *child = alloca (4 * sizeof (struct argp_child));
      struct argp *top_argp = alloca (sizeof (struct argp));

      /* TOP_ARGP has no options, it just serves to group the user & default
	 argps.  */
      memset (top_argp, 0, sizeof (*top_argp));
      top_argp->children = child;

      memset (child, 0, 4 * sizeof (struct argp_child));

      if (argp)
	(child++)->argp = argp;
      (child++)->argp = &argp_default_argp;
      if (argp_program_version || argp_program_version_hook)
	(child++)->argp = &argp_version_argp;
      child->argp = 0;

      argp = top_argp;
    }

  /* Construct a parser for these arguments.  */
  err = parser_init (&parser, argp, argc, argv, flags, input);

  if (! err)
    /* Parse! */
    {
      while (! err)
	err = parser_parse_next (&parser, &arg_ebadkey);
      err = parser_finalize (&parser, err, arg_ebadkey, end_index);
    }

  return err;
}
#ifdef weak_alias
weak_alias (__argp_parse, argp_parse)
#endif

/* Return the input field for ARGP in the parser corresponding to STATE; used
   by the help routines.  */
void *
__argp_input (const struct argp *argp, const struct argp_state *state)
{
  if (state)
    {
      struct group *group;
      struct parser *parser = state->pstate;

      for (group = parser->groups; group < parser->egroup; group++)
	if (group->argp == argp)
	  return group->input;
    }

  return 0;
}
#ifdef weak_alias
weak_alias (__argp_input, _argp_input)
#endif
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216

/* Defined here, in case a user is not inlining the definitions in
 * argp.h */
void
__argp_usage (__const struct argp_state *__state) __THROW
{
  __argp_state_help (__state, stderr, ARGP_HELP_STD_USAGE);
}

int
__option_is_short (__const struct argp_option *__opt) __THROW
{
  if (__opt->flags & OPTION_DOC)
    return 0;
  else
    {
      int __key = __opt->key;
1217
1218
      /* FIXME: whether or not a particular key implies a short option
       * ought not to be locale dependent. */
1219
1220
1221
1222
1223
1224
1225
1226
1227
      return __key > 0 && isprint (__key);
    }
}

int
__option_is_end (__const struct argp_option *__opt) __THROW
{
  return !__opt->key && !__opt->name && !__opt->doc && !__opt->group;
}