getopt.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 NOTE: The canonical source of this file is maintained with the GNU C Library.
10 Bugs can be reported to bug-glibc@prep.ai.mit.edu.
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
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 #include <stdio.h>
38 #include <string.h>
39 #include <stdlib.h>
40 
41 /* Comment out all this code if we are using the GNU C Library, and are not
42  actually compiling the library itself. This code is part of the GNU C
43  Library, but also included in many other GNU distributions. Compiling
44  and linking in this code is a waste when using the GNU C library
45  (especially if it is a shared library). Rather than having every GNU
46  program understand `configure --with-gnu-libc' and omit the object files,
47  it is simpler to just do this in the source for each such file. */
48 
49 #define GETOPT_INTERFACE_VERSION 2
50 #if !defined (_LIBC) && defined (__GLIBC__) && __GLIBC__ >= 2
51 #include <gnu-versions.h>
52 #if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
53 #define ELIDE_CODE
54 #endif
55 #endif
56 
57 #ifndef ELIDE_CODE
58 
59 
60 /* This needs to come after some library #include
61  to get __GNU_LIBRARY__ defined. */
62 #ifdef __GNU_LIBRARY__
63 /* Don't include stdlib.h for non-GNU C libraries because some of them
64  contain conflicting prototypes for getopt. */
65 #include <stdlib.h>
66 #include <unistd.h>
67 #endif /* GNU C library. */
68 
69 #ifdef VMS
70 #include <unixlib.h>
71 #if HAVE_STRING_H - 0
72 #include <string.h>
73 #endif
74 #endif
75 
76 #if defined (WIN32_NATIVE) && !defined (CYGWIN)
77 /* It's not Unix, really. See? Capital letters. */
78 #include <windows.h>
79 #undef getpid
80 #define getpid() GetCurrentProcessId()
81 #endif
82 
83 #ifndef _
84 /* This is for other GNU distributions with internationalized messages.
85  When compiling libc, the _ macro is predefined. */
86 #ifdef HAVE_LIBINTL_H
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 
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 {
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 static char *
206 my_index (const char *str, int chr)
207 {
208  while (*str)
209  {
210  if (*str == chr)
211  return (char *) str;
212  str++;
213  }
214  return 0;
215 }
216 
217 /* If using GCC, we can safely declare strlen this way.
218  If not using GCC, it is ok not to declare it. */
219 #ifdef __GNUC__
220 /* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
221  That was relevant to code that was here before. */
222 #if !defined (__STDC__) || !__STDC__
223 /* gcc with -traditional declares the built-in strlen to return int,
224  and has done so at least since version 2.4.5. -- rms. */
225 extern int strlen (const char *);
226 #endif /* not __STDC__ */
227 #endif /* __GNUC__ */
228 
229 #endif /* not __GNU_LIBRARY__ */
230 
231 /* Handle permutation of arguments. */
232 
233 /* Describe the part of ARGV that contains non-options that have
234  been skipped. `first_nonopt' is the index in ARGV of the first of them;
235  `last_nonopt' is the index after the last of them. */
236 
237 static int first_nonopt;
238 static int last_nonopt;
239 
240 #ifdef _LIBC
241 /* Bash 2.0 gives us an environment variable containing flags
242  indicating ARGV elements that should not be considered arguments. */
243 
244 /* Defined in getopt_init.c */
245 extern char *__getopt_nonoption_flags;
246 
247 static int nonoption_flags_max_len;
248 static int nonoption_flags_len;
249 
250 static int original_argc;
251 static char *const *original_argv;
252 
253 extern pid_t __libc_pid;
254 
255 /* Make sure the environment variable bash 2.0 puts in the environment
256  is valid for the getopt call we must make sure that the ARGV passed
257  to getopt is that one passed to the process. */
258 static void
259 __attribute__ ((unused))
260 store_args_and_env (int argc, char *const *argv)
261 {
262  /* XXX This is no good solution. We should rather copy the args so
263  that we can compare them later. But we must not use malloc(3). */
264  original_argc = argc;
265  original_argv = argv;
266 }
267 text_set_element (__libc_subinit, store_args_and_env);
268 
269 # define SWAP_FLAGS(ch1, ch2) \
270  if (nonoption_flags_len > 0) \
271  { \
272  char __tmp = __getopt_nonoption_flags[ch1]; \
273  __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2]; \
274  __getopt_nonoption_flags[ch2] = __tmp; \
275  }
276 #else /* !_LIBC */
277 # define SWAP_FLAGS(ch1, ch2)
278 #endif /* _LIBC */
279 
280 /* Exchange two adjacent subsequences of ARGV.
281  One subsequence is elements [first_nonopt,last_nonopt)
282  which contains all the non-options that have been skipped so far.
283  The other is elements [last_nonopt,optind), which contains all
284  the options processed since those non-options were skipped.
285 
286  `first_nonopt' and `last_nonopt' are relocated so that they describe
287  the new indices of the non-options in ARGV after they are moved. */
288 
289 #if defined (__STDC__) && __STDC__
290 static void exchange (char **);
291 #endif
292 
293 static void
294 exchange (char **argv)
295 {
296  int bottom = first_nonopt;
297  int middle = last_nonopt;
298  int top = optind;
299  char *tem;
300 
301  /* Exchange the shorter segment with the far end of the longer segment.
302  That puts the shorter segment into the right place.
303  It leaves the longer segment in the right place overall,
304  but it consists of two parts that need to be swapped next. */
305 
306 #ifdef _LIBC
307  /* First make sure the handling of the `__getopt_nonoption_flags'
308  string can work normally. Our top argument must be in the range
309  of the string. */
310  if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len)
311  {
312  /* We must extend the array. The user plays games with us and
313  presents new arguments. */
314  char *new_str = malloc (top + 1);
315  if (new_str == NULL)
316  nonoption_flags_len = nonoption_flags_max_len = 0;
317  else
318  {
319  memcpy (new_str, __getopt_nonoption_flags, nonoption_flags_max_len);
320  memset (&new_str[nonoption_flags_max_len], '\0',
321  top + 1 - nonoption_flags_max_len);
322  nonoption_flags_max_len = top + 1;
323  __getopt_nonoption_flags = new_str;
324  }
325  }
326 #endif
327 
328  while (top > middle && middle > bottom)
329  {
330  if (top - middle > middle - bottom)
331  {
332  /* Bottom segment is the short one. */
333  int len = middle - bottom;
334  register int i;
335 
336  /* Swap it with the top part of the top segment. */
337  for (i = 0; i < len; i++)
338  {
339  tem = argv[bottom + i];
340  argv[bottom + i] = argv[top - (middle - bottom) + i];
341  argv[top - (middle - bottom) + i] = tem;
342  SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
343  }
344  /* Exclude the moved bottom segment from further swapping. */
345  top -= len;
346  }
347  else
348  {
349  /* Top segment is the short one. */
350  int len = top - middle;
351  register int i;
352 
353  /* Swap it with the bottom part of the bottom segment. */
354  for (i = 0; i < len; i++)
355  {
356  tem = argv[bottom + i];
357  argv[bottom + i] = argv[middle + i];
358  argv[middle + i] = tem;
359  SWAP_FLAGS (bottom + i, middle + i);
360  }
361  /* Exclude the moved top segment from further swapping. */
362  bottom += len;
363  }
364  }
365 
366  /* Update records for the slots the non-options now occupy. */
367 
370 }
371 
372 /* Initialize the internal data when the first call is made. */
373 
374 #if defined (__STDC__) && __STDC__
375 static const char *_getopt_initialize (int, char *const *, const char *);
376 #endif
377 static const char *
378 _getopt_initialize (int argc, char *const *argv, const char *optstring)
379 {
380  /* Start processing options with ARGV-element 1 (since ARGV-element 0
381  is the program name); the sequence of previously skipped
382  non-option ARGV-elements is empty. */
383 
385 
386  nextchar = NULL;
387 
388  posixly_correct = getenv ("POSIXLY_CORRECT");
389 
390  /* Determine how to handle the ordering of options and nonoptions. */
391 
392  if (optstring[0] == '-')
393  {
395  ++optstring;
396  }
397  else if (optstring[0] == '+')
398  {
400  ++optstring;
401  }
402  else if (posixly_correct != NULL)
404  else
405  ordering = PERMUTE;
406 
407 #ifdef _LIBC
408  if (posixly_correct == NULL
409  && argc == original_argc && argv == original_argv)
410  {
411  if (nonoption_flags_max_len == 0)
412  {
413  if (__getopt_nonoption_flags == NULL
414  || __getopt_nonoption_flags[0] == '\0')
415  nonoption_flags_max_len = -1;
416  else
417  {
418  const char *orig_str = __getopt_nonoption_flags;
419  int len = nonoption_flags_max_len = strlen (orig_str);
420  if (nonoption_flags_max_len < argc)
421  nonoption_flags_max_len = argc;
422  __getopt_nonoption_flags =
423  (char *) malloc (nonoption_flags_max_len);
424  if (__getopt_nonoption_flags == NULL)
425  nonoption_flags_max_len = -1;
426  else
427  {
428  memcpy (__getopt_nonoption_flags, orig_str, len);
429  memset (&__getopt_nonoption_flags[len], '\0',
430  nonoption_flags_max_len - len);
431  }
432  }
433  }
434  nonoption_flags_len = nonoption_flags_max_len;
435  }
436  else
437  nonoption_flags_len = 0;
438 #endif
439 
440  return optstring;
441 }
442 
443 /* Scan elements of ARGV (whose length is ARGC) for option characters
444  given in OPTSTRING.
445 
446  If an element of ARGV starts with '-', and is not exactly "-" or "--",
447  then it is an option element. The characters of this element
448  (aside from the initial '-') are option characters. If `getopt'
449  is called repeatedly, it returns successively each of the option characters
450  from each of the option elements.
451 
452  If `getopt' finds another option character, it returns that character,
453  updating `optind' and `nextchar' so that the next call to `getopt' can
454  resume the scan with the following option character or ARGV-element.
455 
456  If there are no more option characters, `getopt' returns -1.
457  Then `optind' is the index in ARGV of the first ARGV-element
458  that is not an option. (The ARGV-elements have been permuted
459  so that those that are not options now come last.)
460 
461  OPTSTRING is a string containing the legitimate option characters.
462  If an option character is seen that is not listed in OPTSTRING,
463  return '?' after printing an error message. If you set `opterr' to
464  zero, the error message is suppressed but we still return '?'.
465 
466  If a char in OPTSTRING is followed by a colon, that means it wants an arg,
467  so the following text in the same ARGV-element, or the text of the following
468  ARGV-element, is returned in `optarg'. Two colons mean an option that
469  wants an optional arg; if there is text in the current ARGV-element,
470  it is returned in `optarg', otherwise `optarg' is set to zero.
471 
472  If OPTSTRING starts with `-' or `+', it requests different methods of
473  handling the non-option ARGV-elements.
474  See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
475 
476  Long-named options begin with `--' instead of `-'.
477  Their names may be abbreviated as long as the abbreviation is unique
478  or is an exact match for some defined option. If they have an
479  argument, it follows the option name in the same ARGV-element, separated
480  from the option name by a `=', or else the in next ARGV-element.
481  When `getopt' finds a long-named option, it returns 0 if that option's
482  `flag' field is nonzero, the value of the option's `val' field
483  if the `flag' field is zero.
484 
485  The elements of ARGV aren't really const, because we permute them.
486  But we pretend they're const in the prototype to be compatible
487  with other systems.
488 
489  LONGOPTS is a vector of `struct option' terminated by an
490  element containing a name which is zero.
491 
492  LONGIND returns the index in LONGOPT of the long-named option found.
493  It is only valid when a long-named option has been found by the most
494  recent call.
495 
496  If LONG_ONLY is nonzero, '-' as well as '--' can introduce
497  long-named options. */
498 
499 int
500 _getopt_internal (int argc, char *const *argv, const char *optstring,
501  const struct option *longopts, int *longind, int long_only)
502 {
503  optarg = NULL;
504 
505  if (optind == 0 || !__getopt_initialized)
506  {
507  if (optind == 0)
508  optind = 1; /* Don't scan ARGV[0], the program name. */
509  optstring = _getopt_initialize (argc, argv, optstring);
511  }
512 
513  /* Test whether ARGV[optind] points to a non-option argument.
514  Either it does not have option syntax, or there is an environment flag
515  from the shell indicating it is not an option. The later information
516  is only used when the used in the GNU libc. */
517 #ifdef _LIBC
518 #define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0' \
519  || (optind < nonoption_flags_len \
520  && __getopt_nonoption_flags[optind] == '1'))
521 #else
522 #define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')
523 #endif
524 
525  if (nextchar == NULL || *nextchar == '\0')
526  {
527  /* Advance to the next ARGV-element. */
528 
529  /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
530  moved back by the user (who may also have changed the arguments). */
531  if (last_nonopt > optind)
533  if (first_nonopt > optind)
535 
536  if (ordering == PERMUTE)
537  {
538  /* If we have just processed some options following some non-options,
539  exchange them so that the options come first. */
540 
542  exchange ((char **) argv);
543  else if (last_nonopt != optind)
545 
546  /* Skip any additional non-options
547  and extend the range of non-options previously skipped. */
548 
549  while (optind < argc && NONOPTION_P)
550  optind++;
552  }
553 
554  /* The special ARGV-element `--' means premature end of options.
555  Skip it like a null option,
556  then exchange with previous non-options as if it were an option,
557  then skip everything else like a non-option. */
558 
559  if (optind != argc && !strcmp (argv[optind], "--"))
560  {
561  optind++;
562 
564  exchange ((char **) argv);
565  else if (first_nonopt == last_nonopt)
567  last_nonopt = argc;
568 
569  optind = argc;
570  }
571 
572  /* If we have done all the ARGV-elements, stop the scan
573  and back over any non-options that we skipped and permuted. */
574 
575  if (optind == argc)
576  {
577  /* Set the next-arg-index to point at the non-options
578  that we previously skipped, so the caller will digest them. */
579  if (first_nonopt != last_nonopt)
581  return -1;
582  }
583 
584  /* If we have come to a non-option and did not permute it,
585  either stop the scan or describe it to the caller and pass it by. */
586 
587  if (NONOPTION_P)
588  {
589  if (ordering == REQUIRE_ORDER)
590  return -1;
591  optarg = argv[optind++];
592  return 1;
593  }
594 
595  /* We have found another option-ARGV-element.
596  Skip the initial punctuation. */
597 
598  nextchar = (argv[optind] + 1
599  + (longopts != NULL && argv[optind][1] == '-'));
600  }
601 
602  /* Decode the current option-ARGV-element. */
603 
604  /* Check whether the ARGV-element is a long option.
605 
606  If long_only and the ARGV-element has the form "-f", where f is
607  a valid short option, don't consider it an abbreviated form of
608  a long option that starts with f. Otherwise there would be no
609  way to give the -f short option.
610 
611  On the other hand, if there's a long option "fubar" and
612  the ARGV-element is "-fu", do consider that an abbreviation of
613  the long option, just like "--fu", and not "-f" with arg "u".
614 
615  This distinction seems to be the most useful approach. */
616 
617  if (longopts != NULL
618  && (argv[optind][1] == '-'
619  || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
620  {
621  char *nameend;
622  const struct option *p;
623  const struct option *pfound = NULL;
624  int exact = 0;
625  int ambig = 0;
626  int indfound = -1;
627  int option_index;
628 
629  for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
630  /* Do nothing. */ ;
631 
632  /* Test all long options for either exact match
633  or abbreviated matches. */
634  for (p = longopts, option_index = 0; p->name; p++, option_index++)
635  if (!strncmp (p->name, nextchar, nameend - nextchar))
636  {
637  if ((unsigned int) (nameend - nextchar)
638  == (unsigned int) strlen (p->name))
639  {
640  /* Exact match found. */
641  pfound = p;
642  indfound = option_index;
643  exact = 1;
644  break;
645  }
646  else if (pfound == NULL)
647  {
648  /* First nonexact match found. */
649  pfound = p;
650  indfound = option_index;
651  }
652  else
653  /* Second or later nonexact match found. */
654  ambig = 1;
655  }
656 
657  if (ambig && !exact)
658  {
659  if (opterr)
660  fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
661  argv[0], argv[optind]);
662  nextchar += strlen (nextchar);
663  optind++;
664  optopt = 0;
665  return '?';
666  }
667 
668  if (pfound != NULL)
669  {
670  option_index = indfound;
671  optind++;
672  if (*nameend)
673  {
674  /* Don't test has_arg with >, because some C compilers don't
675  allow it to be used on enums. */
676  if (pfound->has_arg)
677  optarg = nameend + 1;
678  else
679  {
680  if (opterr) {
681  if (argv[optind - 1][1] == '-')
682  /* --option */
683  fprintf (stderr,
684  _("%s: option `--%s' doesn't allow an argument\n"),
685  argv[0], pfound->name);
686  else
687  /* +option or -option */
688  fprintf (stderr,
689  _("%s: option `%c%s' doesn't allow an argument\n"),
690  argv[0], argv[optind - 1][0], pfound->name);
691  }
692  nextchar += strlen (nextchar);
693 
694  optopt = pfound->val;
695  return '?';
696  }
697  }
698  else if (pfound->has_arg == 1)
699  {
700  if (optind < argc)
701  optarg = argv[optind++];
702  else
703  {
704  if (opterr)
705  fprintf (stderr,
706  _("%s: option `%s' requires an argument\n"),
707  argv[0], argv[optind - 1]);
708  nextchar += strlen (nextchar);
709  optopt = pfound->val;
710  return optstring[0] == ':' ? ':' : '?';
711  }
712  }
713  nextchar += strlen (nextchar);
714  if (longind != NULL)
715  *longind = option_index;
716  if (pfound->flag)
717  {
718  *(pfound->flag) = pfound->val;
719  return 0;
720  }
721  return pfound->val;
722  }
723 
724  /* Can't find it as a long option. If this is not getopt_long_only,
725  or the option starts with '--' or is not a valid short
726  option, then it's an error.
727  Otherwise interpret it as a short option. */
728  if (!long_only || argv[optind][1] == '-'
729  || my_index (optstring, *nextchar) == NULL)
730  {
731  if (opterr)
732  {
733  if (argv[optind][1] == '-')
734  /* --option */
735  fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
736  argv[0], nextchar);
737  else
738  /* +option or -option */
739  fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
740  argv[0], argv[optind][0], nextchar);
741  }
742  nextchar = (char *) "";
743  optind++;
744  optopt = 0;
745  return '?';
746  }
747  }
748 
749  /* Look at and handle the next short option-character. */
750 
751  {
752  char c = *nextchar++;
753  char *temp = my_index (optstring, c);
754 
755  /* Increment `optind' when we start to process its last character. */
756  if (*nextchar == '\0')
757  ++optind;
758 
759  if (temp == NULL || c == ':')
760  {
761  if (opterr)
762  {
763  if (posixly_correct)
764  /* 1003.2 specifies the format of this message. */
765  fprintf (stderr, _("%s: illegal option -- %c\n"),
766  argv[0], c);
767  else
768  fprintf (stderr, _("%s: invalid option -- %c\n"),
769  argv[0], c);
770  }
771  optopt = c;
772  return '?';
773  }
774  /* Convenience. Treat POSIX -W foo same as long option --foo */
775  if (temp[0] == 'W' && temp[1] == ';')
776  {
777  char *nameend;
778  const struct option *p;
779  const struct option *pfound = NULL;
780  int exact = 0;
781  int ambig = 0;
782  int indfound = 0;
783  int option_index;
784 
785  /* This is an option that requires an argument. */
786  if (*nextchar != '\0')
787  {
788  optarg = nextchar;
789  /* If we end this ARGV-element by taking the rest as an arg,
790  we must advance to the next element now. */
791  optind++;
792  }
793  else if (optind == argc)
794  {
795  if (opterr)
796  {
797  /* 1003.2 specifies the format of this message. */
798  fprintf (stderr, _("%s: option requires an argument -- %c\n"),
799  argv[0], c);
800  }
801  optopt = c;
802  if (optstring[0] == ':')
803  c = ':';
804  else
805  c = '?';
806  return c;
807  }
808  else
809  /* We already incremented `optind' once;
810  increment it again when taking next ARGV-elt as argument. */
811  optarg = argv[optind++];
812 
813  /* optarg is now the argument, see if it's in the
814  table of longopts. */
815 
816  for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++)
817  /* Do nothing. */ ;
818 
819  /* Test all long options for either exact match
820  or abbreviated matches. */
821  for (p = longopts, option_index = 0; p->name; p++, option_index++)
822  if (!strncmp (p->name, nextchar, nameend - nextchar))
823  {
824  if ((unsigned int) (nameend - nextchar) == strlen (p->name))
825  {
826  /* Exact match found. */
827  pfound = p;
828  indfound = option_index;
829  exact = 1;
830  break;
831  }
832  else if (pfound == NULL)
833  {
834  /* First nonexact match found. */
835  pfound = p;
836  indfound = option_index;
837  }
838  else
839  /* Second or later nonexact match found. */
840  ambig = 1;
841  }
842  if (ambig && !exact)
843  {
844  if (opterr)
845  fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
846  argv[0], argv[optind]);
847  nextchar += strlen (nextchar);
848  optind++;
849  return '?';
850  }
851  if (pfound != NULL)
852  {
853  option_index = indfound;
854  if (*nameend)
855  {
856  /* Don't test has_arg with >, because some C compilers don't
857  allow it to be used on enums. */
858  if (pfound->has_arg)
859  optarg = nameend + 1;
860  else
861  {
862  if (opterr)
863  fprintf (stderr, _("\
864 %s: option `-W %s' doesn't allow an argument\n"),
865  argv[0], pfound->name);
866 
867  nextchar += strlen (nextchar);
868  return '?';
869  }
870  }
871  else if (pfound->has_arg == 1)
872  {
873  if (optind < argc)
874  optarg = argv[optind++];
875  else
876  {
877  if (opterr)
878  fprintf (stderr,
879  _("%s: option `%s' requires an argument\n"),
880  argv[0], argv[optind - 1]);
881  nextchar += strlen (nextchar);
882  return optstring[0] == ':' ? ':' : '?';
883  }
884  }
885  nextchar += strlen (nextchar);
886  if (longind != NULL)
887  *longind = option_index;
888  if (pfound->flag)
889  {
890  *(pfound->flag) = pfound->val;
891  return 0;
892  }
893  return pfound->val;
894  }
895  nextchar = NULL;
896  return 'W'; /* Let the application handle it. */
897  }
898  if (temp[1] == ':')
899  {
900  if (temp[2] == ':')
901  {
902  /* This is an option that accepts an argument optionally. */
903  if (*nextchar != '\0')
904  {
905  optarg = nextchar;
906  optind++;
907  }
908  else
909  optarg = NULL;
910  nextchar = NULL;
911  }
912  else
913  {
914  /* This is an option that requires an argument. */
915  if (*nextchar != '\0')
916  {
917  optarg = nextchar;
918  /* If we end this ARGV-element by taking the rest as an arg,
919  we must advance to the next element now. */
920  optind++;
921  }
922  else if (optind == argc)
923  {
924  if (opterr)
925  {
926  /* 1003.2 specifies the format of this message. */
927  fprintf (stderr,
928  _("%s: option requires an argument -- %c\n"),
929  argv[0], c);
930  }
931  optopt = c;
932  if (optstring[0] == ':')
933  c = ':';
934  else
935  c = '?';
936  }
937  else
938  /* We already incremented `optind' once;
939  increment it again when taking next ARGV-elt as argument. */
940  optarg = argv[optind++];
941  nextchar = NULL;
942  }
943  }
944  return c;
945  }
946 }
947 
948 int
949 getopt (int argc, char *const *argv, const char *optstring)
950 {
951  return _getopt_internal (argc, argv, optstring,
952  (const struct option *) 0,
953  (int *) 0,
954  0);
955 }
956 
957 #endif /* Not ELIDE_CODE. */
958 
959 #ifdef TEST
960 
961 /* Compile with -DTEST to make an executable for use in testing
962  the above definition of `getopt'. */
963 
964 int
965 main (int argc, char **argv)
966 {
967  int c;
968  int digit_optind = 0;
969 
970  while (1)
971  {
972  int this_option_optind = optind ? optind : 1;
973 
974  c = getopt (argc, argv, "abc:d:0123456789");
975  if (c == -1)
976  break;
977 
978  switch (c)
979  {
980  case '0':
981  case '1':
982  case '2':
983  case '3':
984  case '4':
985  case '5':
986  case '6':
987  case '7':
988  case '8':
989  case '9':
990  if (digit_optind != 0 && digit_optind != this_option_optind)
991  printf ("digits occur in two different argv-elements.\n");
992  digit_optind = this_option_optind;
993  printf ("option %c\n", c);
994  break;
995 
996  case 'a':
997  printf ("option a\n");
998  break;
999 
1000  case 'b':
1001  printf ("option b\n");
1002  break;
1003 
1004  case 'c':
1005  printf ("option c with value `%s'\n", optarg);
1006  break;
1007 
1008  case '?':
1009  break;
1010 
1011  default:
1012  printf ("?? getopt returned character code 0%o ??\n", c);
1013  }
1014  }
1015 
1016  if (optind < argc)
1017  {
1018  printf ("non-option ARGV-elements: ");
1019  while (optind < argc)
1020  printf ("%s ", argv[optind++]);
1021  printf ("\n");
1022  }
1023 
1024  exit (0);
1025 }
1026 
1027 #endif /* TEST */
nextchar
static char * nextchar
Definition: getopt.c:146
opterr
int opterr
Definition: getopt.c:151
_getopt_initialize
static const char * _getopt_initialize(int argc, char *const *argv, const char *optstring)
Definition: getopt.c:378
posixly_correct
static char * posixly_correct
Definition: getopt.c:194
getopt.h
last_nonopt
static int last_nonopt
Definition: getopt.c:238
REQUIRE_ORDER
@ REQUIRE_ORDER
Definition: getopt.c:190
exchange
static void exchange(char **argv)
Definition: getopt.c:294
PERMUTE
@ PERMUTE
Definition: getopt.c:190
NULL
#define NULL
Definition: getopt1.c:56
main
int main(int argc, char **argv)
Definition: cancat.cpp:74
ordering
static enum @12 ordering
optopt
int optopt
Definition: getopt.c:157
option::has_arg
int has_arg
Definition: getopt.h:90
getopt
int getopt(int argc, char *const *argv, const char *optstring)
Definition: getopt.c:949
SWAP_FLAGS
#define SWAP_FLAGS(ch1, ch2)
Definition: getopt.c:277
first_nonopt
static int first_nonopt
Definition: getopt.c:237
RETURN_IN_ORDER
@ RETURN_IN_ORDER
Definition: getopt.c:190
_getopt_internal
int _getopt_internal(int argc, char *const *argv, const char *optstring, const struct option *longopts, int *longind, int long_only)
Definition: getopt.c:500
NONOPTION_P
#define NONOPTION_P
option::flag
int * flag
Definition: getopt.h:91
option
Definition: getopt.h:81
__getopt_initialized
int __getopt_initialized
Definition: getopt.c:137
optind
int optind
Definition: getopt.c:131
_
#define _(msgid)
Definition: getopt.c:90
option::name
char * name
Definition: getopt.h:86
option::val
int val
Definition: getopt.h:92
optarg
char * optarg
Definition: getopt.c:116
my_index
static char * my_index(const char *str, int chr)
Definition: getopt.c:206


sdhlibrary_cpp
Author(s): Dirk Osswald
autogenerated on Wed Mar 2 2022 01:00:58