Mercurial > audlegacy
annotate audacious/getopt.c @ 1808:ae21feb9459c trunk
[svn] - make sure all size requests match the skin size
author | nenolod |
---|---|
date | Wed, 04 Oct 2006 23:05:41 -0700 |
parents | 837983bac90f |
children |
rev | line source |
---|---|
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 roland@gnu.ai.mit.edu | |
4 before changing it! | |
5 | |
6 Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97 | |
7 Free Software Foundation, Inc. | |
8 | |
9 This file is part of the GNU C Library. Its master source is NOT part of | |
10 the C library, however. The master source lives in /gd/gnu/lib. | |
11 | |
12 The GNU C Library is free software; you can redistribute it and/or | |
13 modify it under the terms of the GNU Library General Public License as | |
14 published by the Free Software Foundation; either version 2 of the | |
15 License, or (at your option) any later version. | |
16 | |
17 The GNU C Library is distributed in the hope that it will be useful, | |
18 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
20 Library General Public License for more details. | |
21 | |
22 You should have received a copy of the GNU Library General Public | |
23 License along with the GNU C Library; see the file COPYING.LIB. If not, | |
1458
f12d7e208b43
[svn] Update FSF address in copyright notices. Update autotools templates.
chainsaw
parents:
0
diff
changeset
|
24 write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, |
1459 | 25 Boston, MA 02110-1301, USA. */ |
0 | 26 |
27 /* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>. | |
28 Ditto for AIX 3.2 and <stdlib.h>. */ | |
29 #ifndef _NO_PROTO | |
30 #define _NO_PROTO | |
31 #endif | |
32 | |
33 #ifdef HAVE_CONFIG_H | |
34 #include <config.h> | |
35 #endif | |
36 | |
37 #if !defined (__STDC__) || !__STDC__ | |
38 /* This is a separate conditional since some stdc systems | |
39 reject `defined (const)'. */ | |
40 #ifndef const | |
41 #define const | |
42 #endif | |
43 #endif | |
44 | |
45 #include <stdio.h> | |
46 #include <string.h> | |
47 | |
48 /* Comment out all this code if we are using the GNU C Library, and are not | |
49 actually compiling the library itself. This code is part of the GNU C | |
50 Library, but also included in many other GNU distributions. Compiling | |
51 and linking in this code is a waste when using the GNU C library | |
52 (especially if it is a shared library). Rather than having every GNU | |
53 program understand `configure --with-gnu-libc' and omit the object files, | |
54 it is simpler to just do this in the source for each such file. */ | |
55 | |
56 #define GETOPT_INTERFACE_VERSION 2 | |
57 #if !defined (_LIBC) && defined (__GLIBC__) && __GLIBC__ >= 2 | |
58 #include <gnu-versions.h> | |
59 #if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION | |
60 #define ELIDE_CODE | |
61 #endif | |
62 #endif | |
63 | |
64 #ifndef ELIDE_CODE | |
65 | |
66 /* This needs to come after some library #include | |
67 to get __GNU_LIBRARY__ defined. */ | |
68 #ifdef __GNU_LIBRARY__ | |
69 /* Don't include stdlib.h for non-GNU C libraries because some of them | |
70 contain conflicting prototypes for getopt. */ | |
71 #include <stdlib.h> | |
72 #include <unistd.h> | |
73 #endif /* GNU C library. */ | |
74 | |
75 #ifdef VMS | |
76 #include <unixlib.h> | |
77 #if HAVE_STRING_H - 0 | |
78 #include <string.h> | |
79 #endif | |
80 #endif | |
81 | |
82 #if defined (WIN32) && !defined (__CYGWIN32__) | |
83 /* It's not Unix, really. See? Capital letters. */ | |
84 #include <windows.h> | |
85 #define getpid() GetCurrentProcessId() | |
86 #endif | |
87 | |
88 #ifndef _ | |
89 /* This is for other GNU distributions with internationalized messages. | |
90 When compiling libc, the _ macro is predefined. */ | |
91 #ifdef HAVE_LIBINTL_H | |
92 #include <libintl.h> | |
93 #define _(msgid) gettext (msgid) | |
94 #else | |
95 #define _(msgid) (msgid) | |
96 #endif | |
97 #endif | |
98 | |
99 /* This version of `getopt' appears to the caller like standard Unix `getopt' | |
100 but it behaves differently for the user, since it allows the user | |
101 to intersperse the options with the other arguments. | |
102 | |
103 As `getopt' works, it permutes the elements of ARGV so that, | |
104 when it is done, all the options precede everything else. Thus | |
105 all application programs are extended to handle flexible argument order. | |
106 | |
107 Setting the environment variable POSIXLY_CORRECT disables permutation. | |
108 Then the behavior is completely standard. | |
109 | |
110 GNU application programs can use a third alternative mode in which | |
111 they can distinguish the relative order of options and other arguments. */ | |
112 | |
113 #include "getopt.h" | |
114 | |
115 /* For communication from `getopt' to the caller. | |
116 When `getopt' finds an option that takes an argument, | |
117 the argument value is returned here. | |
118 Also, when `ordering' is RETURN_IN_ORDER, | |
119 each non-option ARGV-element is returned here. */ | |
120 | |
121 char *optarg = NULL; | |
122 | |
123 /* Index in ARGV of the next element to be scanned. | |
124 This is used for communication to and from the caller | |
125 and for communication between successive calls to `getopt'. | |
126 | |
127 On entry to `getopt', zero means this is the first call; initialize. | |
128 | |
129 When `getopt' returns -1, this is the index of the first of the | |
130 non-option elements that the caller should itself scan. | |
131 | |
132 Otherwise, `optind' communicates from one call to the next | |
133 how much of ARGV has been scanned so far. */ | |
134 | |
135 /* 1003.2 says this must be 1 before any call. */ | |
136 int optind = 1; | |
137 | |
138 /* Formerly, initialization of getopt depended on optind==0, which | |
139 causes problems with re-calling getopt as programs generally don't | |
140 know that. */ | |
141 | |
142 int __getopt_initialized = 0; | |
143 | |
144 /* The next char to be scanned in the option-element | |
145 in which the last option character we returned was found. | |
146 This allows us to pick up the scan where we left off. | |
147 | |
148 If this is zero, or a null string, it means resume the scan | |
149 by advancing to the next ARGV-element. */ | |
150 | |
151 static char *nextchar; | |
152 | |
153 /* Callers store zero here to inhibit the error message | |
154 for unrecognized options. */ | |
155 | |
156 int opterr = 1; | |
157 | |
158 /* Set to an option character which was unrecognized. | |
159 This must be initialized on some systems to avoid linking in the | |
160 system's own getopt implementation. */ | |
161 | |
162 int optopt = '?'; | |
163 | |
164 /* Describe how to deal with options that follow non-option ARGV-elements. | |
165 | |
166 If the caller did not specify anything, | |
167 the default is REQUIRE_ORDER if the environment variable | |
168 POSIXLY_CORRECT is defined, PERMUTE otherwise. | |
169 | |
170 REQUIRE_ORDER means don't recognize them as options; | |
171 stop option processing when the first non-option is seen. | |
172 This is what Unix does. | |
173 This mode of operation is selected by either setting the environment | |
174 variable POSIXLY_CORRECT, or using `+' as the first character | |
175 of the list of option characters. | |
176 | |
177 PERMUTE is the default. We permute the contents of ARGV as we scan, | |
178 so that eventually all the non-options are at the end. This allows options | |
179 to be given in any order, even with programs that were not written to | |
180 expect this. | |
181 | |
182 RETURN_IN_ORDER is an option available to programs that were written | |
183 to expect options and other ARGV-elements in any order and that care about | |
184 the ordering of the two. We describe each non-option ARGV-element | |
185 as if it were the argument of an option with character code 1. | |
186 Using `-' as the first character of the list of option characters | |
187 selects this mode of operation. | |
188 | |
189 The special argument `--' forces an end of option-scanning regardless | |
190 of the value of `ordering'. In the case of RETURN_IN_ORDER, only | |
191 `--' can cause `getopt' to return -1 with `optind' != ARGC. */ | |
192 | |
193 static enum { | |
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 /* Avoid depending on library functions or files | |
210 whose names are inconsistent. */ | |
211 | |
212 char *getenv(); | |
213 | |
214 static char * | |
215 my_index(str, chr) | |
216 const char *str; | |
217 int chr; | |
218 { | |
219 while (*str) { | |
220 if (*str == chr) | |
221 return (char *) str; | |
222 str++; | |
223 } | |
224 return 0; | |
225 } | |
226 | |
227 /* If using GCC, we can safely declare strlen this way. | |
228 If not using GCC, it is ok not to declare it. */ | |
229 #ifdef __GNUC__ | |
230 /* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h. | |
231 That was relevant to code that was here before. */ | |
232 #if !defined (__STDC__) || !__STDC__ | |
233 /* gcc with -traditional declares the built-in strlen to return int, | |
234 and has done so at least since version 2.4.5. -- rms. */ | |
235 extern int strlen(const char *); | |
236 | |
237 #endif /* not __STDC__ */ | |
238 #endif /* __GNUC__ */ | |
239 | |
240 #endif /* not __GNU_LIBRARY__ */ | |
241 | |
242 /* Handle permutation of arguments. */ | |
243 | |
244 /* Describe the part of ARGV that contains non-options that have | |
245 been skipped. `first_nonopt' is the index in ARGV of the first of them; | |
246 `last_nonopt' is the index after the last of them. */ | |
247 | |
248 static int first_nonopt; | |
249 static int last_nonopt; | |
250 | |
251 #ifdef _LIBC | |
252 /* Bash 2.0 gives us an environment variable containing flags | |
253 indicating ARGV elements that should not be considered arguments. */ | |
254 | |
255 static const char *nonoption_flags; | |
256 static int nonoption_flags_len; | |
257 | |
258 static int original_argc; | |
259 static char *const *original_argv; | |
260 | |
261 /* Make sure the environment variable bash 2.0 puts in the environment | |
262 is valid for the getopt call we must make sure that the ARGV passed | |
263 to getopt is that one passed to the process. */ | |
264 static void store_args(int argc, char *const *argv) | |
265 __attribute__ ((unused)); | |
266 static void | |
267 store_args(int argc, char *const *argv) | |
268 { | |
269 /* XXX This is no good solution. We should rather copy the args so | |
270 that we can compare them later. But we must not use malloc(3). */ | |
271 original_argc = argc; | |
272 original_argv = argv; | |
273 } | |
274 | |
275 text_set_element(__libc_subinit, store_args); | |
276 #endif | |
277 | |
278 /* Exchange two adjacent subsequences of ARGV. | |
279 One subsequence is elements [first_nonopt,last_nonopt) | |
280 which contains all the non-options that have been skipped so far. | |
281 The other is elements [last_nonopt,optind), which contains all | |
282 the options processed since those non-options were skipped. | |
283 | |
284 `first_nonopt' and `last_nonopt' are relocated so that they describe | |
285 the new indices of the non-options in ARGV after they are moved. */ | |
286 | |
287 #if defined (__STDC__) && __STDC__ | |
288 static void exchange(char **); | |
289 | |
290 #endif | |
291 | |
292 static void | |
293 exchange(argv) | |
294 char **argv; | |
295 { | |
296 int bottom = first_nonopt; | |
297 int middle = last_nonopt; | |
298 int top = optind; | |
299 char *tem; | |
300 | |
301 /* Exchange the shorter segment with the far end of the longer segment. | |
302 That puts the shorter segment into the right place. | |
303 It leaves the longer segment in the right place overall, | |
304 but it consists of two parts that need to be swapped next. */ | |
305 | |
306 while (top > middle && middle > bottom) { | |
307 if (top - middle > middle - bottom) { | |
308 /* Bottom segment is the short one. */ | |
309 int len = middle - bottom; | |
310 register int i; | |
311 | |
312 /* Swap it with the top part of the top segment. */ | |
313 for (i = 0; i < len; i++) { | |
314 tem = argv[bottom + i]; | |
315 argv[bottom + i] = argv[top - (middle - bottom) + i]; | |
316 argv[top - (middle - bottom) + i] = tem; | |
317 } | |
318 /* Exclude the moved bottom segment from further swapping. */ | |
319 top -= len; | |
320 } | |
321 else { | |
322 /* Top segment is the short one. */ | |
323 int len = top - middle; | |
324 register int i; | |
325 | |
326 /* Swap it with the bottom part of the bottom segment. */ | |
327 for (i = 0; i < len; i++) { | |
328 tem = argv[bottom + i]; | |
329 argv[bottom + i] = argv[middle + i]; | |
330 argv[middle + i] = tem; | |
331 } | |
332 /* Exclude the moved top segment from further swapping. */ | |
333 bottom += len; | |
334 } | |
335 } | |
336 | |
337 /* Update records for the slots the non-options now occupy. */ | |
338 | |
339 first_nonopt += (optind - last_nonopt); | |
340 last_nonopt = optind; | |
341 } | |
342 | |
343 /* Initialize the internal data when the first call is made. */ | |
344 | |
345 #if defined (__STDC__) && __STDC__ | |
346 static const char *_getopt_initialize(int, char *const *, const char *); | |
347 | |
348 #endif | |
349 static const char * | |
350 _getopt_initialize(argc, argv, optstring) | |
351 int argc; | |
352 char *const *argv; | |
353 const char *optstring; | |
354 { | |
355 /* Start processing options with ARGV-element 1 (since ARGV-element 0 | |
356 is the program name); the sequence of previously skipped | |
357 non-option ARGV-elements is empty. */ | |
358 | |
359 first_nonopt = last_nonopt = optind = 1; | |
360 | |
361 nextchar = NULL; | |
362 | |
363 posixly_correct = getenv("POSIXLY_CORRECT"); | |
364 | |
365 /* Determine how to handle the ordering of options and nonoptions. */ | |
366 | |
367 if (optstring[0] == '-') { | |
368 ordering = RETURN_IN_ORDER; | |
369 ++optstring; | |
370 } | |
371 else if (optstring[0] == '+') { | |
372 ordering = REQUIRE_ORDER; | |
373 ++optstring; | |
374 } | |
375 else if (posixly_correct != NULL) | |
376 ordering = REQUIRE_ORDER; | |
377 else | |
378 ordering = PERMUTE; | |
379 | |
380 #ifdef _LIBC | |
381 if (posixly_correct == NULL | |
382 && argc == original_argc && argv == original_argv) { | |
383 /* Bash 2.0 puts a special variable in the environment for each | |
384 command it runs, specifying which ARGV elements are the results of | |
385 file name wildcard expansion and therefore should not be | |
386 considered as options. */ | |
387 char var[100]; | |
388 | |
389 sprintf(var, "_%d_GNU_nonoption_argv_flags_", getpid()); | |
390 nonoption_flags = getenv(var); | |
391 if (nonoption_flags == NULL) | |
392 nonoption_flags_len = 0; | |
393 else | |
394 nonoption_flags_len = strlen(nonoption_flags); | |
395 } | |
396 else | |
397 nonoption_flags_len = 0; | |
398 #endif | |
399 | |
400 return optstring; | |
401 } | |
402 | |
403 /* Scan elements of ARGV (whose length is ARGC) for option characters | |
404 given in OPTSTRING. | |
405 | |
406 If an element of ARGV starts with '-', and is not exactly "-" or "--", | |
407 then it is an option element. The characters of this element | |
408 (aside from the initial '-') are option characters. If `getopt' | |
409 is called repeatedly, it returns successively each of the option characters | |
410 from each of the option elements. | |
411 | |
412 If `getopt' finds another option character, it returns that character, | |
413 updating `optind' and `nextchar' so that the next call to `getopt' can | |
414 resume the scan with the following option character or ARGV-element. | |
415 | |
416 If there are no more option characters, `getopt' returns -1. | |
417 Then `optind' is the index in ARGV of the first ARGV-element | |
418 that is not an option. (The ARGV-elements have been permuted | |
419 so that those that are not options now come last.) | |
420 | |
421 OPTSTRING is a string containing the legitimate option characters. | |
422 If an option character is seen that is not listed in OPTSTRING, | |
423 return '?' after printing an error message. If you set `opterr' to | |
424 zero, the error message is suppressed but we still return '?'. | |
425 | |
426 If a char in OPTSTRING is followed by a colon, that means it wants an arg, | |
427 so the following text in the same ARGV-element, or the text of the following | |
428 ARGV-element, is returned in `optarg'. Two colons mean an option that | |
429 wants an optional arg; if there is text in the current ARGV-element, | |
430 it is returned in `optarg', otherwise `optarg' is set to zero. | |
431 | |
432 If OPTSTRING starts with `-' or `+', it requests different methods of | |
433 handling the non-option ARGV-elements. | |
434 See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above. | |
435 | |
436 Long-named options begin with `--' instead of `-'. | |
437 Their names may be abbreviated as long as the abbreviation is unique | |
438 or is an exact match for some defined option. If they have an | |
439 argument, it follows the option name in the same ARGV-element, separated | |
440 from the option name by a `=', or else the in next ARGV-element. | |
441 When `getopt' finds a long-named option, it returns 0 if that option's | |
442 `flag' field is nonzero, the value of the option's `val' field | |
443 if the `flag' field is zero. | |
444 | |
445 The elements of ARGV aren't really const, because we permute them. | |
446 But we pretend they're const in the prototype to be compatible | |
447 with other systems. | |
448 | |
449 LONGOPTS is a vector of `struct option' terminated by an | |
450 element containing a name which is zero. | |
451 | |
452 LONGIND returns the index in LONGOPT of the long-named option found. | |
453 It is only valid when a long-named option has been found by the most | |
454 recent call. | |
455 | |
456 If LONG_ONLY is nonzero, '-' as well as '--' can introduce | |
457 long-named options. */ | |
458 | |
459 int | |
460 _getopt_internal(argc, argv, optstring, longopts, longind, long_only) | |
461 int argc; | |
462 char *const *argv; | |
463 const char *optstring; | |
464 const struct option *longopts; | |
465 int *longind; | |
466 int long_only; | |
467 { | |
468 optarg = NULL; | |
469 | |
470 if (!__getopt_initialized || optind == 0) { | |
471 optstring = _getopt_initialize(argc, argv, optstring); | |
472 optind = 1; /* Don't scan ARGV[0], the program name. */ | |
473 __getopt_initialized = 1; | |
474 } | |
475 | |
476 /* Test whether ARGV[optind] points to a non-option argument. | |
477 Either it does not have option syntax, or there is an environment flag | |
478 from the shell indicating it is not an option. The later information | |
479 is only used when the used in the GNU libc. */ | |
480 #ifdef _LIBC | |
481 #define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0' \ | |
482 || (optind < nonoption_flags_len \ | |
483 && nonoption_flags[optind] == '1')) | |
484 #else | |
485 #define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0') | |
486 #endif | |
487 | |
488 if (nextchar == NULL || *nextchar == '\0') { | |
489 /* Advance to the next ARGV-element. */ | |
490 | |
491 /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been | |
492 moved back by the user (who may also have changed the arguments). */ | |
493 if (last_nonopt > optind) | |
494 last_nonopt = optind; | |
495 if (first_nonopt > optind) | |
496 first_nonopt = optind; | |
497 | |
498 if (ordering == PERMUTE) { | |
499 /* If we have just processed some options following some non-options, | |
500 exchange them so that the options come first. */ | |
501 | |
502 if (first_nonopt != last_nonopt && last_nonopt != optind) | |
503 exchange((char **) argv); | |
504 else if (last_nonopt != optind) | |
505 first_nonopt = optind; | |
506 | |
507 /* Skip any additional non-options | |
508 and extend the range of non-options previously skipped. */ | |
509 | |
510 while (optind < argc && NONOPTION_P) | |
511 optind++; | |
512 last_nonopt = optind; | |
513 } | |
514 | |
515 /* The special ARGV-element `--' means premature end of options. | |
516 Skip it like a null option, | |
517 then exchange with previous non-options as if it were an option, | |
518 then skip everything else like a non-option. */ | |
519 | |
520 if (optind != argc && !strcmp(argv[optind], "--")) { | |
521 optind++; | |
522 | |
523 if (first_nonopt != last_nonopt && last_nonopt != optind) | |
524 exchange((char **) argv); | |
525 else if (first_nonopt == last_nonopt) | |
526 first_nonopt = optind; | |
527 last_nonopt = argc; | |
528 | |
529 optind = argc; | |
530 } | |
531 | |
532 /* If we have done all the ARGV-elements, stop the scan | |
533 and back over any non-options that we skipped and permuted. */ | |
534 | |
535 if (optind == argc) { | |
536 /* Set the next-arg-index to point at the non-options | |
537 that we previously skipped, so the caller will digest them. */ | |
538 if (first_nonopt != last_nonopt) | |
539 optind = first_nonopt; | |
540 return -1; | |
541 } | |
542 | |
543 /* If we have come to a non-option and did not permute it, | |
544 either stop the scan or describe it to the caller and pass it by. */ | |
545 | |
546 if (NONOPTION_P) { | |
547 if (ordering == REQUIRE_ORDER) | |
548 return -1; | |
549 optarg = argv[optind++]; | |
550 return 1; | |
551 } | |
552 | |
553 /* We have found another option-ARGV-element. | |
554 Skip the initial punctuation. */ | |
555 | |
556 nextchar = (argv[optind] + 1 | |
557 + (longopts != NULL && argv[optind][1] == '-')); | |
558 } | |
559 | |
560 /* Decode the current option-ARGV-element. */ | |
561 | |
562 /* Check whether the ARGV-element is a long option. | |
563 | |
564 If long_only and the ARGV-element has the form "-f", where f is | |
565 a valid short option, don't consider it an abbreviated form of | |
566 a long option that starts with f. Otherwise there would be no | |
567 way to give the -f short option. | |
568 | |
569 On the other hand, if there's a long option "fubar" and | |
570 the ARGV-element is "-fu", do consider that an abbreviation of | |
571 the long option, just like "--fu", and not "-f" with arg "u". | |
572 | |
573 This distinction seems to be the most useful approach. */ | |
574 | |
575 if (longopts != NULL | |
576 && (argv[optind][1] == '-' || (long_only && (argv[optind][2] | |
577 || | |
578 !my_index(optstring, | |
579 argv[optind] | |
580 [1]))))) { | |
581 char *nameend; | |
582 const struct option *p; | |
583 const struct option *pfound = NULL; | |
584 int exact = 0; | |
585 int ambig = 0; | |
586 int indfound = -1; | |
587 int option_index; | |
588 | |
589 for (nameend = nextchar; *nameend && *nameend != '='; nameend++) | |
590 /* Do nothing. */ ; | |
591 | |
592 /* Test all long options for either exact match | |
593 or abbreviated matches. */ | |
594 for (p = longopts, option_index = 0; p->name; p++, option_index++) | |
595 if (!strncmp(p->name, nextchar, nameend - nextchar)) { | |
596 if ((unsigned int) (nameend - nextchar) | |
597 == (unsigned int) strlen(p->name)) { | |
598 /* Exact match found. */ | |
599 pfound = p; | |
600 indfound = option_index; | |
601 exact = 1; | |
602 break; | |
603 } | |
604 else if (pfound == NULL) { | |
605 /* First nonexact match found. */ | |
606 pfound = p; | |
607 indfound = option_index; | |
608 } | |
609 else | |
610 /* Second or later nonexact match found. */ | |
611 ambig = 1; | |
612 } | |
613 | |
614 if (ambig && !exact) { | |
615 if (opterr) | |
616 fprintf(stderr, _("%s: option `%s' is ambiguous\n"), | |
617 argv[0], argv[optind]); | |
618 nextchar += strlen(nextchar); | |
619 optind++; | |
620 optopt = 0; | |
621 return '?'; | |
622 } | |
623 | |
624 if (pfound != NULL) { | |
625 option_index = indfound; | |
626 optind++; | |
627 if (*nameend) { | |
628 /* Don't test has_arg with >, because some C compilers don't | |
629 allow it to be used on enums. */ | |
630 if (pfound->has_arg) | |
631 optarg = nameend + 1; | |
632 else { | |
1717
837983bac90f
[svn] Fixed a lot of warnings that only showed up on *BSD.
js
parents:
1459
diff
changeset
|
633 if (opterr) { |
0 | 634 if (argv[optind - 1][1] == '-') |
635 /* --option */ | |
636 fprintf(stderr, | |
637 _ | |
638 ("%s: option `--%s' doesn't allow an argument\n"), | |
639 argv[0], pfound->name); | |
640 else | |
641 /* +option or -option */ | |
642 fprintf(stderr, | |
643 _ | |
644 ("%s: option `%c%s' doesn't allow an argument\n"), | |
645 argv[0], argv[optind - 1][0], | |
646 pfound->name); | |
1717
837983bac90f
[svn] Fixed a lot of warnings that only showed up on *BSD.
js
parents:
1459
diff
changeset
|
647 } |
0 | 648 |
649 nextchar += strlen(nextchar); | |
650 | |
651 optopt = pfound->val; | |
652 return '?'; | |
653 } | |
654 } | |
655 else if (pfound->has_arg == 1) { | |
656 if (optind < argc) | |
657 optarg = argv[optind++]; | |
658 else { | |
659 if (opterr) | |
660 fprintf(stderr, | |
661 _ | |
662 ("%s: option `%s' requires an argument\n"), | |
663 argv[0], argv[optind - 1]); | |
664 nextchar += strlen(nextchar); | |
665 optopt = pfound->val; | |
666 return optstring[0] == ':' ? ':' : '?'; | |
667 } | |
668 } | |
669 nextchar += strlen(nextchar); | |
670 if (longind != NULL) | |
671 *longind = option_index; | |
672 if (pfound->flag) { | |
673 *(pfound->flag) = pfound->val; | |
674 return 0; | |
675 } | |
676 return pfound->val; | |
677 } | |
678 | |
679 /* Can't find it as a long option. If this is not getopt_long_only, | |
680 or the option starts with '--' or is not a valid short | |
681 option, then it's an error. | |
682 Otherwise interpret it as a short option. */ | |
683 if (!long_only || argv[optind][1] == '-' | |
684 || my_index(optstring, *nextchar) == NULL) { | |
685 if (opterr) { | |
686 if (argv[optind][1] == '-') | |
687 /* --option */ | |
688 fprintf(stderr, _("%s: unrecognized option `--%s'\n"), | |
689 argv[0], nextchar); | |
690 else | |
691 /* +option or -option */ | |
692 fprintf(stderr, _("%s: unrecognized option `%c%s'\n"), | |
693 argv[0], argv[optind][0], nextchar); | |
694 } | |
695 nextchar = (char *) ""; | |
696 optind++; | |
697 optopt = 0; | |
698 return '?'; | |
699 } | |
700 } | |
701 | |
702 /* Look at and handle the next short option-character. */ | |
703 | |
704 { | |
705 char c = *nextchar++; | |
706 char *temp = my_index(optstring, c); | |
707 | |
708 /* Increment `optind' when we start to process its last character. */ | |
709 if (*nextchar == '\0') | |
710 ++optind; | |
711 | |
712 if (temp == NULL || c == ':') { | |
713 if (opterr) { | |
714 if (posixly_correct) | |
715 /* 1003.2 specifies the format of this message. */ | |
716 fprintf(stderr, _("%s: illegal option -- %c\n"), | |
717 argv[0], c); | |
718 else | |
719 fprintf(stderr, _("%s: invalid option -- %c\n"), | |
720 argv[0], c); | |
721 } | |
722 optopt = c; | |
723 return '?'; | |
724 } | |
725 /* Convenience. Treat POSIX -W foo same as long option --foo */ | |
726 if (temp[0] == 'W' && temp[1] == ';') { | |
727 char *nameend; | |
728 const struct option *p; | |
729 const struct option *pfound = NULL; | |
730 int exact = 0; | |
731 int ambig = 0; | |
732 int indfound = 0; | |
733 int option_index; | |
734 | |
735 /* This is an option that requires an argument. */ | |
736 if (*nextchar != '\0') { | |
737 optarg = nextchar; | |
738 /* If we end this ARGV-element by taking the rest as an arg, | |
739 we must advance to the next element now. */ | |
740 optind++; | |
741 } | |
742 else if (optind == argc) { | |
743 if (opterr) { | |
744 /* 1003.2 specifies the format of this message. */ | |
745 fprintf(stderr, | |
746 _("%s: option requires an argument -- %c\n"), | |
747 argv[0], c); | |
748 } | |
749 optopt = c; | |
750 if (optstring[0] == ':') | |
751 c = ':'; | |
752 else | |
753 c = '?'; | |
754 return c; | |
755 } | |
756 else | |
757 /* We already incremented `optind' once; | |
758 increment it again when taking next ARGV-elt as argument. */ | |
759 optarg = argv[optind++]; | |
760 | |
761 /* optarg is now the argument, see if it's in the | |
762 table of longopts. */ | |
763 | |
764 for (nextchar = nameend = optarg; *nameend && *nameend != '='; | |
765 nameend++) | |
766 /* Do nothing. */ ; | |
767 | |
768 /* Test all long options for either exact match | |
769 or abbreviated matches. */ | |
770 for (p = longopts, option_index = 0; p->name; p++, option_index++) | |
771 if (!strncmp(p->name, nextchar, nameend - nextchar)) { | |
772 if ((unsigned int) (nameend - nextchar) == | |
773 strlen(p->name)) { | |
774 /* Exact match found. */ | |
775 pfound = p; | |
776 indfound = option_index; | |
777 exact = 1; | |
778 break; | |
779 } | |
780 else if (pfound == NULL) { | |
781 /* First nonexact match found. */ | |
782 pfound = p; | |
783 indfound = option_index; | |
784 } | |
785 else | |
786 /* Second or later nonexact match found. */ | |
787 ambig = 1; | |
788 } | |
789 if (ambig && !exact) { | |
790 if (opterr) | |
791 fprintf(stderr, _("%s: option `-W %s' is ambiguous\n"), | |
792 argv[0], argv[optind]); | |
793 nextchar += strlen(nextchar); | |
794 optind++; | |
795 return '?'; | |
796 } | |
797 if (pfound != NULL) { | |
798 option_index = indfound; | |
799 if (*nameend) { | |
800 /* Don't test has_arg with >, because some C compilers don't | |
801 allow it to be used on enums. */ | |
802 if (pfound->has_arg) | |
803 optarg = nameend + 1; | |
804 else { | |
805 if (opterr) | |
806 fprintf(stderr, _("\ | |
807 %s: option `-W %s' doesn't allow an argument\n"), argv[0], pfound->name); | |
808 | |
809 nextchar += strlen(nextchar); | |
810 return '?'; | |
811 } | |
812 } | |
813 else if (pfound->has_arg == 1) { | |
814 if (optind < argc) | |
815 optarg = argv[optind++]; | |
816 else { | |
817 if (opterr) | |
818 fprintf(stderr, | |
819 _ | |
820 ("%s: option `%s' requires an argument\n"), | |
821 argv[0], argv[optind - 1]); | |
822 nextchar += strlen(nextchar); | |
823 return optstring[0] == ':' ? ':' : '?'; | |
824 } | |
825 } | |
826 nextchar += strlen(nextchar); | |
827 if (longind != NULL) | |
828 *longind = option_index; | |
829 if (pfound->flag) { | |
830 *(pfound->flag) = pfound->val; | |
831 return 0; | |
832 } | |
833 return pfound->val; | |
834 } | |
835 nextchar = NULL; | |
836 return 'W'; /* Let the application handle it. */ | |
837 } | |
838 if (temp[1] == ':') { | |
839 if (temp[2] == ':') { | |
840 /* This is an option that accepts an argument optionally. */ | |
841 if (*nextchar != '\0') { | |
842 optarg = nextchar; | |
843 optind++; | |
844 } | |
845 else | |
846 optarg = NULL; | |
847 nextchar = NULL; | |
848 } | |
849 else { | |
850 /* This is an option that requires an argument. */ | |
851 if (*nextchar != '\0') { | |
852 optarg = nextchar; | |
853 /* If we end this ARGV-element by taking the rest as an arg, | |
854 we must advance to the next element now. */ | |
855 optind++; | |
856 } | |
857 else if (optind == argc) { | |
858 if (opterr) { | |
859 /* 1003.2 specifies the format of this message. */ | |
860 fprintf(stderr, | |
861 _ | |
862 ("%s: option requires an argument -- %c\n"), | |
863 argv[0], c); | |
864 } | |
865 optopt = c; | |
866 if (optstring[0] == ':') | |
867 c = ':'; | |
868 else | |
869 c = '?'; | |
870 } | |
871 else | |
872 /* We already incremented `optind' once; | |
873 increment it again when taking next ARGV-elt as argument. */ | |
874 optarg = argv[optind++]; | |
875 nextchar = NULL; | |
876 } | |
877 } | |
878 return c; | |
879 } | |
880 } | |
881 | |
882 int | |
883 getopt(argc, argv, optstring) | |
884 int argc; | |
885 char *const *argv; | |
886 const char *optstring; | |
887 { | |
888 return _getopt_internal(argc, argv, optstring, | |
889 (const struct option *) 0, (int *) 0, 0); | |
890 } | |
891 | |
892 #endif /* Not ELIDE_CODE. */ | |
893 | |
894 #ifdef TEST | |
895 | |
896 /* Compile with -DTEST to make an executable for use in testing | |
897 the above definition of `getopt'. */ | |
898 | |
899 int | |
900 main(argc, argv) | |
901 int argc; | |
902 char **argv; | |
903 { | |
904 int c; | |
905 int digit_optind = 0; | |
906 | |
907 while (1) { | |
908 int this_option_optind = optind ? optind : 1; | |
909 | |
910 c = getopt(argc, argv, "abc:d:0123456789"); | |
911 if (c == -1) | |
912 break; | |
913 | |
914 switch (c) { | |
915 case '0': | |
916 case '1': | |
917 case '2': | |
918 case '3': | |
919 case '4': | |
920 case '5': | |
921 case '6': | |
922 case '7': | |
923 case '8': | |
924 case '9': | |
925 if (digit_optind != 0 && digit_optind != this_option_optind) | |
926 printf("digits occur in two different argv-elements.\n"); | |
927 digit_optind = this_option_optind; | |
928 printf("option %c\n", c); | |
929 break; | |
930 | |
931 case 'a': | |
932 printf("option a\n"); | |
933 break; | |
934 | |
935 case 'b': | |
936 printf("option b\n"); | |
937 break; | |
938 | |
939 case 'c': | |
940 printf("option c with value `%s'\n", optarg); | |
941 break; | |
942 | |
943 case '?': | |
944 break; | |
945 | |
946 default: | |
947 printf("?? getopt returned character code 0%o ??\n", c); | |
948 } | |
949 } | |
950 | |
951 if (optind < argc) { | |
952 printf("non-option ARGV-elements: "); | |
953 while (optind < argc) | |
954 printf("%s ", argv[optind++]); | |
955 printf("\n"); | |
956 } | |
957 | |
958 exit(0); | |
959 } | |
960 | |
961 #endif /* TEST */ |