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