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