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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libiberty/] [getopt.c] - Blame information for rev 736

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 736 jeremybenn
/* Getopt for GNU.
2
   NOTE: getopt is now part of the C library, so if you don't know what
3
   "Keep this file name-space clean" means, talk to drepper@gnu.org
4
   before changing it!
5
 
6
   Copyright (C) 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
7
   1996, 1997, 1998, 2005 Free Software Foundation, Inc.
8
 
9
   NOTE: This source is derived from an old version taken from the GNU C
10
   Library (glibc).
11
 
12
   This program is free software; you can redistribute it and/or modify it
13
   under the terms of the GNU General Public License as published by the
14
   Free Software Foundation; either version 2, or (at your option) any
15
   later version.
16
 
17
   This program is distributed in the hope that it will be useful,
18
   but WITHOUT ANY WARRANTY; without even the implied warranty of
19
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20
   GNU General Public License for more details.
21
 
22
   You should have received a copy of the GNU General Public License
23
   along with this program; if not, write to the Free Software
24
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301,
25
   USA.  */
26
 
27
/* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
28
   Ditto for AIX 3.2 and <stdlib.h>.  */
29
#ifndef _NO_PROTO
30
# define _NO_PROTO
31
#endif
32
 
33
#ifdef HAVE_CONFIG_H
34
# include <config.h>
35
#endif
36
 
37
#if !defined __STDC__ || !__STDC__
38
/* This is a separate conditional since some stdc systems
39
   reject `defined (const)'.  */
40
# ifndef const
41
#  define const
42
# endif
43
#endif
44
 
45
#include "ansidecl.h"
46
#include <stdio.h>
47
 
48
/* Comment out all this code if we are using the GNU C Library, and are not
49
   actually compiling the library itself.  This code is part of the GNU C
50
   Library, but also included in many other GNU distributions.  Compiling
51
   and linking in this code is a waste when using the GNU C library
52
   (especially if it is a shared library).  Rather than having every GNU
53
   program understand `configure --with-gnu-libc' and omit the object files,
54
   it is simpler to just do this in the source for each such file.  */
55
 
56
#define GETOPT_INTERFACE_VERSION 2
57
#if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2
58
# include <gnu-versions.h>
59
# if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
60
#  define ELIDE_CODE
61
# endif
62
#endif
63
 
64
#ifndef ELIDE_CODE
65
 
66
 
67
/* This needs to come after some library #include
68
   to get __GNU_LIBRARY__ defined.  */
69
#ifdef  __GNU_LIBRARY__
70
/* Don't include stdlib.h for non-GNU C libraries because some of them
71
   contain conflicting prototypes for getopt.  */
72
# include <stdlib.h>
73
# include <unistd.h>
74
#endif  /* GNU C library.  */
75
 
76
#ifdef VMS
77
# include <unixlib.h>
78
# if HAVE_STRING_H - 0
79
#  include <string.h>
80
# endif
81
#endif
82
 
83
#ifndef _
84
/* This is for other GNU distributions with internationalized messages.
85
   When compiling libc, the _ macro is predefined.  */
86
# if (HAVE_LIBINTL_H && ENABLE_NLS) || defined _LIBC
87
#  include <libintl.h>
88
#  define _(msgid)      gettext (msgid)
89
# else
90
#  define _(msgid)      (msgid)
91
# endif
92
#endif
93
 
94
/* This version of `getopt' appears to the caller like standard Unix `getopt'
95
   but it behaves differently for the user, since it allows the user
96
   to intersperse the options with the other arguments.
97
 
98
   As `getopt' works, it permutes the elements of ARGV so that,
99
   when it is done, all the options precede everything else.  Thus
100
   all application programs are extended to handle flexible argument order.
101
 
102
   Setting the environment variable POSIXLY_CORRECT disables permutation.
103
   Then the behavior is completely standard.
104
 
105
   GNU application programs can use a third alternative mode in which
106
   they can distinguish the relative order of options and other arguments.  */
107
 
108
#include "getopt.h"
109
 
110
/* For communication from `getopt' to the caller.
111
   When `getopt' finds an option that takes an argument,
112
   the argument value is returned here.
113
   Also, when `ordering' is RETURN_IN_ORDER,
114
   each non-option ARGV-element is returned here.  */
115
 
116
char *optarg = NULL;
117
 
118
/* Index in ARGV of the next element to be scanned.
119
   This is used for communication to and from the caller
120
   and for communication between successive calls to `getopt'.
121
 
122
   On entry to `getopt', zero means this is the first call; initialize.
123
 
124
   When `getopt' returns -1, this is the index of the first of the
125
   non-option elements that the caller should itself scan.
126
 
127
   Otherwise, `optind' communicates from one call to the next
128
   how much of ARGV has been scanned so far.  */
129
 
130
/* 1003.2 says this must be 1 before any call.  */
131
int optind = 1;
132
 
133
/* Formerly, initialization of getopt depended on optind==0, which
134
   causes problems with re-calling getopt as programs generally don't
135
   know that. */
136
 
137
int __getopt_initialized = 0;
138
 
139
/* The next char to be scanned in the option-element
140
   in which the last option character we returned was found.
141
   This allows us to pick up the scan where we left off.
142
 
143
   If this is zero, or a null string, it means resume the scan
144
   by advancing to the next ARGV-element.  */
145
 
146
static char *nextchar;
147
 
148
/* Callers store zero here to inhibit the error message
149
   for unrecognized options.  */
150
 
151
int opterr = 1;
152
 
153
/* Set to an option character which was unrecognized.
154
   This must be initialized on some systems to avoid linking in the
155
   system's own getopt implementation.  */
156
 
157
int optopt = '?';
158
 
159
/* Describe how to deal with options that follow non-option ARGV-elements.
160
 
161
   If the caller did not specify anything,
162
   the default is REQUIRE_ORDER if the environment variable
163
   POSIXLY_CORRECT is defined, PERMUTE otherwise.
164
 
165
   REQUIRE_ORDER means don't recognize them as options;
166
   stop option processing when the first non-option is seen.
167
   This is what Unix does.
168
   This mode of operation is selected by either setting the environment
169
   variable POSIXLY_CORRECT, or using `+' as the first character
170
   of the list of option characters.
171
 
172
   PERMUTE is the default.  We permute the contents of ARGV as we scan,
173
   so that eventually all the non-options are at the end.  This allows options
174
   to be given in any order, even with programs that were not written to
175
   expect this.
176
 
177
   RETURN_IN_ORDER is an option available to programs that were written
178
   to expect options and other ARGV-elements in any order and that care about
179
   the ordering of the two.  We describe each non-option ARGV-element
180
   as if it were the argument of an option with character code 1.
181
   Using `-' as the first character of the list of option characters
182
   selects this mode of operation.
183
 
184
   The special argument `--' forces an end of option-scanning regardless
185
   of the value of `ordering'.  In the case of RETURN_IN_ORDER, only
186
   `--' can cause `getopt' to return -1 with `optind' != ARGC.  */
187
 
188
static enum
189
{
190
  REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
191
} ordering;
192
 
193
/* Value of POSIXLY_CORRECT environment variable.  */
194
static char *posixly_correct;
195
 
196
#ifdef  __GNU_LIBRARY__
197
/* We want to avoid inclusion of string.h with non-GNU libraries
198
   because there are many ways it can cause trouble.
199
   On some systems, it contains special magic macros that don't work
200
   in GCC.  */
201
# include <string.h>
202
# define my_index       strchr
203
#else
204
 
205
# if HAVE_STRING_H
206
#  include <string.h>
207
# else
208
#  if HAVE_STRINGS_H
209
#   include <strings.h>
210
#  endif
211
# endif
212
 
213
/* Avoid depending on library functions or files
214
   whose names are inconsistent.  */
215
 
216
#if HAVE_STDLIB_H && HAVE_DECL_GETENV
217
#  include <stdlib.h>
218
#elif !defined(getenv)
219
#  ifdef __cplusplus
220
extern "C" {
221
#  endif /* __cplusplus */
222
extern char *getenv (const char *);
223
#  ifdef __cplusplus
224
}
225
#  endif /* __cplusplus */
226
#endif
227
 
228
static char *
229
my_index (const char *str, int chr)
230
{
231
  while (*str)
232
    {
233
      if (*str == chr)
234
        return (char *) str;
235
      str++;
236
    }
237
  return 0;
238
}
239
 
240
/* If using GCC, we can safely declare strlen this way.
241
   If not using GCC, it is ok not to declare it.  */
242
#ifdef __GNUC__
243
/* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
244
   That was relevant to code that was here before.  */
245
# if (!defined __STDC__ || !__STDC__) && !defined strlen
246
/* gcc with -traditional declares the built-in strlen to return int,
247
   and has done so at least since version 2.4.5. -- rms.  */
248
extern int strlen (const char *);
249
# endif /* not __STDC__ */
250
#endif /* __GNUC__ */
251
 
252
#endif /* not __GNU_LIBRARY__ */
253
 
254
/* Handle permutation of arguments.  */
255
 
256
/* Describe the part of ARGV that contains non-options that have
257
   been skipped.  `first_nonopt' is the index in ARGV of the first of them;
258
   `last_nonopt' is the index after the last of them.  */
259
 
260
static int first_nonopt;
261
static int last_nonopt;
262
 
263
#ifdef _LIBC
264
/* Bash 2.0 gives us an environment variable containing flags
265
   indicating ARGV elements that should not be considered arguments.  */
266
 
267
/* Defined in getopt_init.c  */
268
extern char *__getopt_nonoption_flags;
269
 
270
static int nonoption_flags_max_len;
271
static int nonoption_flags_len;
272
 
273
static int original_argc;
274
static char *const *original_argv;
275
 
276
/* Make sure the environment variable bash 2.0 puts in the environment
277
   is valid for the getopt call we must make sure that the ARGV passed
278
   to getopt is that one passed to the process.  */
279
static void
280
__attribute__ ((unused))
281
store_args_and_env (int argc, char *const *argv)
282
{
283
  /* XXX This is no good solution.  We should rather copy the args so
284
     that we can compare them later.  But we must not use malloc(3).  */
285
  original_argc = argc;
286
  original_argv = argv;
287
}
288
# ifdef text_set_element
289
text_set_element (__libc_subinit, store_args_and_env);
290
# endif /* text_set_element */
291
 
292
# define SWAP_FLAGS(ch1, ch2) \
293
  if (nonoption_flags_len > 0)                                                 \
294
    {                                                                         \
295
      char __tmp = __getopt_nonoption_flags[ch1];                             \
296
      __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2];          \
297
      __getopt_nonoption_flags[ch2] = __tmp;                                  \
298
    }
299
#else   /* !_LIBC */
300
# define SWAP_FLAGS(ch1, ch2)
301
#endif  /* _LIBC */
302
 
303
/* Exchange two adjacent subsequences of ARGV.
304
   One subsequence is elements [first_nonopt,last_nonopt)
305
   which contains all the non-options that have been skipped so far.
306
   The other is elements [last_nonopt,optind), which contains all
307
   the options processed since those non-options were skipped.
308
 
309
   `first_nonopt' and `last_nonopt' are relocated so that they describe
310
   the new indices of the non-options in ARGV after they are moved.  */
311
 
312
#if defined __STDC__ && __STDC__
313
static void exchange (char **);
314
#endif
315
 
316
static void
317
exchange (char **argv)
318
{
319
  int bottom = first_nonopt;
320
  int middle = last_nonopt;
321
  int top = optind;
322
  char *tem;
323
 
324
  /* Exchange the shorter segment with the far end of the longer segment.
325
     That puts the shorter segment into the right place.
326
     It leaves the longer segment in the right place overall,
327
     but it consists of two parts that need to be swapped next.  */
328
 
329
#ifdef _LIBC
330
  /* First make sure the handling of the `__getopt_nonoption_flags'
331
     string can work normally.  Our top argument must be in the range
332
     of the string.  */
333
  if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len)
334
    {
335
      /* We must extend the array.  The user plays games with us and
336
         presents new arguments.  */
337
      char *new_str = (char *) malloc (top + 1);
338
      if (new_str == NULL)
339
        nonoption_flags_len = nonoption_flags_max_len = 0;
340
      else
341
        {
342
          memset (mempcpy (new_str, __getopt_nonoption_flags,
343
                           nonoption_flags_max_len),
344
                  '\0', top + 1 - nonoption_flags_max_len);
345
          nonoption_flags_max_len = top + 1;
346
          __getopt_nonoption_flags = new_str;
347
        }
348
    }
349
#endif
350
 
351
  while (top > middle && middle > bottom)
352
    {
353
      if (top - middle > middle - bottom)
354
        {
355
          /* Bottom segment is the short one.  */
356
          int len = middle - bottom;
357
          register int i;
358
 
359
          /* Swap it with the top part of the top segment.  */
360
          for (i = 0; i < len; i++)
361
            {
362
              tem = argv[bottom + i];
363
              argv[bottom + i] = argv[top - (middle - bottom) + i];
364
              argv[top - (middle - bottom) + i] = tem;
365
              SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
366
            }
367
          /* Exclude the moved bottom segment from further swapping.  */
368
          top -= len;
369
        }
370
      else
371
        {
372
          /* Top segment is the short one.  */
373
          int len = top - middle;
374
          register int i;
375
 
376
          /* Swap it with the bottom part of the bottom segment.  */
377
          for (i = 0; i < len; i++)
378
            {
379
              tem = argv[bottom + i];
380
              argv[bottom + i] = argv[middle + i];
381
              argv[middle + i] = tem;
382
              SWAP_FLAGS (bottom + i, middle + i);
383
            }
384
          /* Exclude the moved top segment from further swapping.  */
385
          bottom += len;
386
        }
387
    }
388
 
389
  /* Update records for the slots the non-options now occupy.  */
390
 
391
  first_nonopt += (optind - last_nonopt);
392
  last_nonopt = optind;
393
}
394
 
395
/* Initialize the internal data when the first call is made.  */
396
 
397
#if defined __STDC__ && __STDC__
398
static const char *_getopt_initialize (int, char *const *, const char *);
399
#endif
400
static const char *
401
_getopt_initialize (int argc ATTRIBUTE_UNUSED,
402
                    char *const *argv ATTRIBUTE_UNUSED,
403
                    const char *optstring)
404
{
405
  /* Start processing options with ARGV-element 1 (since ARGV-element 0
406
     is the program name); the sequence of previously skipped
407
     non-option ARGV-elements is empty.  */
408
 
409
  first_nonopt = last_nonopt = optind;
410
 
411
  nextchar = NULL;
412
 
413
  posixly_correct = getenv ("POSIXLY_CORRECT");
414
 
415
  /* Determine how to handle the ordering of options and nonoptions.  */
416
 
417
  if (optstring[0] == '-')
418
    {
419
      ordering = RETURN_IN_ORDER;
420
      ++optstring;
421
    }
422
  else if (optstring[0] == '+')
423
    {
424
      ordering = REQUIRE_ORDER;
425
      ++optstring;
426
    }
427
  else if (posixly_correct != NULL)
428
    ordering = REQUIRE_ORDER;
429
  else
430
    ordering = PERMUTE;
431
 
432
#ifdef _LIBC
433
  if (posixly_correct == NULL
434
      && argc == original_argc && argv == original_argv)
435
    {
436
      if (nonoption_flags_max_len == 0)
437
        {
438
          if (__getopt_nonoption_flags == NULL
439
              || __getopt_nonoption_flags[0] == '\0')
440
            nonoption_flags_max_len = -1;
441
          else
442
            {
443
              const char *orig_str = __getopt_nonoption_flags;
444
              int len = nonoption_flags_max_len = strlen (orig_str);
445
              if (nonoption_flags_max_len < argc)
446
                nonoption_flags_max_len = argc;
447
              __getopt_nonoption_flags =
448
                (char *) malloc (nonoption_flags_max_len);
449
              if (__getopt_nonoption_flags == NULL)
450
                nonoption_flags_max_len = -1;
451
              else
452
                memset (mempcpy (__getopt_nonoption_flags, orig_str, len),
453
                        '\0', nonoption_flags_max_len - len);
454
            }
455
        }
456
      nonoption_flags_len = nonoption_flags_max_len;
457
    }
458
  else
459
    nonoption_flags_len = 0;
460
#endif
461
 
462
  return optstring;
463
}
464
 
465
/* Scan elements of ARGV (whose length is ARGC) for option characters
466
   given in OPTSTRING.
467
 
468
   If an element of ARGV starts with '-', and is not exactly "-" or "--",
469
   then it is an option element.  The characters of this element
470
   (aside from the initial '-') are option characters.  If `getopt'
471
   is called repeatedly, it returns successively each of the option characters
472
   from each of the option elements.
473
 
474
   If `getopt' finds another option character, it returns that character,
475
   updating `optind' and `nextchar' so that the next call to `getopt' can
476
   resume the scan with the following option character or ARGV-element.
477
 
478
   If there are no more option characters, `getopt' returns -1.
479
   Then `optind' is the index in ARGV of the first ARGV-element
480
   that is not an option.  (The ARGV-elements have been permuted
481
   so that those that are not options now come last.)
482
 
483
   OPTSTRING is a string containing the legitimate option characters.
484
   If an option character is seen that is not listed in OPTSTRING,
485
   return '?' after printing an error message.  If you set `opterr' to
486
   zero, the error message is suppressed but we still return '?'.
487
 
488
   If a char in OPTSTRING is followed by a colon, that means it wants an arg,
489
   so the following text in the same ARGV-element, or the text of the following
490
   ARGV-element, is returned in `optarg'.  Two colons mean an option that
491
   wants an optional arg; if there is text in the current ARGV-element,
492
   it is returned in `optarg', otherwise `optarg' is set to zero.
493
 
494
   If OPTSTRING starts with `-' or `+', it requests different methods of
495
   handling the non-option ARGV-elements.
496
   See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
497
 
498
   Long-named options begin with `--' instead of `-'.
499
   Their names may be abbreviated as long as the abbreviation is unique
500
   or is an exact match for some defined option.  If they have an
501
   argument, it follows the option name in the same ARGV-element, separated
502
   from the option name by a `=', or else the in next ARGV-element.
503
   When `getopt' finds a long-named option, it returns 0 if that option's
504
   `flag' field is nonzero, the value of the option's `val' field
505
   if the `flag' field is zero.
506
 
507
   The elements of ARGV aren't really const, because we permute them.
508
   But we pretend they're const in the prototype to be compatible
509
   with other systems.
510
 
511
   LONGOPTS is a vector of `struct option' terminated by an
512
   element containing a name which is zero.
513
 
514
   LONGIND returns the index in LONGOPT of the long-named option found.
515
   It is only valid when a long-named option has been found by the most
516
   recent call.
517
 
518
   If LONG_ONLY is nonzero, '-' as well as '--' can introduce
519
   long-named options.  */
520
 
521
int
522
_getopt_internal (int argc, char *const *argv, const char *optstring,
523
                  const struct option *longopts,
524
                  int *longind, int long_only)
525
{
526
  optarg = NULL;
527
 
528
  if (optind == 0 || !__getopt_initialized)
529
    {
530
      if (optind == 0)
531
        optind = 1;     /* Don't scan ARGV[0], the program name.  */
532
      optstring = _getopt_initialize (argc, argv, optstring);
533
      __getopt_initialized = 1;
534
    }
535
 
536
  /* Test whether ARGV[optind] points to a non-option argument.
537
     Either it does not have option syntax, or there is an environment flag
538
     from the shell indicating it is not an option.  The later information
539
     is only used when the used in the GNU libc.  */
540
#ifdef _LIBC
541
# define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0'       \
542
                      || (optind < nonoption_flags_len                        \
543
                          && __getopt_nonoption_flags[optind] == '1'))
544
#else
545
# define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')
546
#endif
547
 
548
  if (nextchar == NULL || *nextchar == '\0')
549
    {
550
      /* Advance to the next ARGV-element.  */
551
 
552
      /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
553
         moved back by the user (who may also have changed the arguments).  */
554
      if (last_nonopt > optind)
555
        last_nonopt = optind;
556
      if (first_nonopt > optind)
557
        first_nonopt = optind;
558
 
559
      if (ordering == PERMUTE)
560
        {
561
          /* If we have just processed some options following some non-options,
562
             exchange them so that the options come first.  */
563
 
564
          if (first_nonopt != last_nonopt && last_nonopt != optind)
565
            exchange ((char **) argv);
566
          else if (last_nonopt != optind)
567
            first_nonopt = optind;
568
 
569
          /* Skip any additional non-options
570
             and extend the range of non-options previously skipped.  */
571
 
572
          while (optind < argc && NONOPTION_P)
573
            optind++;
574
          last_nonopt = optind;
575
        }
576
 
577
      /* The special ARGV-element `--' means premature end of options.
578
         Skip it like a null option,
579
         then exchange with previous non-options as if it were an option,
580
         then skip everything else like a non-option.  */
581
 
582
      if (optind != argc && !strcmp (argv[optind], "--"))
583
        {
584
          optind++;
585
 
586
          if (first_nonopt != last_nonopt && last_nonopt != optind)
587
            exchange ((char **) argv);
588
          else if (first_nonopt == last_nonopt)
589
            first_nonopt = optind;
590
          last_nonopt = argc;
591
 
592
          optind = argc;
593
        }
594
 
595
      /* If we have done all the ARGV-elements, stop the scan
596
         and back over any non-options that we skipped and permuted.  */
597
 
598
      if (optind == argc)
599
        {
600
          /* Set the next-arg-index to point at the non-options
601
             that we previously skipped, so the caller will digest them.  */
602
          if (first_nonopt != last_nonopt)
603
            optind = first_nonopt;
604
          return -1;
605
        }
606
 
607
      /* If we have come to a non-option and did not permute it,
608
         either stop the scan or describe it to the caller and pass it by.  */
609
 
610
      if (NONOPTION_P)
611
        {
612
          if (ordering == REQUIRE_ORDER)
613
            return -1;
614
          optarg = argv[optind++];
615
          return 1;
616
        }
617
 
618
      /* We have found another option-ARGV-element.
619
         Skip the initial punctuation.  */
620
 
621
      nextchar = (argv[optind] + 1
622
                  + (longopts != NULL && argv[optind][1] == '-'));
623
    }
624
 
625
  /* Decode the current option-ARGV-element.  */
626
 
627
  /* Check whether the ARGV-element is a long option.
628
 
629
     If long_only and the ARGV-element has the form "-f", where f is
630
     a valid short option, don't consider it an abbreviated form of
631
     a long option that starts with f.  Otherwise there would be no
632
     way to give the -f short option.
633
 
634
     On the other hand, if there's a long option "fubar" and
635
     the ARGV-element is "-fu", do consider that an abbreviation of
636
     the long option, just like "--fu", and not "-f" with arg "u".
637
 
638
     This distinction seems to be the most useful approach.  */
639
 
640
  if (longopts != NULL
641
      && (argv[optind][1] == '-'
642
          || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
643
    {
644
      char *nameend;
645
      const struct option *p;
646
      const struct option *pfound = NULL;
647
      int exact = 0;
648
      int ambig = 0;
649
      int indfound = -1;
650
      int option_index;
651
 
652
      for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
653
        /* Do nothing.  */ ;
654
 
655
      /* Test all long options for either exact match
656
         or abbreviated matches.  */
657
      for (p = longopts, option_index = 0; p->name; p++, option_index++)
658
        if (!strncmp (p->name, nextchar, nameend - nextchar))
659
          {
660
            if ((unsigned int) (nameend - nextchar)
661
                == (unsigned int) strlen (p->name))
662
              {
663
                /* Exact match found.  */
664
                pfound = p;
665
                indfound = option_index;
666
                exact = 1;
667
                break;
668
              }
669
            else if (pfound == NULL)
670
              {
671
                /* First nonexact match found.  */
672
                pfound = p;
673
                indfound = option_index;
674
              }
675
            else
676
              /* Second or later nonexact match found.  */
677
              ambig = 1;
678
          }
679
 
680
      if (ambig && !exact)
681
        {
682
          if (opterr)
683
            fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
684
                     argv[0], argv[optind]);
685
          nextchar += strlen (nextchar);
686
          optind++;
687
          optopt = 0;
688
          return '?';
689
        }
690
 
691
      if (pfound != NULL)
692
        {
693
          option_index = indfound;
694
          optind++;
695
          if (*nameend)
696
            {
697
              /* Don't test has_arg with >, because some C compilers don't
698
                 allow it to be used on enums.  */
699
              if (pfound->has_arg)
700
                optarg = nameend + 1;
701
              else
702
                {
703
                  if (opterr)
704
                    {
705
                      if (argv[optind - 1][1] == '-')
706
                        /* --option */
707
                        fprintf (stderr,
708
                                 _("%s: option `--%s' doesn't allow an argument\n"),
709
                                 argv[0], pfound->name);
710
                      else
711
                        /* +option or -option */
712
                        fprintf (stderr,
713
                                 _("%s: option `%c%s' doesn't allow an argument\n"),
714
                                 argv[0], argv[optind - 1][0], pfound->name);
715
 
716
                      nextchar += strlen (nextchar);
717
 
718
                      optopt = pfound->val;
719
                      return '?';
720
                    }
721
                }
722
            }
723
          else if (pfound->has_arg == 1)
724
            {
725
              if (optind < argc)
726
                optarg = argv[optind++];
727
              else
728
                {
729
                  if (opterr)
730
                    fprintf (stderr,
731
                           _("%s: option `%s' requires an argument\n"),
732
                           argv[0], argv[optind - 1]);
733
                  nextchar += strlen (nextchar);
734
                  optopt = pfound->val;
735
                  return optstring[0] == ':' ? ':' : '?';
736
                }
737
            }
738
          nextchar += strlen (nextchar);
739
          if (longind != NULL)
740
            *longind = option_index;
741
          if (pfound->flag)
742
            {
743
              *(pfound->flag) = pfound->val;
744
              return 0;
745
            }
746
          return pfound->val;
747
        }
748
 
749
      /* Can't find it as a long option.  If this is not getopt_long_only,
750
         or the option starts with '--' or is not a valid short
751
         option, then it's an error.
752
         Otherwise interpret it as a short option.  */
753
      if (!long_only || argv[optind][1] == '-'
754
          || my_index (optstring, *nextchar) == NULL)
755
        {
756
          if (opterr)
757
            {
758
              if (argv[optind][1] == '-')
759
                /* --option */
760
                fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
761
                         argv[0], nextchar);
762
              else
763
                /* +option or -option */
764
                fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
765
                         argv[0], argv[optind][0], nextchar);
766
            }
767
          nextchar = (char *) "";
768
          optind++;
769
          optopt = 0;
770
          return '?';
771
        }
772
    }
773
 
774
  /* Look at and handle the next short option-character.  */
775
 
776
  {
777
    char c = *nextchar++;
778
    char *temp = my_index (optstring, c);
779
 
780
    /* Increment `optind' when we start to process its last character.  */
781
    if (*nextchar == '\0')
782
      ++optind;
783
 
784
    if (temp == NULL || c == ':')
785
      {
786
        if (opterr)
787
          {
788
            if (posixly_correct)
789
              /* 1003.2 specifies the format of this message.  */
790
              fprintf (stderr, _("%s: illegal option -- %c\n"),
791
                       argv[0], c);
792
            else
793
              fprintf (stderr, _("%s: invalid option -- %c\n"),
794
                       argv[0], c);
795
          }
796
        optopt = c;
797
        return '?';
798
      }
799
    /* Convenience. Treat POSIX -W foo same as long option --foo */
800
    if (temp[0] == 'W' && temp[1] == ';')
801
      {
802
        char *nameend;
803
        const struct option *p;
804
        const struct option *pfound = NULL;
805
        int exact = 0;
806
        int ambig = 0;
807
        int indfound = 0;
808
        int option_index;
809
 
810
        /* This is an option that requires an argument.  */
811
        if (*nextchar != '\0')
812
          {
813
            optarg = nextchar;
814
            /* If we end this ARGV-element by taking the rest as an arg,
815
               we must advance to the next element now.  */
816
            optind++;
817
          }
818
        else if (optind == argc)
819
          {
820
            if (opterr)
821
              {
822
                /* 1003.2 specifies the format of this message.  */
823
                fprintf (stderr, _("%s: option requires an argument -- %c\n"),
824
                         argv[0], c);
825
              }
826
            optopt = c;
827
            if (optstring[0] == ':')
828
              c = ':';
829
            else
830
              c = '?';
831
            return c;
832
          }
833
        else
834
          /* We already incremented `optind' once;
835
             increment it again when taking next ARGV-elt as argument.  */
836
          optarg = argv[optind++];
837
 
838
        /* optarg is now the argument, see if it's in the
839
           table of longopts.  */
840
 
841
        for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++)
842
          /* Do nothing.  */ ;
843
 
844
        /* Test all long options for either exact match
845
           or abbreviated matches.  */
846
        for (p = longopts, option_index = 0; p->name; p++, option_index++)
847
          if (!strncmp (p->name, nextchar, nameend - nextchar))
848
            {
849
              if ((unsigned int) (nameend - nextchar) == strlen (p->name))
850
                {
851
                  /* Exact match found.  */
852
                  pfound = p;
853
                  indfound = option_index;
854
                  exact = 1;
855
                  break;
856
                }
857
              else if (pfound == NULL)
858
                {
859
                  /* First nonexact match found.  */
860
                  pfound = p;
861
                  indfound = option_index;
862
                }
863
              else
864
                /* Second or later nonexact match found.  */
865
                ambig = 1;
866
            }
867
        if (ambig && !exact)
868
          {
869
            if (opterr)
870
              fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
871
                       argv[0], argv[optind]);
872
            nextchar += strlen (nextchar);
873
            optind++;
874
            return '?';
875
          }
876
        if (pfound != NULL)
877
          {
878
            option_index = indfound;
879
            if (*nameend)
880
              {
881
                /* Don't test has_arg with >, because some C compilers don't
882
                   allow it to be used on enums.  */
883
                if (pfound->has_arg)
884
                  optarg = nameend + 1;
885
                else
886
                  {
887
                    if (opterr)
888
                      fprintf (stderr, _("\
889
%s: option `-W %s' doesn't allow an argument\n"),
890
                               argv[0], pfound->name);
891
 
892
                    nextchar += strlen (nextchar);
893
                    return '?';
894
                  }
895
              }
896
            else if (pfound->has_arg == 1)
897
              {
898
                if (optind < argc)
899
                  optarg = argv[optind++];
900
                else
901
                  {
902
                    if (opterr)
903
                      fprintf (stderr,
904
                               _("%s: option `%s' requires an argument\n"),
905
                               argv[0], argv[optind - 1]);
906
                    nextchar += strlen (nextchar);
907
                    return optstring[0] == ':' ? ':' : '?';
908
                  }
909
              }
910
            nextchar += strlen (nextchar);
911
            if (longind != NULL)
912
              *longind = option_index;
913
            if (pfound->flag)
914
              {
915
                *(pfound->flag) = pfound->val;
916
                return 0;
917
              }
918
            return pfound->val;
919
          }
920
          nextchar = NULL;
921
          return 'W';   /* Let the application handle it.   */
922
      }
923
    if (temp[1] == ':')
924
      {
925
        if (temp[2] == ':')
926
          {
927
            /* This is an option that accepts an argument optionally.  */
928
            if (*nextchar != '\0')
929
              {
930
                optarg = nextchar;
931
                optind++;
932
              }
933
            else
934
              optarg = NULL;
935
            nextchar = NULL;
936
          }
937
        else
938
          {
939
            /* This is an option that requires an argument.  */
940
            if (*nextchar != '\0')
941
              {
942
                optarg = nextchar;
943
                /* If we end this ARGV-element by taking the rest as an arg,
944
                   we must advance to the next element now.  */
945
                optind++;
946
              }
947
            else if (optind == argc)
948
              {
949
                if (opterr)
950
                  {
951
                    /* 1003.2 specifies the format of this message.  */
952
                    fprintf (stderr,
953
                           _("%s: option requires an argument -- %c\n"),
954
                           argv[0], c);
955
                  }
956
                optopt = c;
957
                if (optstring[0] == ':')
958
                  c = ':';
959
                else
960
                  c = '?';
961
              }
962
            else
963
              /* We already incremented `optind' once;
964
                 increment it again when taking next ARGV-elt as argument.  */
965
              optarg = argv[optind++];
966
            nextchar = NULL;
967
          }
968
      }
969
    return c;
970
  }
971
}
972
 
973
int
974
getopt (int argc, char *const *argv, const char *optstring)
975
{
976
  return _getopt_internal (argc, argv, optstring,
977
                           (const struct option *) 0,
978
                           (int *) 0,
979
                           0);
980
}
981
 
982
#endif  /* Not ELIDE_CODE.  */
983
 
984
#ifdef TEST
985
 
986
/* Compile with -DTEST to make an executable for use in testing
987
   the above definition of `getopt'.  */
988
 
989
int
990
main (int argc, char **argv)
991
{
992
  int c;
993
  int digit_optind = 0;
994
 
995
  while (1)
996
    {
997
      int this_option_optind = optind ? optind : 1;
998
 
999
      c = getopt (argc, argv, "abc:d:0123456789");
1000
      if (c == -1)
1001
        break;
1002
 
1003
      switch (c)
1004
        {
1005
        case '0':
1006
        case '1':
1007
        case '2':
1008
        case '3':
1009
        case '4':
1010
        case '5':
1011
        case '6':
1012
        case '7':
1013
        case '8':
1014
        case '9':
1015
          if (digit_optind != 0 && digit_optind != this_option_optind)
1016
            printf ("digits occur in two different argv-elements.\n");
1017
          digit_optind = this_option_optind;
1018
          printf ("option %c\n", c);
1019
          break;
1020
 
1021
        case 'a':
1022
          printf ("option a\n");
1023
          break;
1024
 
1025
        case 'b':
1026
          printf ("option b\n");
1027
          break;
1028
 
1029
        case 'c':
1030
          printf ("option c with value `%s'\n", optarg);
1031
          break;
1032
 
1033
        case '?':
1034
          break;
1035
 
1036
        default:
1037
          printf ("?? getopt returned character code 0%o ??\n", c);
1038
        }
1039
    }
1040
 
1041
  if (optind < argc)
1042
    {
1043
      printf ("non-option ARGV-elements: ");
1044
      while (optind < argc)
1045
        printf ("%s ", argv[optind++]);
1046
      printf ("\n");
1047
    }
1048
 
1049
  exit (0);
1050
}
1051
 
1052
#endif /* TEST */

powered by: WebSVN 2.1.0

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