1 /* Getopt for GNU.
2 NOTE: getopt is now part of the C library, so if you don't know what
3 "Keep this file name-space clean" means, talk to drepper@gnu.org
4 before changing it!
5 Copyright (C) 1987,88,89,90,91,92,93,94,95,96,98,99,2000,2001
6 Free Software Foundation, Inc.
7 This file is part of the GNU C Library.
8
9 The GNU C Library is free software; you can redistribute it and/or
10 modify it under the terms of the GNU Lesser General Public
11 License as published by the Free Software Foundation; either
12 version 2.1 of the License, or (at your option) any later version.
13
14 The GNU C Library is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 Lesser General Public License for more details.
18
19 You should have received a copy of the GNU Lesser General Public
20 License along with the GNU C Library; if not, write to the Free
21 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
22 02111-1307 USA. */
23
24 /* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
25 Ditto for AIX 3.2 and <stdlib.h>. */
26 #ifndef _NO_PROTO
27 # define _NO_PROTO
28 #endif
29
30 #ifdef HAVE_CONFIG_H
31 # include <config.h>
32 #endif
33
34 #if !defined __STDC__ || !__STDC__
35 /* This is a separate conditional since some stdc systems
36 reject `defined (const)'. */
37 # ifndef const
38 # define const
39 # endif
40 #endif
41
42 #include <stdio.h>
43
44 /* Comment out all this code if we are using the GNU C Library, and are not
45 actually compiling the library itself. This code is part of the GNU C
46 Library, but also included in many other GNU distributions. Compiling
47 and linking in this code is a waste when using the GNU C library
48 (especially if it is a shared library). Rather than having every GNU
49 program understand `configure --with-gnu-libc' and omit the object files,
50 it is simpler to just do this in the source for each such file. */
51
52 #define GETOPT_INTERFACE_VERSION 2
53 #if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2
54 # include <gnu-versions.h>
55 # if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
56 # define ELIDE_CODE
57 # endif
58 #endif
59
60 #ifndef ELIDE_CODE
61
62
63 /* This needs to come after some library #include
64 to get __GNU_LIBRARY__ defined. */
65 #ifdef __GNU_LIBRARY__
66 /* Don't include stdlib.h for non-GNU C libraries because some of them
67 contain conflicting prototypes for getopt. */
68 # include <stdlib.h>
69 # include <unistd.h>
70 #endif /* GNU C library. */
71
72 #ifdef VMS
73 # include <unixlib.h>
74 # if HAVE_STRING_H - 0
75 # include <string.h>
76 # endif
77 #endif
78
79 #ifndef _
80 /* This is for other GNU distributions with internationalized messages. */
81 # if (HAVE_LIBINTL_H && ENABLE_NLS) || defined _LIBC
82 # include <libintl.h>
83 # ifndef _
84 # define _(msgid) gettext (msgid)
85 # endif
86 # else
87 # define _(msgid) (msgid)
88 # endif
89 # if defined _LIBC && defined USE_IN_LIBIO
90 # include <wchar.h>
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 "wgetopt.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;
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
137 int __getopt_initialized;
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 {
190 REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
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 #define HAVE_STRING_H 1
206 # if HAVE_STRING_H
207 # include <string.h>
208 # else
209 # include <strings.h>
210 # endif
211
212 /* Avoid depending on library functions or files
213 whose names are inconsistent. */
214
215 #ifndef getenv
216 extern char *getenv();
217 #endif
218
219 static char *
my_index(str,chr)220 my_index(str, chr)
221 const char *str;
222 int chr;
223 {
224 while (*str)
225 {
226 if (*str == chr)
227 return (char *)str;
228 str++;
229 }
230 return 0;
231 }
232
233 /* If using GCC, we can safely declare strlen this way.
234 If not using GCC, it is ok not to declare it. */
235 #ifdef __GNUC__
236 /* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
237 That was relevant to code that was here before. */
238 # if (!defined __STDC__ || !__STDC__) && !defined strlen
239 /* gcc with -traditional declares the built-in strlen to return int,
240 and has done so at least since version 2.4.5. -- rms. */
241 extern int strlen(const char *);
242 # endif /* not __STDC__ */
243 #endif /* __GNUC__ */
244
245 #endif /* not __GNU_LIBRARY__ */
246
247 /* Handle permutation of arguments. */
248
249 /* Describe the part of ARGV that contains non-options that have
250 been skipped. `first_nonopt' is the index in ARGV of the first of them;
251 `last_nonopt' is the index after the last of them. */
252
253 static int first_nonopt;
254 static int last_nonopt;
255
256 #ifdef _LIBC
257 /* Stored original parameters.
258 XXX This is no good solution. We should rather copy the args so
259 that we can compare them later. But we must not use malloc(3). */
260 extern int __libc_argc;
261 extern char **__libc_argv;
262
263 /* Bash 2.0 gives us an environment variable containing flags
264 indicating ARGV elements that should not be considered arguments. */
265
266 # ifdef USE_NONOPTION_FLAGS
267 /* Defined in getopt_init.c */
268 extern char *__getopt_nonoption_flags;
269
270 static int nonoption_flags_max_len;
271 static int nonoption_flags_len;
272 # endif
273
274 # ifdef USE_NONOPTION_FLAGS
275 # define SWAP_FLAGS(ch1, ch2) \
276 if (nonoption_flags_len > 0) \
277 { \
278 char __tmp = __getopt_nonoption_flags[ch1]; \
279 __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2]; \
280 __getopt_nonoption_flags[ch2] = __tmp; \
281 }
282 # else
283 # define SWAP_FLAGS(ch1, ch2)
284 # endif
285 #else /* !_LIBC */
286 # define SWAP_FLAGS(ch1, ch2)
287 #endif /* _LIBC */
288
289 /* Exchange two adjacent subsequences of ARGV.
290 One subsequence is elements [first_nonopt,last_nonopt)
291 which contains all the non-options that have been skipped so far.
292 The other is elements [last_nonopt,optind), which contains all
293 the options processed since those non-options were skipped.
294
295 `first_nonopt' and `last_nonopt' are relocated so that they describe
296 the new indices of the non-options in ARGV after they are moved. */
297
298 #if defined __STDC__ && __STDC__
299 static void exchange(char **);
300 #endif
301
302 static void
exchange(argv)303 exchange(argv)
304 char **argv;
305 {
306 int bottom = first_nonopt;
307 int middle = last_nonopt;
308 int top = optind;
309 char *tem;
310
311 /* Exchange the shorter segment with the far end of the longer segment.
312 That puts the shorter segment into the right place.
313 It leaves the longer segment in the right place overall,
314 but it consists of two parts that need to be swapped next. */
315
316 #if defined _LIBC && defined USE_NONOPTION_FLAGS
317 /* First make sure the handling of the `__getopt_nonoption_flags'
318 string can work normally. Our top argument must be in the range
319 of the string. */
320 if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len)
321 {
322 /* We must extend the array. The user plays games with us and
323 presents new arguments. */
324 char *new_str = malloc(top + 1);
325 if (new_str == NULL)
326 nonoption_flags_len = nonoption_flags_max_len = 0;
327 else
328 {
329 memset(__mempcpy(new_str, __getopt_nonoption_flags,
330 nonoption_flags_max_len),
331 '\0', top + 1 - nonoption_flags_max_len);
332 nonoption_flags_max_len = top + 1;
333 __getopt_nonoption_flags = new_str;
334 }
335 }
336 #endif
337
338 while (top > middle && middle > bottom)
339 {
340 if (top - middle > middle - bottom)
341 {
342 /* Bottom segment is the short one. */
343 int len = middle - bottom;
344 register int i;
345
346 /* Swap it with the top part of the top segment. */
347 for (i = 0; i < len; i++)
348 {
349 tem = argv[bottom + i];
350 argv[bottom + i] = argv[top - (middle - bottom) + i];
351 argv[top - (middle - bottom) + i] = tem;
352 SWAP_FLAGS(bottom + i, top - (middle - bottom) + i);
353 }
354 /* Exclude the moved bottom segment from further swapping. */
355 top -= len;
356 }
357 else
358 {
359 /* Top segment is the short one. */
360 int len = top - middle;
361 register int i;
362
363 /* Swap it with the bottom part of the bottom segment. */
364 for (i = 0; i < len; i++)
365 {
366 tem = argv[bottom + i];
367 argv[bottom + i] = argv[middle + i];
368 argv[middle + i] = tem;
369 SWAP_FLAGS(bottom + i, middle + i);
370 }
371 /* Exclude the moved top segment from further swapping. */
372 bottom += len;
373 }
374 }
375
376 /* Update records for the slots the non-options now occupy. */
377
378 first_nonopt += (optind - last_nonopt);
379 last_nonopt = optind;
380 }
381
382 /* Initialize the internal data when the first call is made. */
383
384 #if defined __STDC__ && __STDC__
385 static const char *_getopt_initialize(int, char *const *, const char *);
386 #endif
387 static const char *
_getopt_initialize(argc,argv,optstring)388 _getopt_initialize(argc, argv, optstring)
389 int argc;
390 char *const *argv;
391 const char *optstring;
392 {
393 /* Start processing options with ARGV-element 1 (since ARGV-element 0
394 is the program name); the sequence of previously skipped
395 non-option ARGV-elements is empty. */
396
397 first_nonopt = last_nonopt = optind;
398
399 nextchar = NULL;
400
401 posixly_correct = getenv("POSIXLY_CORRECT");
402
403 /* Determine how to handle the ordering of options and nonoptions. */
404
405 if (optstring[0] == '-')
406 {
407 ordering = RETURN_IN_ORDER;
408 ++optstring;
409 }
410 else if (optstring[0] == '+')
411 {
412 ordering = REQUIRE_ORDER;
413 ++optstring;
414 }
415 else if (posixly_correct != NULL)
416 ordering = REQUIRE_ORDER;
417 else
418 ordering = PERMUTE;
419
420 #if defined _LIBC && defined USE_NONOPTION_FLAGS
421 if (posixly_correct == NULL
422 && argc == __libc_argc && argv == __libc_argv)
423 {
424 if (nonoption_flags_max_len == 0)
425 {
426 if (__getopt_nonoption_flags == NULL
427 || __getopt_nonoption_flags[0] == '\0')
428 nonoption_flags_max_len = -1;
429 else
430 {
431 const char *orig_str = __getopt_nonoption_flags;
432 int len = nonoption_flags_max_len = strlen(orig_str);
433 if (nonoption_flags_max_len < argc)
434 nonoption_flags_max_len = argc;
435 __getopt_nonoption_flags =
436 (char *)malloc(nonoption_flags_max_len);
437 if (__getopt_nonoption_flags == NULL)
438 nonoption_flags_max_len = -1;
439 else
440 memset(__mempcpy(__getopt_nonoption_flags, orig_str, len),
441 '\0', nonoption_flags_max_len - len);
442 }
443 }
444 nonoption_flags_len = nonoption_flags_max_len;
445 }
446 else
447 nonoption_flags_len = 0;
448 #endif
449
450 return optstring;
451 }
452
453 /* Scan elements of ARGV (whose length is ARGC) for option characters
454 given in OPTSTRING.
455
456 If an element of ARGV starts with '-', and is not exactly "-" or "--",
457 then it is an option element. The characters of this element
458 (aside from the initial '-') are option characters. If `getopt'
459 is called repeatedly, it returns successively each of the option characters
460 from each of the option elements.
461
462 If `getopt' finds another option character, it returns that character,
463 updating `optind' and `nextchar' so that the next call to `getopt' can
464 resume the scan with the following option character or ARGV-element.
465
466 If there are no more option characters, `getopt' returns -1.
467 Then `optind' is the index in ARGV of the first ARGV-element
468 that is not an option. (The ARGV-elements have been permuted
469 so that those that are not options now come last.)
470
471 OPTSTRING is a string containing the legitimate option characters.
472 If an option character is seen that is not listed in OPTSTRING,
473 return '?' after printing an error message. If you set `opterr' to
474 zero, the error message is suppressed but we still return '?'.
475
476 If a char in OPTSTRING is followed by a colon, that means it wants an arg,
477 so the following text in the same ARGV-element, or the text of the following
478 ARGV-element, is returned in `optarg'. Two colons mean an option that
479 wants an optional arg; if there is text in the current ARGV-element,
480 it is returned in `optarg', otherwise `optarg' is set to zero.
481
482 If OPTSTRING starts with `-' or `+', it requests different methods of
483 handling the non-option ARGV-elements.
484 See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
485
486 Long-named options begin with `--' instead of `-'.
487 Their names may be abbreviated as long as the abbreviation is unique
488 or is an exact match for some defined option. If they have an
489 argument, it follows the option name in the same ARGV-element, separated
490 from the option name by a `=', or else the in next ARGV-element.
491 When `getopt' finds a long-named option, it returns 0 if that option's
492 `flag' field is nonzero, the value of the option's `val' field
493 if the `flag' field is zero.
494
495 The elements of ARGV aren't really const, because we permute them.
496 But we pretend they're const in the prototype to be compatible
497 with other systems.
498
499 LONGOPTS is a vector of `struct option' terminated by an
500 element containing a name which is zero.
501
502 LONGIND returns the index in LONGOPT of the long-named option found.
503 It is only valid when a long-named option has been found by the most
504 recent call.
505
506 If LONG_ONLY is nonzero, '-' as well as '--' can introduce
507 long-named options. */
508
509 int
_getopt_internal(argc,argv,optstring,longopts,longind,long_only)510 _getopt_internal(argc, argv, optstring, longopts, longind, long_only)
511 int argc;
512 char *const *argv;
513 const char *optstring;
514 const struct option *longopts;
515 int *longind;
516 int long_only;
517 {
518 int print_errors = opterr;
519 if (optstring[0] == ':')
520 print_errors = 0;
521
522 if (argc < 1)
523 return -1;
524
525 optarg = NULL;
526
527 if (optind == 0 || !__getopt_initialized)
528 {
529 if (optind == 0)
530 optind = 1; /* Don't scan ARGV[0], the program name. */
531 optstring = _getopt_initialize(argc, argv, optstring);
532 __getopt_initialized = 1;
533 }
534
535 /* Test whether ARGV[optind] points to a non-option argument.
536 Either it does not have option syntax, or there is an environment flag
537 from the shell indicating it is not an option. The later information
538 is only used when the used in the GNU libc. */
539 #if defined _LIBC && defined USE_NONOPTION_FLAGS
540 # define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0' \
541 || (optind < nonoption_flags_len \
542 && __getopt_nonoption_flags[optind] == '1'))
543 #else
544 # define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')
545 #endif
546
547 if (nextchar == NULL || *nextchar == '\0')
548 {
549 /* Advance to the next ARGV-element. */
550
551 /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
552 moved back by the user (who may also have changed the arguments). */
553 if (last_nonopt > optind)
554 last_nonopt = optind;
555 if (first_nonopt > optind)
556 first_nonopt = optind;
557
558 if (ordering == PERMUTE)
559 {
560 /* If we have just processed some options following some non-options,
561 exchange them so that the options come first. */
562
563 if (first_nonopt != last_nonopt && last_nonopt != optind)
564 exchange((char **)argv);
565 else if (last_nonopt != optind)
566 first_nonopt = optind;
567
568 /* Skip any additional non-options
569 and extend the range of non-options previously skipped. */
570
571 while (optind < argc && NONOPTION_P)
572 optind++;
573 last_nonopt = optind;
574 }
575
576 /* The special ARGV-element `--' means premature end of options.
577 Skip it like a null option,
578 then exchange with previous non-options as if it were an option,
579 then skip everything else like a non-option. */
580
581 if (optind != argc && !strcmp(argv[optind], "--"))
582 {
583 optind++;
584
585 if (first_nonopt != last_nonopt && last_nonopt != optind)
586 exchange((char **)argv);
587 else if (first_nonopt == last_nonopt)
588 first_nonopt = optind;
589 last_nonopt = argc;
590
591 optind = argc;
592 }
593
594 /* If we have done all the ARGV-elements, stop the scan
595 and back over any non-options that we skipped and permuted. */
596
597 if (optind == argc)
598 {
599 /* Set the next-arg-index to point at the non-options
600 that we previously skipped, so the caller will digest them. */
601 if (first_nonopt != last_nonopt)
602 optind = first_nonopt;
603 return -1;
604 }
605
606 /* If we have come to a non-option and did not permute it,
607 either stop the scan or describe it to the caller and pass it by. */
608
609 if (NONOPTION_P)
610 {
611 if (ordering == REQUIRE_ORDER)
612 return -1;
613 optarg = argv[optind++];
614 return 1;
615 }
616
617 /* We have found another option-ARGV-element.
618 Skip the initial punctuation. */
619
620 nextchar = (argv[optind] + 1
621 + (longopts != NULL && argv[optind][1] == '-'));
622 }
623
624 /* Decode the current option-ARGV-element. */
625
626 /* Check whether the ARGV-element is a long option.
627
628 If long_only and the ARGV-element has the form "-f", where f is
629 a valid short option, don't consider it an abbreviated form of
630 a long option that starts with f. Otherwise there would be no
631 way to give the -f short option.
632
633 On the other hand, if there's a long option "fubar" and
634 the ARGV-element is "-fu", do consider that an abbreviation of
635 the long option, just like "--fu", and not "-f" with arg "u".
636
637 This distinction seems to be the most useful approach. */
638
639 if (longopts != NULL
640 && (argv[optind][1] == '-'
641 || (long_only && (argv[optind][2] || !my_index(optstring, argv[optind][1])))))
642 {
643 char *nameend;
644 const struct option *p;
645 const struct option *pfound = NULL;
646 int exact = 0;
647 int ambig = 0;
648 int indfound = -1;
649 int option_index;
650
651 for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
652 /* Do nothing. */;
653
654 /* Test all long options for either exact match
655 or abbreviated matches. */
656 for (p = longopts, option_index = 0; p->name; p++, option_index++)
657 if (!strncmp(p->name, nextchar, nameend - nextchar))
658 {
659 if ((unsigned int)(nameend - nextchar)
660 == (unsigned int)strlen(p->name))
661 {
662 /* Exact match found. */
663 pfound = p;
664 indfound = option_index;
665 exact = 1;
666 break;
667 }
668 else if (pfound == NULL)
669 {
670 /* First nonexact match found. */
671 pfound = p;
672 indfound = option_index;
673 }
674 else if (long_only
675 || pfound->has_arg != p->has_arg
676 || pfound->flag != p->flag
677 || pfound->val != p->val)
678 /* Second or later nonexact match found. */
679 ambig = 1;
680 }
681
682 if (ambig && !exact)
683 {
684 if (print_errors)
685 {
686 #if defined _LIBC && defined USE_IN_LIBIO
687 char *buf;
688
689 __asprintf(&buf, _("%s: option `%s' is ambiguous\n"),
690 argv[0], argv[optind]);
691
692 if (_IO_fwide(stderr, 0) > 0)
693 __fwprintf(stderr, L"%s", buf);
694 else
695 fputs(buf, stderr);
696
697 free(buf);
698 #else
699 fprintf(stderr, _("%s: option `%s' is ambiguous\n"),
700 argv[0], argv[optind]);
701 #endif
702 }
703 nextchar += strlen(nextchar);
704 optind++;
705 optopt = 0;
706 return '?';
707 }
708
709 if (pfound != NULL)
710 {
711 option_index = indfound;
712 optind++;
713 if (*nameend)
714 {
715 /* Don't test has_arg with >, because some C compilers don't
716 allow it to be used on enums. */
717 if (pfound->has_arg)
718 optarg = nameend + 1;
719 else
720 {
721 if (print_errors)
722 {
723 #if defined _LIBC && defined USE_IN_LIBIO
724 char *buf;
725 #endif
726
727 if (argv[optind - 1][1] == '-')
728 {
729 /* --option */
730 #if defined _LIBC && defined USE_IN_LIBIO
731 __asprintf(&buf, _("\
732 %s: option `--%s' doesn't allow an argument\n"),
733 argv[0], pfound->name);
734 #else
735 fprintf(stderr, _("\
736 %s: option `--%s' doesn't allow an argument\n"),
737 argv[0], pfound->name);
738 #endif
739 }
740 else
741 {
742 /* +option or -option */
743 #if defined _LIBC && defined USE_IN_LIBIO
744 __asprintf(&buf, _("\
745 %s: option `%c%s' doesn't allow an argument\n"),
746 argv[0], argv[optind - 1][0],
747 pfound->name);
748 #else
749 fprintf(stderr, _("\
750 %s: option `%c%s' doesn't allow an argument\n"),
751 argv[0], argv[optind - 1][0], pfound->name);
752 #endif
753 }
754
755 #if defined _LIBC && defined USE_IN_LIBIO
756 if (_IO_fwide(stderr, 0) > 0)
757 __fwprintf(stderr, L"%s", buf);
758 else
759 fputs(buf, stderr);
760
761 free(buf);
762 #endif
763 }
764
765 nextchar += strlen(nextchar);
766
767 optopt = pfound->val;
768 return '?';
769 }
770 }
771 else if (pfound->has_arg == 1)
772 {
773 if (optind < argc)
774 optarg = argv[optind++];
775 else
776 {
777 if (print_errors)
778 {
779 #if defined _LIBC && defined USE_IN_LIBIO
780 char *buf;
781
782 __asprintf(&buf,
783 _("%s: option `%s' requires an argument\n"),
784 argv[0], argv[optind - 1]);
785
786 if (_IO_fwide(stderr, 0) > 0)
787 __fwprintf(stderr, L"%s", buf);
788 else
789 fputs(buf, stderr);
790
791 free(buf);
792 #else
793 fprintf(stderr,
794 _("%s: option `%s' requires an argument\n"),
795 argv[0], argv[optind - 1]);
796 #endif
797 }
798 nextchar += strlen(nextchar);
799 optopt = pfound->val;
800 return optstring[0] == ':' ? ':' : '?';
801 }
802 }
803 nextchar += strlen(nextchar);
804 if (longind != NULL)
805 *longind = option_index;
806 if (pfound->flag)
807 {
808 *(pfound->flag) = pfound->val;
809 return 0;
810 }
811 return pfound->val;
812 }
813
814 /* Can't find it as a long option. If this is not getopt_long_only,
815 or the option starts with '--' or is not a valid short
816 option, then it's an error.
817 Otherwise interpret it as a short option. */
818 if (!long_only || argv[optind][1] == '-'
819 || my_index(optstring, *nextchar) == NULL)
820 {
821 if (print_errors)
822 {
823 #if defined _LIBC && defined USE_IN_LIBIO
824 char *buf;
825 #endif
826
827 if (argv[optind][1] == '-')
828 {
829 /* --option */
830 #if defined _LIBC && defined USE_IN_LIBIO
831 __asprintf(&buf, _("%s: unrecognized option `--%s'\n"),
832 argv[0], nextchar);
833 #else
834 fprintf(stderr, _("%s: unrecognized option `--%s'\n"),
835 argv[0], nextchar);
836 #endif
837 }
838 else
839 {
840 /* +option or -option */
841 #if defined _LIBC && defined USE_IN_LIBIO
842 __asprintf(&buf, _("%s: unrecognized option `%c%s'\n"),
843 argv[0], argv[optind][0], nextchar);
844 #else
845 fprintf(stderr, _("%s: unrecognized option `%c%s'\n"),
846 argv[0], argv[optind][0], nextchar);
847 #endif
848 }
849
850 #if defined _LIBC && defined USE_IN_LIBIO
851 if (_IO_fwide(stderr, 0) > 0)
852 __fwprintf(stderr, L"%s", buf);
853 else
854 fputs(buf, stderr);
855
856 free(buf);
857 #endif
858 }
859 nextchar = (char *) "";
860 optind++;
861 optopt = 0;
862 return '?';
863 }
864 }
865
866 /* Look at and handle the next short option-character. */
867
868 {
869 char c = *nextchar++;
870 char *temp = my_index(optstring, c);
871
872 /* Increment `optind' when we start to process its last character. */
873 if (*nextchar == '\0')
874 ++optind;
875
876 if (temp == NULL || c == ':')
877 {
878 if (print_errors)
879 {
880 #if defined _LIBC && defined USE_IN_LIBIO
881 char *buf;
882 #endif
883
884 if (posixly_correct)
885 {
886 /* 1003.2 specifies the format of this message. */
887 #if defined _LIBC && defined USE_IN_LIBIO
888 __asprintf(&buf, _("%s: illegal option -- %c\n"),
889 argv[0], c);
890 #else
891 fprintf(stderr, _("%s: illegal option -- %c\n"), argv[0], c);
892 #endif
893 }
894 else
895 {
896 #if defined _LIBC && defined USE_IN_LIBIO
897 __asprintf(&buf, _("%s: invalid option -- %c\n"),
898 argv[0], c);
899 #else
900 fprintf(stderr, _("%s: invalid option -- %c\n"), argv[0], c);
901 #endif
902 }
903
904 #if defined _LIBC && defined USE_IN_LIBIO
905 if (_IO_fwide(stderr, 0) > 0)
906 __fwprintf(stderr, L"%s", buf);
907 else
908 fputs(buf, stderr);
909
910 free(buf);
911 #endif
912 }
913 optopt = c;
914 return '?';
915 }
916 /* Convenience. Treat POSIX -W foo same as long option --foo */
917 if (temp[0] == 'W' && temp[1] == ';')
918 {
919 char *nameend;
920 const struct option *p;
921 const struct option *pfound = NULL;
922 int exact = 0;
923 int ambig = 0;
924 int indfound = 0;
925 int option_index;
926
927 /* This is an option that requires an argument. */
928 if (*nextchar != '\0')
929 {
930 optarg = nextchar;
931 /* If we end this ARGV-element by taking the rest as an arg,
932 we must advance to the next element now. */
933 optind++;
934 }
935 else if (optind == argc)
936 {
937 if (print_errors)
938 {
939 /* 1003.2 specifies the format of this message. */
940 #if defined _LIBC && defined USE_IN_LIBIO
941 char *buf;
942
943 __asprintf(&buf, _("%s: option requires an argument -- %c\n"),
944 argv[0], c);
945
946 if (_IO_fwide(stderr, 0) > 0)
947 __fwprintf(stderr, L"%s", buf);
948 else
949 fputs(buf, stderr);
950
951 free(buf);
952 #else
953 fprintf(stderr, _("%s: option requires an argument -- %c\n"),
954 argv[0], c);
955 #endif
956 }
957 optopt = c;
958 if (optstring[0] == ':')
959 c = ':';
960 else
961 c = '?';
962 return c;
963 }
964 else
965 /* We already incremented `optind' once;
966 increment it again when taking next ARGV-elt as argument. */
967 optarg = argv[optind++];
968
969 /* optarg is now the argument, see if it's in the
970 table of longopts. */
971
972 for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++)
973 /* Do nothing. */;
974
975 /* Test all long options for either exact match
976 or abbreviated matches. */
977 for (p = longopts, option_index = 0; p->name; p++, option_index++)
978 if (!strncmp(p->name, nextchar, nameend - nextchar))
979 {
980 if ((unsigned int)(nameend - nextchar) == strlen(p->name))
981 {
982 /* Exact match found. */
983 pfound = p;
984 indfound = option_index;
985 exact = 1;
986 break;
987 }
988 else if (pfound == NULL)
989 {
990 /* First nonexact match found. */
991 pfound = p;
992 indfound = option_index;
993 }
994 else
995 /* Second or later nonexact match found. */
996 ambig = 1;
997 }
998 if (ambig && !exact)
999 {
1000 if (print_errors)
1001 {
1002 #if defined _LIBC && defined USE_IN_LIBIO
1003 char *buf;
1004
1005 __asprintf(&buf, _("%s: option `-W %s' is ambiguous\n"),
1006 argv[0], argv[optind]);
1007
1008 if (_IO_fwide(stderr, 0) > 0)
1009 __fwprintf(stderr, L"%s", buf);
1010 else
1011 fputs(buf, stderr);
1012
1013 free(buf);
1014 #else
1015 fprintf(stderr, _("%s: option `-W %s' is ambiguous\n"),
1016 argv[0], argv[optind]);
1017 #endif
1018 }
1019 nextchar += strlen(nextchar);
1020 optind++;
1021 return '?';
1022 }
1023 if (pfound != NULL)
1024 {
1025 option_index = indfound;
1026 if (*nameend)
1027 {
1028 /* Don't test has_arg with >, because some C compilers don't
1029 allow it to be used on enums. */
1030 if (pfound->has_arg)
1031 optarg = nameend + 1;
1032 else
1033 {
1034 if (print_errors)
1035 {
1036 #if defined _LIBC && defined USE_IN_LIBIO
1037 char *buf;
1038
1039 __asprintf(&buf, _("\
1040 %s: option `-W %s' doesn't allow an argument\n"),
1041 argv[0], pfound->name);
1042
1043 if (_IO_fwide(stderr, 0) > 0)
1044 __fwprintf(stderr, L"%s", buf);
1045 else
1046 fputs(buf, stderr);
1047
1048 free(buf);
1049 #else
1050 fprintf(stderr, _("\
1051 %s: option `-W %s' doesn't allow an argument\n"),
1052 argv[0], pfound->name);
1053 #endif
1054 }
1055
1056 nextchar += strlen(nextchar);
1057 return '?';
1058 }
1059 }
1060 else if (pfound->has_arg == 1)
1061 {
1062 if (optind < argc)
1063 optarg = argv[optind++];
1064 else
1065 {
1066 if (print_errors)
1067 {
1068 #if defined _LIBC && defined USE_IN_LIBIO
1069 char *buf;
1070
1071 __asprintf(&buf, _("\
1072 %s: option `%s' requires an argument\n"),
1073 argv[0], argv[optind - 1]);
1074
1075 if (_IO_fwide(stderr, 0) > 0)
1076 __fwprintf(stderr, L"%s", buf);
1077 else
1078 fputs(buf, stderr);
1079
1080 free(buf);
1081 #else
1082 fprintf(stderr,
1083 _("%s: option `%s' requires an argument\n"),
1084 argv[0], argv[optind - 1]);
1085 #endif
1086 }
1087 nextchar += strlen(nextchar);
1088 return optstring[0] == ':' ? ':' : '?';
1089 }
1090 }
1091 nextchar += strlen(nextchar);
1092 if (longind != NULL)
1093 *longind = option_index;
1094 if (pfound->flag)
1095 {
1096 *(pfound->flag) = pfound->val;
1097 return 0;
1098 }
1099 return pfound->val;
1100 }
1101 nextchar = NULL;
1102 return 'W'; /* Let the application handle it. */
1103 }
1104 if (temp[1] == ':')
1105 {
1106 if (temp[2] == ':')
1107 {
1108 /* This is an option that accepts an argument optionally. */
1109 if (*nextchar != '\0')
1110 {
1111 optarg = nextchar;
1112 optind++;
1113 }
1114 else
1115 optarg = NULL;
1116 nextchar = NULL;
1117 }
1118 else
1119 {
1120 /* This is an option that requires an argument. */
1121 if (*nextchar != '\0')
1122 {
1123 optarg = nextchar;
1124 /* If we end this ARGV-element by taking the rest as an arg,
1125 we must advance to the next element now. */
1126 optind++;
1127 }
1128 else if (optind == argc)
1129 {
1130 if (print_errors)
1131 {
1132 /* 1003.2 specifies the format of this message. */
1133 #if defined _LIBC && defined USE_IN_LIBIO
1134 char *buf;
1135
1136 __asprintf(&buf,
1137 _("%s: option requires an argument -- %c\n"),
1138 argv[0], c);
1139
1140 if (_IO_fwide(stderr, 0) > 0)
1141 __fwprintf(stderr, L"%s", buf);
1142 else
1143 fputs(buf, stderr);
1144
1145 free(buf);
1146 #else
1147 fprintf(stderr,
1148 _("%s: option requires an argument -- %c\n"),
1149 argv[0], c);
1150 #endif
1151 }
1152 optopt = c;
1153 if (optstring[0] == ':')
1154 c = ':';
1155 else
1156 c = '?';
1157 }
1158 else
1159 /* We already incremented `optind' once;
1160 increment it again when taking next ARGV-elt as argument. */
1161 optarg = argv[optind++];
1162 nextchar = NULL;
1163 }
1164 }
1165 return c;
1166 }
1167 }
1168
1169 int
getopt(argc,argv,optstring)1170 getopt(argc, argv, optstring)
1171 int argc;
1172 char *const *argv;
1173 const char *optstring;
1174 {
1175 return _getopt_internal(argc, argv, optstring,
1176 (const struct option *) 0,
1177 (int *)0,
1178 0);
1179 }
1180
1181
1182
1183
1184 int
getopt_long(int argc,char * const * argv,const char * options,const struct option * long_options,int * opt_index)1185 getopt_long(int argc, char *const *argv, const char *options,
1186 const struct option *long_options, int *opt_index)
1187 {
1188 return _getopt_internal(argc, argv, options, long_options, opt_index, 0, 0);
1189 }
1190
1191 int
getopt_long_only(int argc,char * const * argv,const char * options,const struct option * long_options,int * opt_index)1192 getopt_long_only(int argc, char *const *argv, const char *options,
1193 const struct option *long_options, int *opt_index)
1194 {
1195 return _getopt_internal(argc, argv, options, long_options, opt_index, 1, 0);
1196 }
1197
1198
1199
1200
1201
1202 #endif /* Not ELIDE_CODE. */
1203
1204 #ifdef TEST
1205
1206 /* Compile with -DTEST to make an executable for use in testing
1207 the above definition of `getopt'. */
1208
1209 int
main(argc,argv)1210 main(argc, argv)
1211 int argc;
1212 char **argv;
1213 {
1214 int c;
1215 int digit_optind = 0;
1216
1217 while (1)
1218 {
1219 int this_option_optind = optind ? optind : 1;
1220
1221 c = getopt(argc, argv, "abc:d:0123456789");
1222 if (c == -1)
1223 break;
1224
1225 switch (c)
1226 {
1227 case '0':
1228 case '1':
1229 case '2':
1230 case '3':
1231 case '4':
1232 case '5':
1233 case '6':
1234 case '7':
1235 case '8':
1236 case '9':
1237 if (digit_optind != 0 && digit_optind != this_option_optind)
1238 printf("digits occur in two different argv-elements.\n");
1239 digit_optind = this_option_optind;
1240 printf("option %c\n", c);
1241 break;
1242
1243 case 'a':
1244 printf("option a\n");
1245 break;
1246
1247 case 'b':
1248 printf("option b\n");
1249 break;
1250
1251 case 'c':
1252 printf("option c with value `%s'\n", optarg);
1253 break;
1254
1255 case '?':
1256 break;
1257
1258 default:
1259 printf("?? getopt returned character code 0%o ??\n", c);
1260 }
1261 }
1262
1263 if (optind < argc)
1264 {
1265 printf("non-option ARGV-elements: ");
1266 while (optind < argc)
1267 printf("%s ", argv[optind++]);
1268 printf("\n");
1269 }
1270
1271 exit(0);
1272 }
1273
1274 #endif /* TEST */
1275