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