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