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