2
NOTE: getopt is 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
5
Copyright (C) 1987-1996, 1998-2004, 2006, 2008-2012 Free Software
7
This file is part of the GNU C Library.
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 3 of the License, or
12
(at your option) any later version.
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.
19
You should have received a copy of the GNU General Public License
20
along with this program. If not, see <http://www.gnu.org/licenses/>. */
37
# define _(msgid) gettext (msgid)
40
#if defined _LIBC && defined USE_IN_LIBIO
44
/* This version of 'getopt' appears to the caller like standard Unix 'getopt'
45
but it behaves differently for the user, since it allows the user
46
to intersperse the options with the other arguments.
48
As 'getopt_long' works, it permutes the elements of ARGV so that,
49
when it is done, all the options precede everything else. Thus
50
all application programs are extended to handle flexible argument order.
52
Using 'getopt' or setting the environment variable POSIXLY_CORRECT
54
Then the behavior is completely standard.
56
GNU application programs can use a third alternative mode in which
57
they can distinguish the relative order of options and other arguments. */
59
#include "getopt_int.h"
61
/* For communication from 'getopt' to the caller.
62
When 'getopt' finds an option that takes an argument,
63
the argument value is returned here.
64
Also, when 'ordering' is RETURN_IN_ORDER,
65
each non-option ARGV-element is returned here. */
69
/* Index in ARGV of the next element to be scanned.
70
This is used for communication to and from the caller
71
and for communication between successive calls to 'getopt'.
73
On entry to 'getopt', zero means this is the first call; initialize.
75
When 'getopt' returns -1, this is the index of the first of the
76
non-option elements that the caller should itself scan.
78
Otherwise, 'optind' communicates from one call to the next
79
how much of ARGV has been scanned so far. */
81
/* 1003.2 says this must be 1 before any call. */
84
/* Callers store zero here to inhibit the error message
85
for unrecognized options. */
89
/* Set to an option character which was unrecognized.
90
This must be initialized on some systems to avoid linking in the
91
system's own getopt implementation. */
95
/* Keep a global copy of all internal members of getopt_data. */
97
static struct _getopt_data getopt_data;
100
#if defined HAVE_DECL_GETENV && !HAVE_DECL_GETENV
101
extern char *getenv ();
105
/* Stored original parameters.
106
XXX This is no good solution. We should rather copy the args so
107
that we can compare them later. But we must not use malloc(3). */
108
extern int __libc_argc;
109
extern char **__libc_argv;
111
/* Bash 2.0 gives us an environment variable containing flags
112
indicating ARGV elements that should not be considered arguments. */
114
# ifdef USE_NONOPTION_FLAGS
115
/* Defined in getopt_init.c */
116
extern char *__getopt_nonoption_flags;
119
# ifdef USE_NONOPTION_FLAGS
120
# define SWAP_FLAGS(ch1, ch2) \
121
if (d->__nonoption_flags_len > 0) \
123
char __tmp = __getopt_nonoption_flags[ch1]; \
124
__getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2]; \
125
__getopt_nonoption_flags[ch2] = __tmp; \
128
# define SWAP_FLAGS(ch1, ch2)
131
# define SWAP_FLAGS(ch1, ch2)
134
/* Exchange two adjacent subsequences of ARGV.
135
One subsequence is elements [first_nonopt,last_nonopt)
136
which contains all the non-options that have been skipped so far.
137
The other is elements [last_nonopt,optind), which contains all
138
the options processed since those non-options were skipped.
140
'first_nonopt' and 'last_nonopt' are relocated so that they describe
141
the new indices of the non-options in ARGV after they are moved. */
144
exchange (char **argv, struct _getopt_data *d)
146
int bottom = d->__first_nonopt;
147
int middle = d->__last_nonopt;
151
/* Exchange the shorter segment with the far end of the longer segment.
152
That puts the shorter segment into the right place.
153
It leaves the longer segment in the right place overall,
154
but it consists of two parts that need to be swapped next. */
156
#if defined _LIBC && defined USE_NONOPTION_FLAGS
157
/* First make sure the handling of the '__getopt_nonoption_flags'
158
string can work normally. Our top argument must be in the range
160
if (d->__nonoption_flags_len > 0 && top >= d->__nonoption_flags_max_len)
162
/* We must extend the array. The user plays games with us and
163
presents new arguments. */
164
char *new_str = malloc (top + 1);
166
d->__nonoption_flags_len = d->__nonoption_flags_max_len = 0;
169
memset (__mempcpy (new_str, __getopt_nonoption_flags,
170
d->__nonoption_flags_max_len),
171
'\0', top + 1 - d->__nonoption_flags_max_len);
172
d->__nonoption_flags_max_len = top + 1;
173
__getopt_nonoption_flags = new_str;
178
while (top > middle && middle > bottom)
180
if (top - middle > middle - bottom)
182
/* Bottom segment is the short one. */
183
int len = middle - bottom;
186
/* Swap it with the top part of the top segment. */
187
for (i = 0; i < len; i++)
189
tem = argv[bottom + i];
190
argv[bottom + i] = argv[top - (middle - bottom) + i];
191
argv[top - (middle - bottom) + i] = tem;
192
SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
194
/* Exclude the moved bottom segment from further swapping. */
199
/* Top segment is the short one. */
200
int len = top - middle;
203
/* Swap it with the bottom part of the bottom segment. */
204
for (i = 0; i < len; i++)
206
tem = argv[bottom + i];
207
argv[bottom + i] = argv[middle + i];
208
argv[middle + i] = tem;
209
SWAP_FLAGS (bottom + i, middle + i);
211
/* Exclude the moved top segment from further swapping. */
216
/* Update records for the slots the non-options now occupy. */
218
d->__first_nonopt += (d->optind - d->__last_nonopt);
219
d->__last_nonopt = d->optind;
222
/* Initialize the internal data when the first call is made. */
225
_getopt_initialize (int argc _GL_UNUSED,
226
char **argv _GL_UNUSED, const char *optstring,
227
struct _getopt_data *d, int posixly_correct)
229
/* Start processing options with ARGV-element 1 (since ARGV-element 0
230
is the program name); the sequence of previously skipped
231
non-option ARGV-elements is empty. */
233
d->__first_nonopt = d->__last_nonopt = d->optind;
235
d->__nextchar = NULL;
237
d->__posixly_correct = posixly_correct || !!getenv ("POSIXLY_CORRECT");
239
/* Determine how to handle the ordering of options and nonoptions. */
241
if (optstring[0] == '-')
243
d->__ordering = RETURN_IN_ORDER;
246
else if (optstring[0] == '+')
248
d->__ordering = REQUIRE_ORDER;
251
else if (d->__posixly_correct)
252
d->__ordering = REQUIRE_ORDER;
254
d->__ordering = PERMUTE;
256
#if defined _LIBC && defined USE_NONOPTION_FLAGS
257
if (!d->__posixly_correct
258
&& argc == __libc_argc && argv == __libc_argv)
260
if (d->__nonoption_flags_max_len == 0)
262
if (__getopt_nonoption_flags == NULL
263
|| __getopt_nonoption_flags[0] == '\0')
264
d->__nonoption_flags_max_len = -1;
267
const char *orig_str = __getopt_nonoption_flags;
268
int len = d->__nonoption_flags_max_len = strlen (orig_str);
269
if (d->__nonoption_flags_max_len < argc)
270
d->__nonoption_flags_max_len = argc;
271
__getopt_nonoption_flags =
272
(char *) malloc (d->__nonoption_flags_max_len);
273
if (__getopt_nonoption_flags == NULL)
274
d->__nonoption_flags_max_len = -1;
276
memset (__mempcpy (__getopt_nonoption_flags, orig_str, len),
277
'\0', d->__nonoption_flags_max_len - len);
280
d->__nonoption_flags_len = d->__nonoption_flags_max_len;
283
d->__nonoption_flags_len = 0;
289
/* Scan elements of ARGV (whose length is ARGC) for option characters
292
If an element of ARGV starts with '-', and is not exactly "-" or "--",
293
then it is an option element. The characters of this element
294
(aside from the initial '-') are option characters. If 'getopt'
295
is called repeatedly, it returns successively each of the option characters
296
from each of the option elements.
298
If 'getopt' finds another option character, it returns that character,
299
updating 'optind' and 'nextchar' so that the next call to 'getopt' can
300
resume the scan with the following option character or ARGV-element.
302
If there are no more option characters, 'getopt' returns -1.
303
Then 'optind' is the index in ARGV of the first ARGV-element
304
that is not an option. (The ARGV-elements have been permuted
305
so that those that are not options now come last.)
307
OPTSTRING is a string containing the legitimate option characters.
308
If an option character is seen that is not listed in OPTSTRING,
309
return '?' after printing an error message. If you set 'opterr' to
310
zero, the error message is suppressed but we still return '?'.
312
If a char in OPTSTRING is followed by a colon, that means it wants an arg,
313
so the following text in the same ARGV-element, or the text of the following
314
ARGV-element, is returned in 'optarg'. Two colons mean an option that
315
wants an optional arg; if there is text in the current ARGV-element,
316
it is returned in 'optarg', otherwise 'optarg' is set to zero.
318
If OPTSTRING starts with '-' or '+', it requests different methods of
319
handling the non-option ARGV-elements.
320
See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
322
Long-named options begin with '--' instead of '-'.
323
Their names may be abbreviated as long as the abbreviation is unique
324
or is an exact match for some defined option. If they have an
325
argument, it follows the option name in the same ARGV-element, separated
326
from the option name by a '=', or else the in next ARGV-element.
327
When 'getopt' finds a long-named option, it returns 0 if that option's
328
'flag' field is nonzero, the value of the option's 'val' field
329
if the 'flag' field is zero.
331
The elements of ARGV aren't really const, because we permute them.
332
But we pretend they're const in the prototype to be compatible
335
LONGOPTS is a vector of 'struct option' terminated by an
336
element containing a name which is zero.
338
LONGIND returns the index in LONGOPT of the long-named option found.
339
It is only valid when a long-named option has been found by the most
342
If LONG_ONLY is nonzero, '-' as well as '--' can introduce
343
long-named options. */
346
_getopt_internal_r (int argc, char **argv, const char *optstring,
347
const struct option *longopts, int *longind,
348
int long_only, struct _getopt_data *d, int posixly_correct)
350
int print_errors = d->opterr;
357
if (d->optind == 0 || !d->__initialized)
360
d->optind = 1; /* Don't scan ARGV[0], the program name. */
361
optstring = _getopt_initialize (argc, argv, optstring, d,
363
d->__initialized = 1;
365
else if (optstring[0] == '-' || optstring[0] == '+')
367
if (optstring[0] == ':')
370
/* Test whether ARGV[optind] points to a non-option argument.
371
Either it does not have option syntax, or there is an environment flag
372
from the shell indicating it is not an option. The later information
373
is only used when the used in the GNU libc. */
374
#if defined _LIBC && defined USE_NONOPTION_FLAGS
375
# define NONOPTION_P (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0' \
376
|| (d->optind < d->__nonoption_flags_len \
377
&& __getopt_nonoption_flags[d->optind] == '1'))
379
# define NONOPTION_P (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0')
382
if (d->__nextchar == NULL || *d->__nextchar == '\0')
384
/* Advance to the next ARGV-element. */
386
/* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
387
moved back by the user (who may also have changed the arguments). */
388
if (d->__last_nonopt > d->optind)
389
d->__last_nonopt = d->optind;
390
if (d->__first_nonopt > d->optind)
391
d->__first_nonopt = d->optind;
393
if (d->__ordering == PERMUTE)
395
/* If we have just processed some options following some non-options,
396
exchange them so that the options come first. */
398
if (d->__first_nonopt != d->__last_nonopt
399
&& d->__last_nonopt != d->optind)
400
exchange ((char **) argv, d);
401
else if (d->__last_nonopt != d->optind)
402
d->__first_nonopt = d->optind;
404
/* Skip any additional non-options
405
and extend the range of non-options previously skipped. */
407
while (d->optind < argc && NONOPTION_P)
409
d->__last_nonopt = d->optind;
412
/* The special ARGV-element '--' means premature end of options.
413
Skip it like a null option,
414
then exchange with previous non-options as if it were an option,
415
then skip everything else like a non-option. */
417
if (d->optind != argc && !strcmp (argv[d->optind], "--"))
421
if (d->__first_nonopt != d->__last_nonopt
422
&& d->__last_nonopt != d->optind)
423
exchange ((char **) argv, d);
424
else if (d->__first_nonopt == d->__last_nonopt)
425
d->__first_nonopt = d->optind;
426
d->__last_nonopt = argc;
431
/* If we have done all the ARGV-elements, stop the scan
432
and back over any non-options that we skipped and permuted. */
434
if (d->optind == argc)
436
/* Set the next-arg-index to point at the non-options
437
that we previously skipped, so the caller will digest them. */
438
if (d->__first_nonopt != d->__last_nonopt)
439
d->optind = d->__first_nonopt;
443
/* If we have come to a non-option and did not permute it,
444
either stop the scan or describe it to the caller and pass it by. */
448
if (d->__ordering == REQUIRE_ORDER)
450
d->optarg = argv[d->optind++];
454
/* We have found another option-ARGV-element.
455
Skip the initial punctuation. */
457
d->__nextchar = (argv[d->optind] + 1
458
+ (longopts != NULL && argv[d->optind][1] == '-'));
461
/* Decode the current option-ARGV-element. */
463
/* Check whether the ARGV-element is a long option.
465
If long_only and the ARGV-element has the form "-f", where f is
466
a valid short option, don't consider it an abbreviated form of
467
a long option that starts with f. Otherwise there would be no
468
way to give the -f short option.
470
On the other hand, if there's a long option "fubar" and
471
the ARGV-element is "-fu", do consider that an abbreviation of
472
the long option, just like "--fu", and not "-f" with arg "u".
474
This distinction seems to be the most useful approach. */
477
&& (argv[d->optind][1] == '-'
478
|| (long_only && (argv[d->optind][2]
479
|| !strchr (optstring, argv[d->optind][1])))))
482
unsigned int namelen;
483
const struct option *p;
484
const struct option *pfound = NULL;
487
const struct option *p;
488
struct option_list *next;
489
} *ambig_list = NULL;
494
for (nameend = d->__nextchar; *nameend && *nameend != '='; nameend++)
496
namelen = nameend - d->__nextchar;
498
/* Test all long options for either exact match
499
or abbreviated matches. */
500
for (p = longopts, option_index = 0; p->name; p++, option_index++)
501
if (!strncmp (p->name, d->__nextchar, namelen))
503
if (namelen == (unsigned int) strlen (p->name))
505
/* Exact match found. */
507
indfound = option_index;
511
else if (pfound == NULL)
513
/* First nonexact match found. */
515
indfound = option_index;
518
|| pfound->has_arg != p->has_arg
519
|| pfound->flag != p->flag
520
|| pfound->val != p->val)
522
/* Second or later nonexact match found. */
523
struct option_list *newp = malloc (sizeof (*newp));
525
newp->next = ambig_list;
530
if (ambig_list != NULL && !exact)
534
struct option_list first;
536
first.next = ambig_list;
539
#if defined _LIBC && defined USE_IN_LIBIO
543
FILE *fp = open_memstream (&buf, &buflen);
547
_("%s: option '%s' is ambiguous; possibilities:"),
548
argv[0], argv[d->optind]);
552
fprintf (fp, " '--%s'", ambig_list->p->name);
553
ambig_list = ambig_list->next;
555
while (ambig_list != NULL);
557
fputc_unlocked ('\n', fp);
559
if (__builtin_expect (fclose (fp) != EOF, 1))
561
_IO_flockfile (stderr);
563
int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
564
((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
566
__fxprintf (NULL, "%s", buf);
568
((_IO_FILE *) stderr)->_flags2 = old_flags2;
569
_IO_funlockfile (stderr);
576
_("%s: option '%s' is ambiguous; possibilities:"),
577
argv[0], argv[d->optind]);
580
fprintf (stderr, " '--%s'", ambig_list->p->name);
581
ambig_list = ambig_list->next;
583
while (ambig_list != NULL);
585
fputc ('\n', stderr);
588
d->__nextchar += strlen (d->__nextchar);
594
while (ambig_list != NULL)
596
struct option_list *pn = ambig_list->next;
603
option_index = indfound;
607
/* Don't test has_arg with >, because some C compilers don't
608
allow it to be used on enums. */
610
d->optarg = nameend + 1;
615
#if defined _LIBC && defined USE_IN_LIBIO
620
if (argv[d->optind - 1][1] == '-')
623
#if defined _LIBC && defined USE_IN_LIBIO
624
n = __asprintf (&buf, _("\
625
%s: option '--%s' doesn't allow an argument\n"),
626
argv[0], pfound->name);
628
fprintf (stderr, _("\
629
%s: option '--%s' doesn't allow an argument\n"),
630
argv[0], pfound->name);
635
/* +option or -option */
636
#if defined _LIBC && defined USE_IN_LIBIO
637
n = __asprintf (&buf, _("\
638
%s: option '%c%s' doesn't allow an argument\n"),
639
argv[0], argv[d->optind - 1][0],
642
fprintf (stderr, _("\
643
%s: option '%c%s' doesn't allow an argument\n"),
644
argv[0], argv[d->optind - 1][0],
649
#if defined _LIBC && defined USE_IN_LIBIO
652
_IO_flockfile (stderr);
654
int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
655
((_IO_FILE *) stderr)->_flags2
656
|= _IO_FLAGS2_NOTCANCEL;
658
__fxprintf (NULL, "%s", buf);
660
((_IO_FILE *) stderr)->_flags2 = old_flags2;
661
_IO_funlockfile (stderr);
668
d->__nextchar += strlen (d->__nextchar);
670
d->optopt = pfound->val;
674
else if (pfound->has_arg == 1)
676
if (d->optind < argc)
677
d->optarg = argv[d->optind++];
682
#if defined _LIBC && defined USE_IN_LIBIO
685
if (__asprintf (&buf, _("\
686
%s: option '--%s' requires an argument\n"),
687
argv[0], pfound->name) >= 0)
689
_IO_flockfile (stderr);
691
int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
692
((_IO_FILE *) stderr)->_flags2
693
|= _IO_FLAGS2_NOTCANCEL;
695
__fxprintf (NULL, "%s", buf);
697
((_IO_FILE *) stderr)->_flags2 = old_flags2;
698
_IO_funlockfile (stderr);
704
_("%s: option '--%s' requires an argument\n"),
705
argv[0], pfound->name);
708
d->__nextchar += strlen (d->__nextchar);
709
d->optopt = pfound->val;
710
return optstring[0] == ':' ? ':' : '?';
713
d->__nextchar += strlen (d->__nextchar);
715
*longind = option_index;
718
*(pfound->flag) = pfound->val;
724
/* Can't find it as a long option. If this is not getopt_long_only,
725
or the option starts with '--' or is not a valid short
726
option, then it's an error.
727
Otherwise interpret it as a short option. */
728
if (!long_only || argv[d->optind][1] == '-'
729
|| strchr (optstring, *d->__nextchar) == NULL)
733
#if defined _LIBC && defined USE_IN_LIBIO
738
if (argv[d->optind][1] == '-')
741
#if defined _LIBC && defined USE_IN_LIBIO
742
n = __asprintf (&buf, _("%s: unrecognized option '--%s'\n"),
743
argv[0], d->__nextchar);
745
fprintf (stderr, _("%s: unrecognized option '--%s'\n"),
746
argv[0], d->__nextchar);
751
/* +option or -option */
752
#if defined _LIBC && defined USE_IN_LIBIO
753
n = __asprintf (&buf, _("%s: unrecognized option '%c%s'\n"),
754
argv[0], argv[d->optind][0], d->__nextchar);
756
fprintf (stderr, _("%s: unrecognized option '%c%s'\n"),
757
argv[0], argv[d->optind][0], d->__nextchar);
761
#if defined _LIBC && defined USE_IN_LIBIO
764
_IO_flockfile (stderr);
766
int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
767
((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
769
__fxprintf (NULL, "%s", buf);
771
((_IO_FILE *) stderr)->_flags2 = old_flags2;
772
_IO_funlockfile (stderr);
778
d->__nextchar = (char *) "";
785
/* Look at and handle the next short option-character. */
788
char c = *d->__nextchar++;
789
const char *temp = strchr (optstring, c);
791
/* Increment 'optind' when we start to process its last character. */
792
if (*d->__nextchar == '\0')
795
if (temp == NULL || c == ':' || c == ';')
799
#if defined _LIBC && defined USE_IN_LIBIO
804
#if defined _LIBC && defined USE_IN_LIBIO
805
n = __asprintf (&buf, _("%s: invalid option -- '%c'\n"),
808
fprintf (stderr, _("%s: invalid option -- '%c'\n"), argv[0], c);
811
#if defined _LIBC && defined USE_IN_LIBIO
814
_IO_flockfile (stderr);
816
int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
817
((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
819
__fxprintf (NULL, "%s", buf);
821
((_IO_FILE *) stderr)->_flags2 = old_flags2;
822
_IO_funlockfile (stderr);
831
/* Convenience. Treat POSIX -W foo same as long option --foo */
832
if (temp[0] == 'W' && temp[1] == ';')
835
const struct option *p;
836
const struct option *pfound = NULL;
842
if (longopts == NULL)
845
/* This is an option that requires an argument. */
846
if (*d->__nextchar != '\0')
848
d->optarg = d->__nextchar;
849
/* If we end this ARGV-element by taking the rest as an arg,
850
we must advance to the next element now. */
853
else if (d->optind == argc)
857
#if defined _LIBC && defined USE_IN_LIBIO
860
if (__asprintf (&buf,
861
_("%s: option requires an argument -- '%c'\n"),
864
_IO_flockfile (stderr);
866
int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
867
((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
869
__fxprintf (NULL, "%s", buf);
871
((_IO_FILE *) stderr)->_flags2 = old_flags2;
872
_IO_funlockfile (stderr);
878
_("%s: option requires an argument -- '%c'\n"),
883
if (optstring[0] == ':')
890
/* We already incremented 'd->optind' once;
891
increment it again when taking next ARGV-elt as argument. */
892
d->optarg = argv[d->optind++];
894
/* optarg is now the argument, see if it's in the
895
table of longopts. */
897
for (d->__nextchar = nameend = d->optarg; *nameend && *nameend != '=';
901
/* Test all long options for either exact match
902
or abbreviated matches. */
903
for (p = longopts, option_index = 0; p->name; p++, option_index++)
904
if (!strncmp (p->name, d->__nextchar, nameend - d->__nextchar))
906
if ((unsigned int) (nameend - d->__nextchar) == strlen (p->name))
908
/* Exact match found. */
910
indfound = option_index;
914
else if (pfound == NULL)
916
/* First nonexact match found. */
918
indfound = option_index;
921
|| pfound->has_arg != p->has_arg
922
|| pfound->flag != p->flag
923
|| pfound->val != p->val)
924
/* Second or later nonexact match found. */
931
#if defined _LIBC && defined USE_IN_LIBIO
934
if (__asprintf (&buf, _("%s: option '-W %s' is ambiguous\n"),
935
argv[0], d->optarg) >= 0)
937
_IO_flockfile (stderr);
939
int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
940
((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
942
__fxprintf (NULL, "%s", buf);
944
((_IO_FILE *) stderr)->_flags2 = old_flags2;
945
_IO_funlockfile (stderr);
950
fprintf (stderr, _("%s: option '-W %s' is ambiguous\n"),
954
d->__nextchar += strlen (d->__nextchar);
960
option_index = indfound;
963
/* Don't test has_arg with >, because some C compilers don't
964
allow it to be used on enums. */
966
d->optarg = nameend + 1;
971
#if defined _LIBC && defined USE_IN_LIBIO
974
if (__asprintf (&buf, _("\
975
%s: option '-W %s' doesn't allow an argument\n"),
976
argv[0], pfound->name) >= 0)
978
_IO_flockfile (stderr);
980
int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
981
((_IO_FILE *) stderr)->_flags2
982
|= _IO_FLAGS2_NOTCANCEL;
984
__fxprintf (NULL, "%s", buf);
986
((_IO_FILE *) stderr)->_flags2 = old_flags2;
987
_IO_funlockfile (stderr);
992
fprintf (stderr, _("\
993
%s: option '-W %s' doesn't allow an argument\n"),
994
argv[0], pfound->name);
998
d->__nextchar += strlen (d->__nextchar);
1002
else if (pfound->has_arg == 1)
1004
if (d->optind < argc)
1005
d->optarg = argv[d->optind++];
1010
#if defined _LIBC && defined USE_IN_LIBIO
1013
if (__asprintf (&buf, _("\
1014
%s: option '-W %s' requires an argument\n"),
1015
argv[0], pfound->name) >= 0)
1017
_IO_flockfile (stderr);
1019
int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
1020
((_IO_FILE *) stderr)->_flags2
1021
|= _IO_FLAGS2_NOTCANCEL;
1023
__fxprintf (NULL, "%s", buf);
1025
((_IO_FILE *) stderr)->_flags2 = old_flags2;
1026
_IO_funlockfile (stderr);
1031
fprintf (stderr, _("\
1032
%s: option '-W %s' requires an argument\n"),
1033
argv[0], pfound->name);
1036
d->__nextchar += strlen (d->__nextchar);
1037
return optstring[0] == ':' ? ':' : '?';
1042
d->__nextchar += strlen (d->__nextchar);
1043
if (longind != NULL)
1044
*longind = option_index;
1047
*(pfound->flag) = pfound->val;
1054
d->__nextchar = NULL;
1055
return 'W'; /* Let the application handle it. */
1061
/* This is an option that accepts an argument optionally. */
1062
if (*d->__nextchar != '\0')
1064
d->optarg = d->__nextchar;
1069
d->__nextchar = NULL;
1073
/* This is an option that requires an argument. */
1074
if (*d->__nextchar != '\0')
1076
d->optarg = d->__nextchar;
1077
/* If we end this ARGV-element by taking the rest as an arg,
1078
we must advance to the next element now. */
1081
else if (d->optind == argc)
1085
#if defined _LIBC && defined USE_IN_LIBIO
1088
if (__asprintf (&buf, _("\
1089
%s: option requires an argument -- '%c'\n"),
1092
_IO_flockfile (stderr);
1094
int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
1095
((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
1097
__fxprintf (NULL, "%s", buf);
1099
((_IO_FILE *) stderr)->_flags2 = old_flags2;
1100
_IO_funlockfile (stderr);
1106
_("%s: option requires an argument -- '%c'\n"),
1111
if (optstring[0] == ':')
1117
/* We already incremented 'optind' once;
1118
increment it again when taking next ARGV-elt as argument. */
1119
d->optarg = argv[d->optind++];
1120
d->__nextchar = NULL;
1128
_getopt_internal (int argc, char **argv, const char *optstring,
1129
const struct option *longopts, int *longind, int long_only,
1130
int posixly_correct)
1134
getopt_data.optind = optind;
1135
getopt_data.opterr = opterr;
1137
result = _getopt_internal_r (argc, argv, optstring, longopts,
1138
longind, long_only, &getopt_data,
1141
optind = getopt_data.optind;
1142
optarg = getopt_data.optarg;
1143
optopt = getopt_data.optopt;
1148
/* glibc gets a LSB-compliant getopt.
1149
Standalone applications get a POSIX-compliant getopt. */
1151
enum { POSIXLY_CORRECT = 0 };
1153
enum { POSIXLY_CORRECT = 1 };
1157
getopt (int argc, char *const *argv, const char *optstring)
1159
return _getopt_internal (argc, (char **) argv, optstring,
1160
(const struct option *) 0,
1162
0, POSIXLY_CORRECT);
1167
__posix_getopt (int argc, char *const *argv, const char *optstring)
1169
return _getopt_internal (argc, argv, optstring,
1170
(const struct option *) 0,
1179
/* Compile with -DTEST to make an executable for use in testing
1180
the above definition of 'getopt'. */
1183
main (int argc, char **argv)
1186
int digit_optind = 0;
1190
int this_option_optind = optind ? optind : 1;
1192
c = getopt (argc, argv, "abc:d:0123456789");
1208
if (digit_optind != 0 && digit_optind != this_option_optind)
1209
printf ("digits occur in two different argv-elements.\n");
1210
digit_optind = this_option_optind;
1211
printf ("option %c\n", c);
1215
printf ("option a\n");
1219
printf ("option b\n");
1223
printf ("option c with value '%s'\n", optarg);
1230
printf ("?? getopt returned character code 0%o ??\n", c);
1236
printf ("non-option ARGV-elements: ");
1237
while (optind < argc)
1238
printf ("%s ", argv[optind++]);
added
removed
lib/getopt.c
