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