« back to all changes in this revision
Viewing changes to src/getopt.c
- browse files at revision 1
- compare with another revision
- download diff
- download tarball
- view history from revision 1
- Committer: Bazaar Package Importer
- Author(s): Noèl Köthe
- Date: 2004-02-13 20:26:44 UTC
- Revision ID: james.westby@ubuntu.com-20040213202644-skxj93qs15sskqfy
Tags: upstream-1.9.1
Import upstream version 1.9.1
- files added:
- ChangeLog-branches
- doc
- doc/ChangeLog-branches
- po
- src
- src/ChangeLog-branches
- util
- windows
added
removed
src/getopt.c
1
/* Getopt for GNU.
2
NOTE: The canonical source of this file is maintained with the GNU
3
C Library. Bugs can be reported to bug-glibc@gnu.org.
4
5
Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99
6
Free Software Foundation, Inc.
7
8
This program is free software; you can redistribute it and/or modify it
9
under the terms of the GNU General Public License as published by the
10
Free Software Foundation; either version 2, or (at your option) any
11
later version.
12
13
This program is distributed in the hope that it will be useful,
14
but WITHOUT ANY WARRANTY; without even the implied warranty of
15
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16
GNU General Public License for more details.
17
18
You should have received a copy of the GNU General Public License
19
along with this program; if not, write to the Free Software Foundation,
20
Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21
22
/* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
23
Ditto for AIX 3.2 and <stdlib.h>. */
24
#ifndef _NO_PROTO
25
# define _NO_PROTO
26
#endif
27
28
#ifdef HAVE_CONFIG_H
29
# include <config.h>
30
#else
31
# if !defined __STDC__ || !__STDC__
32
/* This is a separate conditional since some stdc systems
33
reject `defined (const)'. */
34
# ifndef const
35
# define const
36
# endif
37
# endif
38
#endif
39
40
#include <stdio.h>
41
42
/* Comment out all this code if we are using the GNU C Library, and are not
43
actually compiling the library itself. This code is part of the GNU C
44
Library, but also included in many other GNU distributions. Compiling
45
and linking in this code is a waste when using the GNU C library
46
(especially if it is a shared library). Rather than having every GNU
47
program understand `configure --with-gnu-libc' and omit the object files,
48
it is simpler to just do this in the source for each such file. */
49
50
#define GETOPT_INTERFACE_VERSION 2
51
#if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2
52
# include <gnu-versions.h>
53
# if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
54
# define ELIDE_CODE
55
# endif
56
#endif
57
58
#ifndef ELIDE_CODE
59
60
61
/* This needs to come after some library #include
62
to get __GNU_LIBRARY__ defined. */
63
#ifdef __GNU_LIBRARY__
64
/* Don't include stdlib.h for non-GNU C libraries because some of them
65
contain conflicting prototypes for getopt. */
66
# include <stdlib.h>
67
# include <unistd.h>
68
#endif /* GNU C library. */
69
70
#ifdef VMS
71
# include <unixlib.h>
72
# if HAVE_STRING_H - 0
73
# include <string.h>
74
# endif
75
#endif
76
77
#ifndef _
78
/* This is for other GNU distributions with internationalized messages.
79
When compiling libc, the _ macro is predefined. */
80
# ifdef HAVE_LIBINTL_H
81
# include <libintl.h>
82
# define _(msgid) gettext (msgid)
83
# else
84
# define _(msgid) (msgid)
85
# endif
86
#endif
87
88
/* This version of `getopt' appears to the caller like standard Unix `getopt'
89
but it behaves differently for the user, since it allows the user
90
to intersperse the options with the other arguments.
91
92
As `getopt' works, it permutes the elements of ARGV so that,
93
when it is done, all the options precede everything else. Thus
94
all application programs are extended to handle flexible argument order.
95
96
Setting the environment variable POSIXLY_CORRECT disables permutation.
97
Then the behavior is completely standard.
98
99
GNU application programs can use a third alternative mode in which
100
they can distinguish the relative order of options and other arguments. */
101
102
#include "getopt.h"
103
104
/* For communication from `getopt' to the caller.
105
When `getopt' finds an option that takes an argument,
106
the argument value is returned here.
107
Also, when `ordering' is RETURN_IN_ORDER,
108
each non-option ARGV-element is returned here. */
109
110
char *optarg;
111
112
/* Index in ARGV of the next element to be scanned.
113
This is used for communication to and from the caller
114
and for communication between successive calls to `getopt'.
115
116
On entry to `getopt', zero means this is the first call; initialize.
117
118
When `getopt' returns -1, this is the index of the first of the
119
non-option elements that the caller should itself scan.
120
121
Otherwise, `optind' communicates from one call to the next
122
how much of ARGV has been scanned so far. */
123
124
/* 1003.2 says this must be 1 before any call. */
125
int optind = 1;
126
127
/* Formerly, initialization of getopt depended on optind==0, which
128
causes problems with re-calling getopt as programs generally don't
129
know that. */
130
131
int __getopt_initialized;
132
133
/* The next char to be scanned in the option-element
134
in which the last option character we returned was found.
135
This allows us to pick up the scan where we left off.
136
137
If this is zero, or a null string, it means resume the scan
138
by advancing to the next ARGV-element. */
139
140
static char *nextchar;
141
142
/* Callers store zero here to inhibit the error message
143
for unrecognized options. */
144
145
int opterr = 1;
146
147
/* Set to an option character which was unrecognized.
148
This must be initialized on some systems to avoid linking in the
149
system's own getopt implementation. */
150
151
int optopt = '?';
152
153
/* Describe how to deal with options that follow non-option ARGV-elements.
154
155
If the caller did not specify anything,
156
the default is REQUIRE_ORDER if the environment variable
157
POSIXLY_CORRECT is defined, PERMUTE otherwise.
158
159
REQUIRE_ORDER means don't recognize them as options;
160
stop option processing when the first non-option is seen.
161
This is what Unix does.
162
This mode of operation is selected by either setting the environment
163
variable POSIXLY_CORRECT, or using `+' as the first character
164
of the list of option characters.
165
166
PERMUTE is the default. We permute the contents of ARGV as we scan,
167
so that eventually all the non-options are at the end. This allows options
168
to be given in any order, even with programs that were not written to
169
expect this.
170
171
RETURN_IN_ORDER is an option available to programs that were written
172
to expect options and other ARGV-elements in any order and that care about
173
the ordering of the two. We describe each non-option ARGV-element
174
as if it were the argument of an option with character code 1.
175
Using `-' as the first character of the list of option characters
176
selects this mode of operation.
177
178
The special argument `--' forces an end of option-scanning regardless
179
of the value of `ordering'. In the case of RETURN_IN_ORDER, only
180
`--' can cause `getopt' to return -1 with `optind' != ARGC. */
181
182
static enum
183
{
184
REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
185
} ordering;
186
187
/* Value of POSIXLY_CORRECT environment variable. */
188
static char *posixly_correct;
189
190
#ifdef __GNU_LIBRARY__
191
/* We want to avoid inclusion of string.h with non-GNU libraries
192
because there are many ways it can cause trouble.
193
On some systems, it contains special magic macros that don't work
194
in GCC. */
195
# include <string.h>
196
# define my_index strchr
197
#else
198
199
# if HAVE_STRING_H
200
# include <string.h>
201
# else
202
# include <strings.h>
203
# endif
204
205
/* Avoid depending on library functions or files
206
whose names are inconsistent. */
207
208
#ifndef getenv
209
extern char *getenv ();
210
#endif
211
212
static char *
213
my_index (str, chr)
214
const char *str;
215
int chr;
216
{
217
while (*str)
218
{
219
if (*str == chr)
220
return (char *) str;
221
str++;
222
}
223
return 0;
224
}
225
226
/* If using GCC, we can safely declare strlen this way.
227
If not using GCC, it is ok not to declare it. */
228
#ifdef __GNUC__
229
/* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h.
230
That was relevant to code that was here before. */
231
# if (!defined __STDC__ || !__STDC__) && !defined strlen
232
/* gcc with -traditional declares the built-in strlen to return int,
233
and has done so at least since version 2.4.5. -- rms. */
234
extern int strlen (const char *);
235
# endif /* not __STDC__ */
236
#endif /* __GNUC__ */
237
238
#endif /* not __GNU_LIBRARY__ */
239
240
/* Handle permutation of arguments. */
241
242
/* Describe the part of ARGV that contains non-options that have
243
been skipped. `first_nonopt' is the index in ARGV of the first of them;
244
`last_nonopt' is the index after the last of them. */
245
246
static int first_nonopt;
247
static int last_nonopt;
248
249
#ifdef _LIBC
250
/* Bash 2.0 gives us an environment variable containing flags
251
indicating ARGV elements that should not be considered arguments. */
252
253
/* Defined in getopt_init.c */
254
extern char *__getopt_nonoption_flags;
255
256
static int nonoption_flags_max_len;
257
static int nonoption_flags_len;
258
259
static int original_argc;
260
static char *const *original_argv;
261
262
/* Make sure the environment variable bash 2.0 puts in the environment
263
is valid for the getopt call we must make sure that the ARGV passed
264
to getopt is that one passed to the process. */
265
static void
266
__attribute__ ((unused))
267
store_args_and_env (int argc, char *const *argv)
268
{
269
/* XXX This is no good solution. We should rather copy the args so
270
that we can compare them later. But we must not use malloc(3). */
271
original_argc = argc;
272
original_argv = argv;
273
}
274
# ifdef text_set_element
275
text_set_element (__libc_subinit, store_args_and_env);
276
# endif /* text_set_element */
277
278
# define SWAP_FLAGS(ch1, ch2) \
279
if (nonoption_flags_len > 0) \
280
{ \
281
char __tmp = __getopt_nonoption_flags[ch1]; \
282
__getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2]; \
283
__getopt_nonoption_flags[ch2] = __tmp; \
284
}
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
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
#ifdef _LIBC
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 *
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
#ifdef _LIBC
421
if (posixly_correct == NULL
422
&& argc == original_argc && argv == original_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
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
optarg = NULL;
519
520
if (optind == 0 || !__getopt_initialized)
521
{
522
if (optind == 0)
523
optind = 1; /* Don't scan ARGV[0], the program name. */
524
optstring = _getopt_initialize (argc, argv, optstring);
525
__getopt_initialized = 1;
526
}
527
528
/* Test whether ARGV[optind] points to a non-option argument.
529
Either it does not have option syntax, or there is an environment flag
530
from the shell indicating it is not an option. The later information
531
is only used when the used in the GNU libc. */
532
#ifdef _LIBC
533
# define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0' \
534
|| (optind < nonoption_flags_len \
535
&& __getopt_nonoption_flags[optind] == '1'))
536
#else
537
# define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')
538
#endif
539
540
if (nextchar == NULL || *nextchar == '\0')
541
{
542
/* Advance to the next ARGV-element. */
543
544
/* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
545
moved back by the user (who may also have changed the arguments). */
546
if (last_nonopt > optind)
547
last_nonopt = optind;
548
if (first_nonopt > optind)
549
first_nonopt = optind;
550
551
if (ordering == PERMUTE)
552
{
553
/* If we have just processed some options following some non-options,
554
exchange them so that the options come first. */
555
556
if (first_nonopt != last_nonopt && last_nonopt != optind)
557
exchange ((char **) argv);
558
else if (last_nonopt != optind)
559
first_nonopt = optind;
560
561
/* Skip any additional non-options
562
and extend the range of non-options previously skipped. */
563
564
while (optind < argc && NONOPTION_P)
565
optind++;
566
last_nonopt = optind;
567
}
568
569
/* The special ARGV-element `--' means premature end of options.
570
Skip it like a null option,
571
then exchange with previous non-options as if it were an option,
572
then skip everything else like a non-option. */
573
574
if (optind != argc && !strcmp (argv[optind], "--"))
575
{
576
optind++;
577
578
if (first_nonopt != last_nonopt && last_nonopt != optind)
579
exchange ((char **) argv);
580
else if (first_nonopt == last_nonopt)
581
first_nonopt = optind;
582
last_nonopt = argc;
583
584
optind = argc;
585
}
586
587
/* If we have done all the ARGV-elements, stop the scan
588
and back over any non-options that we skipped and permuted. */
589
590
if (optind == argc)
591
{
592
/* Set the next-arg-index to point at the non-options
593
that we previously skipped, so the caller will digest them. */
594
if (first_nonopt != last_nonopt)
595
optind = first_nonopt;
596
return -1;
597
}
598
599
/* If we have come to a non-option and did not permute it,
600
either stop the scan or describe it to the caller and pass it by. */
601
602
if (NONOPTION_P)
603
{
604
if (ordering == REQUIRE_ORDER)
605
return -1;
606
optarg = argv[optind++];
607
return 1;
608
}
609
610
/* We have found another option-ARGV-element.
611
Skip the initial punctuation. */
612
613
nextchar = (argv[optind] + 1
614
+ (longopts != NULL && argv[optind][1] == '-'));
615
}
616
617
/* Decode the current option-ARGV-element. */
618
619
/* Check whether the ARGV-element is a long option.
620
621
If long_only and the ARGV-element has the form "-f", where f is
622
a valid short option, don't consider it an abbreviated form of
623
a long option that starts with f. Otherwise there would be no
624
way to give the -f short option.
625
626
On the other hand, if there's a long option "fubar" and
627
the ARGV-element is "-fu", do consider that an abbreviation of
628
the long option, just like "--fu", and not "-f" with arg "u".
629
630
This distinction seems to be the most useful approach. */
631
632
if (longopts != NULL
633
&& (argv[optind][1] == '-'
634
|| (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
635
{
636
char *nameend;
637
const struct option *p;
638
const struct option *pfound = NULL;
639
int exact = 0;
640
int ambig = 0;
641
int indfound = -1;
642
int option_index;
643
644
for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
645
/* Do nothing. */ ;
646
647
/* Test all long options for either exact match
648
or abbreviated matches. */
649
for (p = longopts, option_index = 0; p->name; p++, option_index++)
650
if (!strncmp (p->name, nextchar, nameend - nextchar))
651
{
652
if ((unsigned int) (nameend - nextchar)
653
== (unsigned int) strlen (p->name))
654
{
655
/* Exact match found. */
656
pfound = p;
657
indfound = option_index;
658
exact = 1;
659
break;
660
}
661
else if (pfound == NULL)
662
{
663
/* First nonexact match found. */
664
pfound = p;
665
indfound = option_index;
666
}
667
else
668
/* Second or later nonexact match found. */
669
ambig = 1;
670
}
671
672
if (ambig && !exact)
673
{
674
if (opterr)
675
fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
676
argv[0], argv[optind]);
677
nextchar += strlen (nextchar);
678
optind++;
679
optopt = 0;
680
return '?';
681
}
682
683
if (pfound != NULL)
684
{
685
option_index = indfound;
686
optind++;
687
if (*nameend)
688
{
689
/* Don't test has_arg with >, because some C compilers don't
690
allow it to be used on enums. */
691
if (pfound->has_arg)
692
optarg = nameend + 1;
693
else
694
{
695
if (opterr)
696
{
697
if (argv[optind - 1][1] == '-')
698
/* --option */
699
fprintf (stderr,
700
_("%s: option `--%s' doesn't allow an argument\n"),
701
argv[0], pfound->name);
702
else
703
/* +option or -option */
704
fprintf (stderr,
705
_("%s: option `%c%s' doesn't allow an argument\n"),
706
argv[0], argv[optind - 1][0], pfound->name);
707
}
708
709
nextchar += strlen (nextchar);
710
711
optopt = pfound->val;
712
return '?';
713
}
714
}
715
else if (pfound->has_arg == 1)
716
{
717
if (optind < argc)
718
optarg = argv[optind++];
719
else
720
{
721
if (opterr)
722
fprintf (stderr,
723
_("%s: option `%s' requires an argument\n"),
724
argv[0], argv[optind - 1]);
725
nextchar += strlen (nextchar);
726
optopt = pfound->val;
727
return optstring[0] == ':' ? ':' : '?';
728
}
729
}
730
nextchar += strlen (nextchar);
731
if (longind != NULL)
732
*longind = option_index;
733
if (pfound->flag)
734
{
735
*(pfound->flag) = pfound->val;
736
return 0;
737
}
738
return pfound->val;
739
}
740
741
/* Can't find it as a long option. If this is not getopt_long_only,
742
or the option starts with '--' or is not a valid short
743
option, then it's an error.
744
Otherwise interpret it as a short option. */
745
if (!long_only || argv[optind][1] == '-'
746
|| my_index (optstring, *nextchar) == NULL)
747
{
748
if (opterr)
749
{
750
if (argv[optind][1] == '-')
751
/* --option */
752
fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
753
argv[0], nextchar);
754
else
755
/* +option or -option */
756
fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
757
argv[0], argv[optind][0], nextchar);
758
}
759
nextchar = (char *) "";
760
optind++;
761
optopt = 0;
762
return '?';
763
}
764
}
765
766
/* Look at and handle the next short option-character. */
767
768
{
769
char c = *nextchar++;
770
char *temp = my_index (optstring, c);
771
772
/* Increment `optind' when we start to process its last character. */
773
if (*nextchar == '\0')
774
++optind;
775
776
if (temp == NULL || c == ':')
777
{
778
if (opterr)
779
{
780
if (posixly_correct)
781
/* 1003.2 specifies the format of this message. */
782
fprintf (stderr, _("%s: illegal option -- %c\n"),
783
argv[0], c);
784
else
785
fprintf (stderr, _("%s: invalid option -- %c\n"),
786
argv[0], c);
787
}
788
optopt = c;
789
return '?';
790
}
791
/* Convenience. Treat POSIX -W foo same as long option --foo */
792
if (temp[0] == 'W' && temp[1] == ';')
793
{
794
char *nameend;
795
const struct option *p;
796
const struct option *pfound = NULL;
797
int exact = 0;
798
int ambig = 0;
799
int indfound = 0;
800
int option_index;
801
802
/* This is an option that requires an argument. */
803
if (*nextchar != '\0')
804
{
805
optarg = nextchar;
806
/* If we end this ARGV-element by taking the rest as an arg,
807
we must advance to the next element now. */
808
optind++;
809
}
810
else if (optind == argc)
811
{
812
if (opterr)
813
{
814
/* 1003.2 specifies the format of this message. */
815
fprintf (stderr, _("%s: option requires an argument -- %c\n"),
816
argv[0], c);
817
}
818
optopt = c;
819
if (optstring[0] == ':')
820
c = ':';
821
else
822
c = '?';
823
return c;
824
}
825
else
826
/* We already incremented `optind' once;
827
increment it again when taking next ARGV-elt as argument. */
828
optarg = argv[optind++];
829
830
/* optarg is now the argument, see if it's in the
831
table of longopts. */
832
833
for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++)
834
/* Do nothing. */ ;
835
836
/* Test all long options for either exact match
837
or abbreviated matches. */
838
for (p = longopts, option_index = 0; p->name; p++, option_index++)
839
if (!strncmp (p->name, nextchar, nameend - nextchar))
840
{
841
if ((unsigned int) (nameend - nextchar) == strlen (p->name))
842
{
843
/* Exact match found. */
844
pfound = p;
845
indfound = option_index;
846
exact = 1;
847
break;
848
}
849
else if (pfound == NULL)
850
{
851
/* First nonexact match found. */
852
pfound = p;
853
indfound = option_index;
854
}
855
else
856
/* Second or later nonexact match found. */
857
ambig = 1;
858
}
859
if (ambig && !exact)
860
{
861
if (opterr)
862
fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
863
argv[0], argv[optind]);
864
nextchar += strlen (nextchar);
865
optind++;
866
return '?';
867
}
868
if (pfound != NULL)
869
{
870
option_index = indfound;
871
if (*nameend)
872
{
873
/* Don't test has_arg with >, because some C compilers don't
874
allow it to be used on enums. */
875
if (pfound->has_arg)
876
optarg = nameend + 1;
877
else
878
{
879
if (opterr)
880
fprintf (stderr, _("\
881
%s: option `-W %s' doesn't allow an argument\n"),
882
argv[0], pfound->name);
883
884
nextchar += strlen (nextchar);
885
return '?';
886
}
887
}
888
else if (pfound->has_arg == 1)
889
{
890
if (optind < argc)
891
optarg = argv[optind++];
892
else
893
{
894
if (opterr)
895
fprintf (stderr,
896
_("%s: option `%s' requires an argument\n"),
897
argv[0], argv[optind - 1]);
898
nextchar += strlen (nextchar);
899
return optstring[0] == ':' ? ':' : '?';
900
}
901
}
902
nextchar += strlen (nextchar);
903
if (longind != NULL)
904
*longind = option_index;
905
if (pfound->flag)
906
{
907
*(pfound->flag) = pfound->val;
908
return 0;
909
}
910
return pfound->val;
911
}
912
nextchar = NULL;
913
return 'W'; /* Let the application handle it. */
914
}
915
if (temp[1] == ':')
916
{
917
if (temp[2] == ':')
918
{
919
/* This is an option that accepts an argument optionally. */
920
if (*nextchar != '\0')
921
{
922
optarg = nextchar;
923
optind++;
924
}
925
else
926
optarg = NULL;
927
nextchar = NULL;
928
}
929
else
930
{
931
/* This is an option that requires an argument. */
932
if (*nextchar != '\0')
933
{
934
optarg = nextchar;
935
/* If we end this ARGV-element by taking the rest as an arg,
936
we must advance to the next element now. */
937
optind++;
938
}
939
else if (optind == argc)
940
{
941
if (opterr)
942
{
943
/* 1003.2 specifies the format of this message. */
944
fprintf (stderr,
945
_("%s: option requires an argument -- %c\n"),
946
argv[0], c);
947
}
948
optopt = c;
949
if (optstring[0] == ':')
950
c = ':';
951
else
952
c = '?';
953
}
954
else
955
/* We already incremented `optind' once;
956
increment it again when taking next ARGV-elt as argument. */
957
optarg = argv[optind++];
958
nextchar = NULL;
959
}
960
}
961
return c;
962
}
963
}
964
965
int
966
getopt (argc, argv, optstring)
967
int argc;
968
char *const *argv;
969
const char *optstring;
970
{
971
return _getopt_internal (argc, argv, optstring,
972
(const struct option *) 0,
973
(int *) 0,
974
0);
975
}
976
977
int
978
getopt_long (argc, argv, options, long_options, opt_index)
979
int argc;
980
char *const *argv;
981
const char *options;
982
const struct option *long_options;
983
int *opt_index;
984
{
985
return _getopt_internal (argc, argv, options, long_options, opt_index, 0);
986
}
987
988
/* Like getopt_long, but '-' as well as '--' can indicate a long option.
989
If an option that starts with '-' (not '--') doesn't match a long option,
990
but does match a short option, it is parsed as a short option
991
instead. */
992
993
int
994
getopt_long_only (argc, argv, options, long_options, opt_index)
995
int argc;
996
char *const *argv;
997
const char *options;
998
const struct option *long_options;
999
int *opt_index;
1000
{
1001
return _getopt_internal (argc, argv, options, long_options, opt_index, 1);
1002
}
1003
1004
#endif /* Not ELIDE_CODE. */
1005
1006
#ifdef TEST
1007
1008
/* Compile with -DTEST to make an executable for use in testing
1009
the above definition of `getopt'. */
1010
1011
int
1012
main (argc, argv)
1013
int argc;
1014
char **argv;
1015
{
1016
int c;
1017
int digit_optind = 0;
1018
1019
while (1)
1020
{
1021
int this_option_optind = optind ? optind : 1;
1022
1023
c = getopt (argc, argv, "abc:d:0123456789");
1024
if (c == -1)
1025
break;
1026
1027
switch (c)
1028
{
1029
case '0':
1030
case '1':
1031
case '2':
1032
case '3':
1033
case '4':
1034
case '5':
1035
case '6':
1036
case '7':
1037
case '8':
1038
case '9':
1039
if (digit_optind != 0 && digit_optind != this_option_optind)
1040
printf ("digits occur in two different argv-elements.\n");
1041
digit_optind = this_option_optind;
1042
printf ("option %c\n", c);
1043
break;
1044
1045
case 'a':
1046
printf ("option a\n");
1047
break;
1048
1049
case 'b':
1050
printf ("option b\n");
1051
break;
1052
1053
case 'c':
1054
printf ("option c with value `%s'\n", optarg);
1055
break;
1056
1057
case '?':
1058
break;
1059
1060
default:
1061
printf ("?? getopt returned character code 0%o ??\n", c);
1062
}
1063
}
1064
1065
if (optind < argc)
1066
{
1067
printf ("non-option ARGV-elements: ");
1068
while (optind < argc)
1069
printf ("%s ", argv[optind++]);
1070
printf ("\n");
1071
}
1072
1073
exit (0);
1074
}
1075
1076
#endif /* TEST */
Loggerhead is a web-based interface for Breezy
Version: 2.0.1