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 #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 {
706 if (argv[optind - 1][1] == '-')
707 /* --option */
708 fprintf (stderr,
709 _("%s: option `--%s' doesn't allow an argument\n"),
710 argv[0], pfound->name);
711 else
712 /* +option or -option */
713 fprintf (stderr,
714 _("%s: option `%c%s' doesn't allow an argument\n"),
715 argv[0], argv[optind - 1][0], pfound->name);
716 }
717
718 nextchar += strlen (nextchar);
719
720 optopt = pfound->val;
721 return '?';
722 }
723 }
724 else if (pfound->has_arg == 1)
725 {
726 if (optind < argc)
727 optarg = argv[optind++];
728 else
729 {
730 if (opterr)
731 fprintf (stderr,
732 _("%s: option `%s' requires an argument\n"),
733 argv[0], argv[optind - 1]);
734 nextchar += strlen (nextchar);
735 optopt = pfound->val;
736 return optstring[0] == ':' ? ':' : '?';
737 }
738 }
739 nextchar += strlen (nextchar);
740 if (longind != NULL)
741 *longind = option_index;
742 if (pfound->flag)
743 {
744 *(pfound->flag) = pfound->val;
745 return 0;
746 }
747 return pfound->val;
748 }
749
750 /* Can't find it as a long option. If this is not getopt_long_only,
751 or the option starts with '--' or is not a valid short
752 option, then it's an error.
753 Otherwise interpret it as a short option. */
754 if (!long_only || argv[optind][1] == '-'
755 || my_index (optstring, *nextchar) == NULL)
756 {
757 if (opterr)
758 {
759 if (argv[optind][1] == '-')
760 /* --option */
761 fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
762 argv[0], nextchar);
763 else
764 /* +option or -option */
765 fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
766 argv[0], argv[optind][0], nextchar);
767 }
768 nextchar = (char *) "";
769 optind++;
770 optopt = 0;
771 return '?';
772 }
773 }
774
775 /* Look at and handle the next short option-character. */
776
777 {
778 char c = *nextchar++;
779 char *temp = my_index (optstring, c);
780
781 /* Increment `optind' when we start to process its last character. */
782 if (*nextchar == '\0')
783 ++optind;
784
785 if (temp == NULL || c == ':')
786 {
787 if (opterr)
788 {
789 if (posixly_correct)
790 /* 1003.2 specifies the format of this message. */
791 fprintf (stderr, _("%s: illegal option -- %c\n"),
792 argv[0], c);
793 else
794 fprintf (stderr, _("%s: invalid option -- %c\n"),
795 argv[0], c);
796 }
797 optopt = c;
798 return '?';
799 }
800 /* Convenience. Treat POSIX -W foo same as long option --foo */
801 if (temp[0] == 'W' && temp[1] == ';')
802 {
803 char *nameend;
804 const struct option *p;
805 const struct option *pfound = NULL;
806 int exact = 0;
807 int ambig = 0;
808 int indfound = 0;
809 int option_index;
810
811 /* This is an option that requires an argument. */
812 if (*nextchar != '\0')
813 {
814 optarg = nextchar;
815 /* If we end this ARGV-element by taking the rest as an arg,
816 we must advance to the next element now. */
817 optind++;
818 }
819 else if (optind == argc)
820 {
821 if (opterr)
822 {
823 /* 1003.2 specifies the format of this message. */
824 fprintf (stderr, _("%s: option requires an argument -- %c\n"),
825 argv[0], c);
826 }
827 optopt = c;
828 if (optstring[0] == ':')
829 c = ':';
830 else
831 c = '?';
832 return c;
833 }
834 else
835 /* We already incremented `optind' once;
836 increment it again when taking next ARGV-elt as argument. */
837 optarg = argv[optind++];
838
839 /* optarg is now the argument, see if it's in the
840 table of longopts. */
841
842 for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++)
843 /* Do nothing. */ ;
844
845 /* Test all long options for either exact match
846 or abbreviated matches. */
847 for (p = longopts, option_index = 0; p->name; p++, option_index++)
848 if (!strncmp (p->name, nextchar, nameend - nextchar))
849 {
850 if ((unsigned int) (nameend - nextchar) == strlen (p->name))
851 {
852 /* Exact match found. */
853 pfound = p;
854 indfound = option_index;
855 exact = 1;
856 break;
857 }
858 else if (pfound == NULL)
859 {
860 /* First nonexact match found. */
861 pfound = p;
862 indfound = option_index;
863 }
864 else
865 /* Second or later nonexact match found. */
866 ambig = 1;
867 }
868 if (ambig && !exact)
869 {
870 if (opterr)
871 fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
872 argv[0], argv[optind]);
873 nextchar += strlen (nextchar);
874 optind++;
875 return '?';
876 }
877 if (pfound != NULL)
878 {
879 option_index = indfound;
880 if (*nameend)
881 {
882 /* Don't test has_arg with >, because some C compilers don't
883 allow it to be used on enums. */
884 if (pfound->has_arg)
885 optarg = nameend + 1;
886 else
887 {
888 if (opterr)
889 fprintf (stderr, _("\
890 %s: option `-W %s' doesn't allow an argument\n"),
891 argv[0], pfound->name);
892
893 nextchar += strlen (nextchar);
894 return '?';
895 }
896 }
897 else if (pfound->has_arg == 1)
898 {
899 if (optind < argc)
900 optarg = argv[optind++];
901 else
902 {
903 if (opterr)
904 fprintf (stderr,
905 _("%s: option `%s' requires an argument\n"),
906 argv[0], argv[optind - 1]);
907 nextchar += strlen (nextchar);
908 return optstring[0] == ':' ? ':' : '?';
909 }
910 }
911 nextchar += strlen (nextchar);
912 if (longind != NULL)
913 *longind = option_index;
914 if (pfound->flag)
915 {
916 *(pfound->flag) = pfound->val;
917 return 0;
918 }
919 return pfound->val;
920 }
921 nextchar = NULL;
922 return 'W'; /* Let the application handle it. */
923 }
924 if (temp[1] == ':')
925 {
926 if (temp[2] == ':')
927 {
928 /* This is an option that accepts an argument optionally. */
929 if (*nextchar != '\0')
930 {
931 optarg = nextchar;
932 optind++;
933 }
934 else
935 optarg = NULL;
936 nextchar = NULL;
937 }
938 else
939 {
940 /* This is an option that requires an argument. */
941 if (*nextchar != '\0')
942 {
943 optarg = nextchar;
944 /* If we end this ARGV-element by taking the rest as an arg,
945 we must advance to the next element now. */
946 optind++;
947 }
948 else if (optind == argc)
949 {
950 if (opterr)
951 {
952 /* 1003.2 specifies the format of this message. */
953 fprintf (stderr,
954 _("%s: option requires an argument -- %c\n"),
955 argv[0], c);
956 }
957 optopt = c;
958 if (optstring[0] == ':')
959 c = ':';
960 else
961 c = '?';
962 }
963 else
964 /* We already incremented `optind' once;
965 increment it again when taking next ARGV-elt as argument. */
966 optarg = argv[optind++];
967 nextchar = NULL;
968 }
969 }
970 return c;
971 }
972 }
973
974 int
getopt(argc,argv,optstring)975 getopt (argc, argv, optstring)
976 int argc;
977 char *const *argv;
978 const char *optstring;
979 {
980 return _getopt_internal (argc, argv, optstring,
981 (const struct option *) 0,
982 (int *) 0,
983 0);
984 }
985
986 #endif /* Not ELIDE_CODE. */
987 #endif /* Not HAVE_GETOPT_LONG. */
988
989 #ifdef TEST
990
991 /* Compile with -DTEST to make an executable for use in testing
992 the above definition of `getopt'. */
993
994 int
main(argc,argv)995 main (argc, argv)
996 int argc;
997 char **argv;
998 {
999 int c;
1000 int digit_optind = 0;
1001
1002 while (1)
1003 {
1004 int this_option_optind = optind ? optind : 1;
1005
1006 c = getopt (argc, argv, "abc:d:0123456789");
1007 if (c == -1)
1008 break;
1009
1010 switch (c)
1011 {
1012 case '0':
1013 case '1':
1014 case '2':
1015 case '3':
1016 case '4':
1017 case '5':
1018 case '6':
1019 case '7':
1020 case '8':
1021 case '9':
1022 if (digit_optind != 0 && digit_optind != this_option_optind)
1023 printf ("digits occur in two different argv-elements.\n");
1024 digit_optind = this_option_optind;
1025 printf ("option %c\n", c);
1026 break;
1027
1028 case 'a':
1029 printf ("option a\n");
1030 break;
1031
1032 case 'b':
1033 printf ("option b\n");
1034 break;
1035
1036 case 'c':
1037 printf ("option c with value `%s'\n", optarg);
1038 break;
1039
1040 case '?':
1041 break;
1042
1043 default:
1044 printf ("?? getopt returned character code 0%o ??\n", c);
1045 }
1046 }
1047
1048 if (optind < argc)
1049 {
1050 printf ("non-option ARGV-elements: ");
1051 while (optind < argc)
1052 printf ("%s ", argv[optind++]);
1053 printf ("\n");
1054 }
1055
1056 exit (0);
1057 }
1058
1059 #endif /* TEST */
1060