OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [newlib-1.18.0/] [newlib/] [libc/] [sys/] [linux/] [argp/] [argp-parse.c] - Blame information for rev 207

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.