« back to all changes in this revision
Viewing changes to getopt.c
- browse files at revision 4
- compare with another revision
- download diff
- download tarball
- view history from revision 4
- Committer: Bazaar Package Importer
- Author(s): Lior Kaplan
- Date: 2006-09-16 10:37:10 UTC
- mfrom: (3.1.3 edgy)
- Revision ID: james.westby@ubuntu.com-20060916103710-1ktngzyx9azkujhl
Tags: 0.10.7-4
* Fix manual page name section (Closes: #368632)
* debian/control: Upgrade standards version to 3.7.2 (no changes needed).
* debian/copyright: Update Dov Grobgeld's contact address.
* debian/control: Upgrade standards version to 3.7.2 (no changes needed).
* debian/copyright: Update Dov Grobgeld's contact address.
- files added:
- AUTHORS
- tests
- unidata
- files removed:
- debian/libfribidi0.shlibs
- patches
- files modified:
- Makefile
added
removed
getopt.c
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 02111-1307, 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 */
Loggerhead is a web-based interface for Breezy
Version: 2.0.1