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
6
Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000
7
Free Software Foundation, Inc.
9
The GNU C Library is free software; you can redistribute it and/or
10
modify it under the terms of the GNU Library General Public License as
11
published by the Free Software Foundation; either version 2 of the
12
License, or (at your option) any later version.
14
The GNU C Library is distributed in the hope that it will be useful,
15
but WITHOUT ANY WARRANTY; without even the implied warranty of
16
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17
Library General Public License for more details.
19
You should have received a copy of the GNU Library General Public
20
License along with the GNU C Library; see the file COPYING.LIB. If not,
21
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
22
Boston, MA 02111-1307, USA. */
24
/* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
25
Ditto for AIX 3.2 and <stdlib.h>. */
36
#if !defined __STDC__ || !__STDC__
37
/* This is a separate conditional since some stdc systems
38
reject `defined (const)'. */
46
/* Comment out all this code if we are using the GNU C Library, and are not
47
actually compiling the library itself. This code is part of the GNU C
48
Library, but also included in many other GNU distributions. Compiling
49
and linking in this code is a waste when using the GNU C library
50
(especially if it is a shared library). Rather than having every GNU
51
program understand `configure --with-gnu-libc' and omit the object files,
52
it is simpler to just do this in the source for each such file. */
54
#define GETOPT_INTERFACE_VERSION 2
55
#if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2
56
# include <gnu-versions.h>
57
# if _GNU_GETOPT<_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
65
/* This needs to come after some library #include
66
to get __GNU_LIBRARY__ defined. */
67
#ifdef __GNU_LIBRARY__
68
/* Don't include stdlib.h for non-GNU C libraries because some of them
69
contain conflicting prototypes for getopt. */
72
#endif /* GNU C library. */
76
# if HAVE_STRING_H - 0
82
/* This is for other GNU distributions with internationalized messages.
83
When compiling libc, the _ macro is predefined. */
84
# ifdef HAVE_LIBINTL_H
86
# define _(msgid) gettext (msgid)
88
# define _(msgid) (msgid)
92
/* This version of `getopt' appears to the caller like standard Unix `getopt'
93
but it behaves differently for the user, since it allows the user
94
to intersperse the options with the other arguments.
96
As `getopt' works, it permutes the elements of ARGV so that,
97
when it is done, all the options precede everything else. Thus
98
all application programs are extended to handle flexible argument order.
100
Setting the environment variable POSIXLY_CORRECT disables permutation.
101
Then the behavior is completely standard.
103
GNU application programs can use a third alternative mode in which
104
they can distinguish the relative order of options and other arguments. */
108
/* ntop addition to quiet warning from -Wmissing-prototypes */
109
int getopt____ (int argc, char *const *argv, const char *optstring);
111
/* For communication from `getopt' to the caller.
112
When `getopt' finds an option that takes an argument,
113
the argument value is returned here.
114
Also, when `ordering' is RETURN_IN_ORDER,
115
each non-option ARGV-element is returned here. */
122
/* Index in ARGV of the next element to be scanned.
123
This is used for communication to and from the caller
124
and for communication between successive calls to `getopt'.
126
On entry to `getopt', zero means this is the first call; initialize.
128
When `getopt' returns -1, this is the index of the first of the
129
non-option elements that the caller should itself scan.
131
Otherwise, `optind' communicates from one call to the next
132
how much of ARGV has been scanned so far. */
134
/* 1003.2 says this must be 1 before any call. */
139
/* Formerly, initialization of getopt depended on optind==0, which
140
causes problems with re-calling getopt as programs generally don't
143
int __getopt_initialized;
145
/* The next char to be scanned in the option-element
146
in which the last option character we returned was found.
147
This allows us to pick up the scan where we left off.
149
If this is zero, or a null string, it means resume the scan
150
by advancing to the next ARGV-element. */
152
static char *nextchar;
154
/* Callers store zero here to inhibit the error message
155
for unrecognized options. */
161
/* Set to an option character which was unrecognized.
162
This must be initialized on some systems to avoid linking in the
163
system's own getopt implementation. */
168
/* Describe how to deal with options that follow non-option ARGV-elements.
170
If the caller did not specify anything,
171
the default is REQUIRE_ORDER if the environment variable
172
POSIXLY_CORRECT is defined, PERMUTE otherwise.
174
REQUIRE_ORDER means don't recognize them as options;
175
stop option processing when the first non-option is seen.
176
This is what Unix does.
177
This mode of operation is selected by either setting the environment
178
variable POSIXLY_CORRECT, or using `+' as the first character
179
of the list of option characters.
181
PERMUTE is the default. We permute the contents of ARGV as we scan,
182
so that eventually all the non-options are at the end. This allows options
183
to be given in any order, even with programs that were not written to
186
RETURN_IN_ORDER is an option available to programs that were written
187
to expect options and other ARGV-elements in any order and that care about
188
the ordering of the two. We describe each non-option ARGV-element
189
as if it were the argument of an option with character code 1.
190
Using `-' as the first character of the list of option characters
191
selects this mode of operation.
193
The special argument `--' forces an end of option-scanning regardless
194
of the value of `ordering'. In the case of RETURN_IN_ORDER, only
195
`--' can cause `getopt' to return -1 with `optind' != ARGC. */
199
REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
202
/* Value of POSIXLY_CORRECT environment variable. */
203
static char *posixly_correct;
205
#ifdef __GNU_LIBRARY__
206
/* We want to avoid inclusion of string.h with non-GNU libraries
207
because there are many ways it can cause trouble.
208
On some systems, it contains special magic macros that don't work
211
# define my_index strchr
218
# include <strings.h>
222
/* Avoid depending on library functions or files
223
whose names are inconsistent. */
226
extern char *getenv ();
243
/* If using GCC, we can safely declare strlen this way.
244
If not using GCC, it is ok not to declare it. */
246
/* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
247
That was relevant to code that was here before. */
248
# if (!defined __STDC__ || !__STDC__) && !defined strlen
249
/* gcc with -traditional declares the built-in strlen to return int,
250
and has done so at least since version 2.4.5. -- rms. */
251
extern int strlen (const char *);
252
# endif /* not __STDC__ */
253
#endif /* __GNUC__ */
255
#endif /* not __GNU_LIBRARY__ */
257
/* Handle permutation of arguments. */
259
/* Describe the part of ARGV that contains non-options that have
260
been skipped. `first_nonopt' is the index in ARGV of the first of them;
261
`last_nonopt' is the index after the last of them. */
263
static int first_nonopt;
264
static int last_nonopt;
267
/* Bash 2.0 gives us an environment variable containing flags
268
indicating ARGV elements that should not be considered arguments. */
270
/* Defined in getopt_init.c */
271
extern char *__getopt_nonoption_flags;
273
static int nonoption_flags_max_len;
274
static int nonoption_flags_len;
276
static int original_argc;
277
static char *const *original_argv;
279
/* Make sure the environment variable bash 2.0 puts in the environment
280
is valid for the getopt call we must make sure that the ARGV passed
281
to getopt is that one passed to the process. */
283
__attribute__ ((unused))
284
store_args_and_env (int argc, char *const *argv)
286
/* XXX This is no good solution. We should rather copy the args so
287
that we can compare them later. But we must not use malloc(3). */
288
original_argc = argc;
289
original_argv = argv;
291
# ifdef text_set_element
292
text_set_element (__libc_subinit, store_args_and_env);
293
# endif /* text_set_element */
295
# define SWAP_FLAGS(ch1, ch2) \
296
if (nonoption_flags_len > 0) \
298
char __tmp = __getopt_nonoption_flags[ch1]; \
299
__getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2]; \
300
__getopt_nonoption_flags[ch2] = __tmp; \
303
# define SWAP_FLAGS(ch1, ch2)
306
/* Exchange two adjacent subsequences of ARGV.
307
One subsequence is elements [first_nonopt,last_nonopt)
308
which contains all the non-options that have been skipped so far.
309
The other is elements [last_nonopt,optind), which contains all
310
the options processed since those non-options were skipped.
312
`first_nonopt' and `last_nonopt' are relocated so that they describe
313
the new indices of the non-options in ARGV after they are moved. */
315
#if defined __STDC__ && __STDC__
316
static void exchange (char **);
323
int bottom = first_nonopt;
324
int middle = last_nonopt;
328
/* Exchange the shorter segment with the far end of the longer segment.
329
That puts the shorter segment into the right place.
330
It leaves the longer segment in the right place overall,
331
but it consists of two parts that need to be swapped next. */
334
/* First make sure the handling of the `__getopt_nonoption_flags'
335
string can work normally. Our top argument must be in the range
337
if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len)
339
/* We must extend the array. The user plays games with us and
340
presents new arguments. */
341
char *new_str = malloc (top + 1);
343
nonoption_flags_len = nonoption_flags_max_len = 0;
346
memset (__mempcpy (new_str, __getopt_nonoption_flags,
347
nonoption_flags_max_len),
348
'\0', top + 1 - nonoption_flags_max_len);
349
nonoption_flags_max_len = top + 1;
350
__getopt_nonoption_flags = new_str;
355
while (top > middle && middle > bottom)
357
if (top - middle > middle - bottom)
359
/* Bottom segment is the short one. */
360
int len = middle - bottom;
363
/* Swap it with the top part of the top segment. */
364
for (i = 0; i < len; i++)
366
tem = argv[bottom + i];
367
argv[bottom + i] = argv[top - (middle - bottom) + i];
368
argv[top - (middle - bottom) + i] = tem;
369
SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
371
/* Exclude the moved bottom segment from further swapping. */
376
/* Top segment is the short one. */
377
int len = top - middle;
380
/* Swap it with the bottom part of the bottom segment. */
381
for (i = 0; i < len; i++)
383
tem = argv[bottom + i];
384
argv[bottom + i] = argv[middle + i];
385
argv[middle + i] = tem;
386
SWAP_FLAGS (bottom + i, middle + i);
388
/* Exclude the moved top segment from further swapping. */
393
/* Update records for the slots the non-options now occupy. */
395
first_nonopt += (optind - last_nonopt);
396
last_nonopt = optind;
399
/* Initialize the internal data when the first call is made. */
401
#if defined __STDC__ && __STDC__
402
static const char *_getopt_initialize (int, char *const *, const char *);
405
_getopt_initialize (argc, argv, optstring)
408
const char *optstring;
410
/* Start processing options with ARGV-element 1 (since ARGV-element 0
411
is the program name); the sequence of previously skipped
412
non-option ARGV-elements is empty. */
414
first_nonopt = last_nonopt = optind;
418
posixly_correct = getenv ("POSIXLY_CORRECT");
420
/* Determine how to handle the ordering of options and nonoptions. */
422
if (optstring[0] == '-')
424
ordering = RETURN_IN_ORDER;
427
else if (optstring[0] == '+')
429
ordering = REQUIRE_ORDER;
432
else if (posixly_correct != NULL)
433
ordering = REQUIRE_ORDER;
438
if (posixly_correct == NULL
439
&& argc == original_argc && argv == original_argv)
441
if (nonoption_flags_max_len == 0)
443
if (__getopt_nonoption_flags == NULL
444
|| __getopt_nonoption_flags[0] == '\0')
445
nonoption_flags_max_len = -1;
448
const char *orig_str = __getopt_nonoption_flags;
449
int len = nonoption_flags_max_len = strlen (orig_str);
450
if (nonoption_flags_max_len < argc)
451
nonoption_flags_max_len = argc;
452
__getopt_nonoption_flags =
453
(char *) malloc (nonoption_flags_max_len);
454
if (__getopt_nonoption_flags == NULL)
455
nonoption_flags_max_len = -1;
457
memset (__mempcpy (__getopt_nonoption_flags, orig_str, len),
458
'\0', nonoption_flags_max_len - len);
461
nonoption_flags_len = nonoption_flags_max_len;
464
nonoption_flags_len = 0;
470
/* Scan elements of ARGV (whose length is ARGC) for option characters
473
If an element of ARGV starts with '-', and is not exactly "-" or "--",
474
then it is an option element. The characters of this element
475
(aside from the initial '-') are option characters. If `getopt'
476
is called repeatedly, it returns successively each of the option characters
477
from each of the option elements.
479
If `getopt' finds another option character, it returns that character,
480
updating `optind' and `nextchar' so that the next call to `getopt' can
481
resume the scan with the following option character or ARGV-element.
483
If there are no more option characters, `getopt' returns -1.
484
Then `optind' is the index in ARGV of the first ARGV-element
485
that is not an option. (The ARGV-elements have been permuted
486
so that those that are not options now come last.)
488
OPTSTRING is a string containing the legitimate option characters.
489
If an option character is seen that is not listed in OPTSTRING,
490
return '?' after printing an error message. If you set `opterr' to
491
zero, the error message is suppressed but we still return '?'.
493
If a char in OPTSTRING is followed by a colon, that means it wants an arg,
494
so the following text in the same ARGV-element, or the text of the following
495
ARGV-element, is returned in `optarg'. Two colons mean an option that
496
wants an optional arg; if there is text in the current ARGV-element,
497
it is returned in `optarg', otherwise `optarg' is set to zero.
499
If OPTSTRING starts with `-' or `+', it requests different methods of
500
handling the non-option ARGV-elements.
501
See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
503
Long-named options begin with `--' instead of `-'.
504
Their names may be abbreviated as long as the abbreviation is unique
505
or is an exact match for some defined option. If they have an
506
argument, it follows the option name in the same ARGV-element, separated
507
from the option name by a `=', or else the in next ARGV-element.
508
When `getopt' finds a long-named option, it returns 0 if that option's
509
`flag' field is nonzero, the value of the option's `val' field
510
if the `flag' field is zero.
512
The elements of ARGV aren't really const, because we permute them.
513
But we pretend they're const in the prototype to be compatible
516
LONGOPTS is a vector of `struct option' terminated by an
517
element containing a name which is zero.
519
LONGIND returns the index in LONGOPT of the long-named option found.
520
It is only valid when a long-named option has been found by the most
523
If LONG_ONLY is nonzero, '-' as well as '--' can introduce
524
long-named options. */
527
_getopt_internal (argc, argv, optstring, longopts, longind, long_only)
530
const char *optstring;
531
const struct option *longopts;
535
int print_errors = opterr;
536
if (optstring[0] == ':')
541
if (optind == 0 || !__getopt_initialized)
544
optind = 1; /* Don't scan ARGV[0], the program name. */
545
optstring = _getopt_initialize (argc, argv, optstring);
546
__getopt_initialized = 1;
549
/* Test whether ARGV[optind] points to a non-option argument.
550
Either it does not have option syntax, or there is an environment flag
551
from the shell indicating it is not an option. The later information
552
is only used when the used in the GNU libc. */
554
# define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0' \
555
|| (optind < nonoption_flags_len \
556
&& __getopt_nonoption_flags[optind] == '1'))
558
# define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')
561
if (nextchar == NULL || *nextchar == '\0')
563
/* Advance to the next ARGV-element. */
565
/* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
566
moved back by the user (who may also have changed the arguments). */
567
if (last_nonopt > optind)
568
last_nonopt = optind;
569
if (first_nonopt > optind)
570
first_nonopt = optind;
572
if (ordering == PERMUTE)
574
/* If we have just processed some options following some non-options,
575
exchange them so that the options come first. */
577
if (first_nonopt != last_nonopt && last_nonopt != optind)
578
exchange ((char **) argv);
579
else if (last_nonopt != optind)
580
first_nonopt = optind;
582
/* Skip any additional non-options
583
and extend the range of non-options previously skipped. */
585
while (optind < argc && NONOPTION_P)
587
last_nonopt = optind;
590
/* The special ARGV-element `--' means premature end of options.
591
Skip it like a null option,
592
then exchange with previous non-options as if it were an option,
593
then skip everything else like a non-option. */
595
if (optind != argc && !strcmp (argv[optind], "--"))
599
if (first_nonopt != last_nonopt && last_nonopt != optind)
600
exchange ((char **) argv);
601
else if (first_nonopt == last_nonopt)
602
first_nonopt = optind;
608
/* If we have done all the ARGV-elements, stop the scan
609
and back over any non-options that we skipped and permuted. */
613
/* Set the next-arg-index to point at the non-options
614
that we previously skipped, so the caller will digest them. */
615
if (first_nonopt != last_nonopt)
616
optind = first_nonopt;
620
/* If we have come to a non-option and did not permute it,
621
either stop the scan or describe it to the caller and pass it by. */
625
if (ordering == REQUIRE_ORDER)
628
optarg = argv[optind++];
632
/* We have found another option-ARGV-element.
633
Skip the initial punctuation. */
635
nextchar = (argv[optind] + 1
636
+ (longopts != NULL && argv[optind][1] == '-'));
639
/* Decode the current option-ARGV-element. */
641
/* Check whether the ARGV-element is a long option.
643
If long_only and the ARGV-element has the form "-f", where f is
644
a valid short option, don't consider it an abbreviated form of
645
a long option that starts with f. Otherwise there would be no
646
way to give the -f short option.
648
On the other hand, if there's a long option "fubar" and
649
the ARGV-element is "-fu", do consider that an abbreviation of
650
the long option, just like "--fu", and not "-f" with arg "u".
652
This distinction seems to be the most useful approach. */
655
&& (argv[optind][1] == '-'
656
|| (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
659
const struct option *p;
660
const struct option *pfound = NULL;
666
for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
669
/* Test all long options for either exact match
670
or abbreviated matches. */
671
for (p = longopts, option_index = 0; p->name; p++, option_index++)
672
if (!strncmp (p->name, nextchar, nameend - nextchar))
674
if ((unsigned int) (nameend - nextchar)
675
== (unsigned int) strlen (p->name))
677
/* Exact match found. */
679
indfound = option_index;
683
else if (pfound == NULL)
685
/* First nonexact match found. */
687
indfound = option_index;
690
/* Second or later nonexact match found. */
697
fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
698
argv[0], argv[optind]);
699
nextchar += strlen (nextchar);
707
option_index = indfound;
711
/* Don't test has_arg with >, because some C compilers don't
712
allow it to be used on enums. */
714
optarg = nameend + 1;
719
if (argv[optind - 1][1] == '-')
722
_("%s: option `--%s' doesn't allow an argument\n"),
723
argv[0], pfound->name);
725
/* +option or -option */
727
_("%s: option `%c%s' doesn't allow an argument\n"),
728
argv[0], argv[optind - 1][0], pfound->name);
731
nextchar += strlen (nextchar);
733
optopt = pfound->val;
737
else if (pfound->has_arg == 1)
740
optarg = argv[optind++];
745
_("%s: option `%s' requires an argument\n"),
746
argv[0], argv[optind - 1]);
747
nextchar += strlen (nextchar);
748
optopt = pfound->val;
749
return optstring[0] == ':' ? ':' : '?';
752
nextchar += strlen (nextchar);
754
*longind = option_index;
757
*(pfound->flag) = pfound->val;
763
/* Can't find it as a long option. If this is not getopt_long_only,
764
or the option starts with '--' or is not a valid short
765
option, then it's an error.
766
Otherwise interpret it as a short option. */
767
if (!long_only || argv[optind][1] == '-'
768
|| my_index (optstring, *nextchar) == NULL)
772
if (argv[optind][1] == '-')
774
fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
777
/* +option or -option */
778
fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
779
argv[0], argv[optind][0], nextchar);
781
nextchar = (char *) "";
788
/* Look at and handle the next short option-character. */
791
char c = *nextchar++;
792
char *temp = my_index (optstring, c);
794
/* Increment `optind' when we start to process its last character. */
795
if (*nextchar == '\0')
798
if (temp == NULL || c == ':')
803
/* 1003.2 specifies the format of this message. */
804
fprintf (stderr, _("%s: illegal option -- %c\n"),
807
fprintf (stderr, _("%s: invalid option -- %c\n"),
813
/* Convenience. Treat POSIX -W foo same as long option --foo */
814
if (temp[0] == 'W' && temp[1] == ';')
817
const struct option *p;
818
const struct option *pfound = NULL;
824
/* This is an option that requires an argument. */
825
if (*nextchar != '\0')
828
/* If we end this ARGV-element by taking the rest as an arg,
829
we must advance to the next element now. */
832
else if (optind == argc)
836
/* 1003.2 specifies the format of this message. */
837
fprintf (stderr, _("%s: option requires an argument -- %c\n"),
841
if (optstring[0] == ':')
848
/* We already incremented `optind' once;
849
increment it again when taking next ARGV-elt as argument. */
850
optarg = argv[optind++];
852
/* optarg is now the argument, see if it's in the
853
table of longopts. */
855
for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++)
858
/* Test all long options for either exact match
859
or abbreviated matches. */
860
for (p = longopts, option_index = 0; p->name; p++, option_index++)
861
if (!strncmp (p->name, nextchar, nameend - nextchar))
863
if ((unsigned int) (nameend - nextchar) == strlen (p->name))
865
/* Exact match found. */
867
indfound = option_index;
871
else if (pfound == NULL)
873
/* First nonexact match found. */
875
indfound = option_index;
878
/* Second or later nonexact match found. */
884
fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
885
argv[0], argv[optind]);
886
nextchar += strlen (nextchar);
892
option_index = indfound;
895
/* Don't test has_arg with >, because some C compilers don't
896
allow it to be used on enums. */
898
optarg = nameend + 1;
902
fprintf (stderr, _("\
903
%s: option `-W %s' doesn't allow an argument\n"),
904
argv[0], pfound->name);
906
nextchar += strlen (nextchar);
910
else if (pfound->has_arg == 1)
913
optarg = argv[optind++];
918
_("%s: option `%s' requires an argument\n"),
919
argv[0], argv[optind - 1]);
920
nextchar += strlen (nextchar);
921
return optstring[0] == ':' ? ':' : '?';
924
nextchar += strlen (nextchar);
926
*longind = option_index;
929
*(pfound->flag) = pfound->val;
935
return 'W'; /* Let the application handle it. */
941
/* This is an option that accepts an argument optionally. */
942
if (*nextchar != '\0')
953
/* This is an option that requires an argument. */
954
if (*nextchar != '\0')
957
/* If we end this ARGV-element by taking the rest as an arg,
958
we must advance to the next element now. */
961
else if (optind == argc)
965
/* 1003.2 specifies the format of this message. */
967
_("%s: option requires an argument -- %c\n"),
971
if (optstring[0] == ':')
977
/* We already incremented `optind' once;
978
increment it again when taking next ARGV-elt as argument. */
979
optarg = argv[optind++];
988
getopt____ (argc, argv, optstring)
991
const char *optstring;
993
return _getopt_internal (argc, argv, optstring,
994
(const struct option *) 0,
999
#endif /* Not ELIDE_CODE. */
1003
/* Compile with -DTEST to make an executable for use in testing
1004
the above definition of `getopt'. */
1012
int digit_optind = 0;
1016
int this_option_optind = optind ? optind : 1;
1018
c = getopt (argc, argv, "abc:d:0123456789");
1034
if (digit_optind != 0 && digit_optind != this_option_optind)
1035
printf ("digits occur in two different argv-elements.\n");
1036
digit_optind = this_option_optind;
1037
printf ("option %c\n", c);
1041
printf ("option a\n");
1045
printf ("option b\n");
1049
printf ("option c with value `%s'\n", optarg);
1056
printf ("?? getopt returned character code 0%o ??\n", c);
1062
printf ("non-option ARGV-elements: ");
1063
while (optind < argc)
1064
printf ("%s ", argv[optind++]);
added
removed
getopt.c
