LibOFX
|
00001 /* Getopt for GNU. 00002 NOTE: getopt is now part of the C library, so if you don't know what 00003 "Keep this file name-space clean" means, talk to drepper@gnu.org 00004 before changing it! 00005 Copyright (C) 1987,88,89,90,91,92,93,94,95,96,98,99,2000,2001 00006 Free Software Foundation, Inc. 00007 This file is part of the GNU C Library. 00008 00009 The GNU C Library is free software; you can redistribute it and/or 00010 modify it under the terms of the GNU Lesser General Public 00011 License as published by the Free Software Foundation; either 00012 version 2.1 of the License, or (at your option) any later version. 00013 00014 The GNU C Library is distributed in the hope that it will be useful, 00015 but WITHOUT ANY WARRANTY; without even the implied warranty of 00016 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00017 Lesser General Public License for more details. 00018 00019 You should have received a copy of the GNU Lesser General Public 00020 License along with the GNU C Library; if not, write to the Free 00021 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 00022 02111-1307 USA. */ 00023 00024 /* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>. 00025 Ditto for AIX 3.2 and <stdlib.h>. */ 00026 #ifndef _NO_PROTO 00027 # define _NO_PROTO 00028 #endif 00029 00030 #ifdef HAVE_CONFIG_H 00031 # include <config.h> 00032 #endif 00033 00034 #if !defined __STDC__ || !__STDC__ 00035 /* This is a separate conditional since some stdc systems 00036 reject `defined (const)'. */ 00037 # ifndef const 00038 # define const 00039 # endif 00040 #endif 00041 00042 #include <stdio.h> 00043 00044 /* Comment out all this code if we are using the GNU C Library, and are not 00045 actually compiling the library itself. This code is part of the GNU C 00046 Library, but also included in many other GNU distributions. Compiling 00047 and linking in this code is a waste when using the GNU C library 00048 (especially if it is a shared library). Rather than having every GNU 00049 program understand `configure --with-gnu-libc' and omit the object files, 00050 it is simpler to just do this in the source for each such file. */ 00051 00052 #define GETOPT_INTERFACE_VERSION 2 00053 #if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2 00054 # include <gnu-versions.h> 00055 # if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION 00056 # define ELIDE_CODE 00057 # endif 00058 #endif 00059 00060 #ifndef ELIDE_CODE 00061 00062 00063 /* This needs to come after some library #include 00064 to get __GNU_LIBRARY__ defined. */ 00065 #ifdef __GNU_LIBRARY__ 00066 /* Don't include stdlib.h for non-GNU C libraries because some of them 00067 contain conflicting prototypes for getopt. */ 00068 # include <stdlib.h> 00069 # include <unistd.h> 00070 #endif /* GNU C library. */ 00071 00072 #ifdef VMS 00073 # include <unixlib.h> 00074 # if HAVE_STRING_H - 0 00075 # include <string.h> 00076 # endif 00077 #endif 00078 00079 #ifndef _ 00080 /* This is for other GNU distributions with internationalized messages. */ 00081 # if defined HAVE_LIBINTL_H || defined _LIBC 00082 # include <libintl.h> 00083 # ifndef _ 00084 # define _(msgid) gettext (msgid) 00085 # endif 00086 # else 00087 # define _(msgid) (msgid) 00088 # endif 00089 #endif 00090 00091 /* This version of `getopt' appears to the caller like standard Unix `getopt' 00092 but it behaves differently for the user, since it allows the user 00093 to intersperse the options with the other arguments. 00094 00095 As `getopt' works, it permutes the elements of ARGV so that, 00096 when it is done, all the options precede everything else. Thus 00097 all application programs are extended to handle flexible argument order. 00098 00099 Setting the environment variable POSIXLY_CORRECT disables permutation. 00100 Then the behavior is completely standard. 00101 00102 GNU application programs can use a third alternative mode in which 00103 they can distinguish the relative order of options and other arguments. */ 00104 00105 #include "getopt.h" 00106 00107 /* For communication from `getopt' to the caller. 00108 When `getopt' finds an option that takes an argument, 00109 the argument value is returned here. 00110 Also, when `ordering' is RETURN_IN_ORDER, 00111 each non-option ARGV-element is returned here. */ 00112 00113 char *optarg; 00114 00115 /* Index in ARGV of the next element to be scanned. 00116 This is used for communication to and from the caller 00117 and for communication between successive calls to `getopt'. 00118 00119 On entry to `getopt', zero means this is the first call; initialize. 00120 00121 When `getopt' returns -1, this is the index of the first of the 00122 non-option elements that the caller should itself scan. 00123 00124 Otherwise, `optind' communicates from one call to the next 00125 how much of ARGV has been scanned so far. */ 00126 00127 /* 1003.2 says this must be 1 before any call. */ 00128 int optind = 1; 00129 00130 /* Formerly, initialization of getopt depended on optind==0, which 00131 causes problems with re-calling getopt as programs generally don't 00132 know that. */ 00133 00134 int __getopt_initialized; 00135 00136 /* The next char to be scanned in the option-element 00137 in which the last option character we returned was found. 00138 This allows us to pick up the scan where we left off. 00139 00140 If this is zero, or a null string, it means resume the scan 00141 by advancing to the next ARGV-element. */ 00142 00143 static char *nextchar; 00144 00145 /* Callers store zero here to inhibit the error message 00146 for unrecognized options. */ 00147 00148 int opterr = 1; 00149 00150 /* Set to an option character which was unrecognized. 00151 This must be initialized on some systems to avoid linking in the 00152 system's own getopt implementation. */ 00153 00154 int optopt = '?'; 00155 00156 /* Describe how to deal with options that follow non-option ARGV-elements. 00157 00158 If the caller did not specify anything, 00159 the default is REQUIRE_ORDER if the environment variable 00160 POSIXLY_CORRECT is defined, PERMUTE otherwise. 00161 00162 REQUIRE_ORDER means don't recognize them as options; 00163 stop option processing when the first non-option is seen. 00164 This is what Unix does. 00165 This mode of operation is selected by either setting the environment 00166 variable POSIXLY_CORRECT, or using `+' as the first character 00167 of the list of option characters. 00168 00169 PERMUTE is the default. We permute the contents of ARGV as we scan, 00170 so that eventually all the non-options are at the end. This allows options 00171 to be given in any order, even with programs that were not written to 00172 expect this. 00173 00174 RETURN_IN_ORDER is an option available to programs that were written 00175 to expect options and other ARGV-elements in any order and that care about 00176 the ordering of the two. We describe each non-option ARGV-element 00177 as if it were the argument of an option with character code 1. 00178 Using `-' as the first character of the list of option characters 00179 selects this mode of operation. 00180 00181 The special argument `--' forces an end of option-scanning regardless 00182 of the value of `ordering'. In the case of RETURN_IN_ORDER, only 00183 `--' can cause `getopt' to return -1 with `optind' != ARGC. */ 00184 00185 static enum 00186 { 00187 REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER 00188 } ordering; 00189 00190 /* Value of POSIXLY_CORRECT environment variable. */ 00191 static char *posixly_correct; 00192 00193 #ifdef __GNU_LIBRARY__ 00194 /* We want to avoid inclusion of string.h with non-GNU libraries 00195 because there are many ways it can cause trouble. 00196 On some systems, it contains special magic macros that don't work 00197 in GCC. */ 00198 # include <string.h> 00199 # define my_index strchr 00200 #else 00201 00202 # if HAVE_STRING_H 00203 # include <string.h> 00204 # else 00205 # include <strings.h> 00206 # endif 00207 00208 /* Avoid depending on library functions or files 00209 whose names are inconsistent. */ 00210 00211 #ifndef getenv 00212 extern char *getenv (); 00213 #endif 00214 00215 static char * 00216 my_index (str, chr) 00217 const char *str; 00218 int chr; 00219 { 00220 while (*str) 00221 { 00222 if (*str == chr) 00223 return (char *) str; 00224 str++; 00225 } 00226 return 0; 00227 } 00228 00229 /* If using GCC, we can safely declare strlen this way. 00230 If not using GCC, it is ok not to declare it. */ 00231 #ifdef __GNUC__ 00232 /* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h. 00233 That was relevant to code that was here before. */ 00234 # if (!defined __STDC__ || !__STDC__) && !defined strlen 00235 /* gcc with -traditional declares the built-in strlen to return int, 00236 and has done so at least since version 2.4.5. -- rms. */ 00237 extern int strlen (const char *); 00238 # endif /* not __STDC__ */ 00239 #endif /* __GNUC__ */ 00240 00241 #endif /* not __GNU_LIBRARY__ */ 00242 00243 /* Handle permutation of arguments. */ 00244 00245 /* Describe the part of ARGV that contains non-options that have 00246 been skipped. `first_nonopt' is the index in ARGV of the first of them; 00247 `last_nonopt' is the index after the last of them. */ 00248 00249 static int first_nonopt; 00250 static int last_nonopt; 00251 00252 #ifdef _LIBC 00253 /* Stored original parameters. 00254 XXX This is no good solution. We should rather copy the args so 00255 that we can compare them later. But we must not use malloc(3). */ 00256 extern int __libc_argc; 00257 extern char **__libc_argv; 00258 00259 /* Bash 2.0 gives us an environment variable containing flags 00260 indicating ARGV elements that should not be considered arguments. */ 00261 00262 # ifdef USE_NONOPTION_FLAGS 00263 /* Defined in getopt_init.c */ 00264 extern char *__getopt_nonoption_flags; 00265 00266 static int nonoption_flags_max_len; 00267 static int nonoption_flags_len; 00268 # endif 00269 00270 # ifdef USE_NONOPTION_FLAGS 00271 # define SWAP_FLAGS(ch1, ch2) \ 00272 if (nonoption_flags_len > 0) \ 00273 { \ 00274 char __tmp = __getopt_nonoption_flags[ch1]; \ 00275 __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2]; \ 00276 __getopt_nonoption_flags[ch2] = __tmp; \ 00277 } 00278 # else 00279 # define SWAP_FLAGS(ch1, ch2) 00280 # endif 00281 #else /* !_LIBC */ 00282 # define SWAP_FLAGS(ch1, ch2) 00283 #endif /* _LIBC */ 00284 00285 /* Exchange two adjacent subsequences of ARGV. 00286 One subsequence is elements [first_nonopt,last_nonopt) 00287 which contains all the non-options that have been skipped so far. 00288 The other is elements [last_nonopt,optind), which contains all 00289 the options processed since those non-options were skipped. 00290 00291 `first_nonopt' and `last_nonopt' are relocated so that they describe 00292 the new indices of the non-options in ARGV after they are moved. */ 00293 00294 #if defined __STDC__ && __STDC__ 00295 static void exchange (char **); 00296 #endif 00297 00298 static void 00299 exchange (argv) 00300 char **argv; 00301 { 00302 int bottom = first_nonopt; 00303 int middle = last_nonopt; 00304 int top = optind; 00305 char *tem; 00306 00307 /* Exchange the shorter segment with the far end of the longer segment. 00308 That puts the shorter segment into the right place. 00309 It leaves the longer segment in the right place overall, 00310 but it consists of two parts that need to be swapped next. */ 00311 00312 #if defined _LIBC && defined USE_NONOPTION_FLAGS 00313 /* First make sure the handling of the `__getopt_nonoption_flags' 00314 string can work normally. Our top argument must be in the range 00315 of the string. */ 00316 if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len) 00317 { 00318 /* We must extend the array. The user plays games with us and 00319 presents new arguments. */ 00320 char *new_str = malloc (top + 1); 00321 if (new_str == NULL) 00322 nonoption_flags_len = nonoption_flags_max_len = 0; 00323 else 00324 { 00325 memset (__mempcpy (new_str, __getopt_nonoption_flags, 00326 nonoption_flags_max_len), 00327 '\0', top + 1 - nonoption_flags_max_len); 00328 nonoption_flags_max_len = top + 1; 00329 __getopt_nonoption_flags = new_str; 00330 } 00331 } 00332 #endif 00333 00334 while (top > middle && middle > bottom) 00335 { 00336 if (top - middle > middle - bottom) 00337 { 00338 /* Bottom segment is the short one. */ 00339 int len = middle - bottom; 00340 register int i; 00341 00342 /* Swap it with the top part of the top segment. */ 00343 for (i = 0; i < len; i++) 00344 { 00345 tem = argv[bottom + i]; 00346 argv[bottom + i] = argv[top - (middle - bottom) + i]; 00347 argv[top - (middle - bottom) + i] = tem; 00348 SWAP_FLAGS (bottom + i, top - (middle - bottom) + i); 00349 } 00350 /* Exclude the moved bottom segment from further swapping. */ 00351 top -= len; 00352 } 00353 else 00354 { 00355 /* Top segment is the short one. */ 00356 int len = top - middle; 00357 register int i; 00358 00359 /* Swap it with the bottom part of the bottom segment. */ 00360 for (i = 0; i < len; i++) 00361 { 00362 tem = argv[bottom + i]; 00363 argv[bottom + i] = argv[middle + i]; 00364 argv[middle + i] = tem; 00365 SWAP_FLAGS (bottom + i, middle + i); 00366 } 00367 /* Exclude the moved top segment from further swapping. */ 00368 bottom += len; 00369 } 00370 } 00371 00372 /* Update records for the slots the non-options now occupy. */ 00373 00374 first_nonopt += (optind - last_nonopt); 00375 last_nonopt = optind; 00376 } 00377 00378 /* Initialize the internal data when the first call is made. */ 00379 00380 #if defined __STDC__ && __STDC__ 00381 static const char *_getopt_initialize (int, char *const *, const char *); 00382 #endif 00383 static const char * 00384 _getopt_initialize (argc, argv, optstring) 00385 int argc; 00386 char *const *argv; 00387 const char *optstring; 00388 { 00389 /* Start processing options with ARGV-element 1 (since ARGV-element 0 00390 is the program name); the sequence of previously skipped 00391 non-option ARGV-elements is empty. */ 00392 00393 first_nonopt = last_nonopt = optind; 00394 00395 nextchar = NULL; 00396 00397 posixly_correct = getenv ("POSIXLY_CORRECT"); 00398 00399 /* Determine how to handle the ordering of options and nonoptions. */ 00400 00401 if (optstring[0] == '-') 00402 { 00403 ordering = RETURN_IN_ORDER; 00404 ++optstring; 00405 } 00406 else if (optstring[0] == '+') 00407 { 00408 ordering = REQUIRE_ORDER; 00409 ++optstring; 00410 } 00411 else if (posixly_correct != NULL) 00412 ordering = REQUIRE_ORDER; 00413 else 00414 ordering = PERMUTE; 00415 00416 #if defined _LIBC && defined USE_NONOPTION_FLAGS 00417 if (posixly_correct == NULL 00418 && argc == __libc_argc && argv == __libc_argv) 00419 { 00420 if (nonoption_flags_max_len == 0) 00421 { 00422 if (__getopt_nonoption_flags == NULL 00423 || __getopt_nonoption_flags[0] == '\0') 00424 nonoption_flags_max_len = -1; 00425 else 00426 { 00427 const char *orig_str = __getopt_nonoption_flags; 00428 int len = nonoption_flags_max_len = strlen (orig_str); 00429 if (nonoption_flags_max_len < argc) 00430 nonoption_flags_max_len = argc; 00431 __getopt_nonoption_flags = 00432 (char *) malloc (nonoption_flags_max_len); 00433 if (__getopt_nonoption_flags == NULL) 00434 nonoption_flags_max_len = -1; 00435 else 00436 memset (__mempcpy (__getopt_nonoption_flags, orig_str, len), 00437 '\0', nonoption_flags_max_len - len); 00438 } 00439 } 00440 nonoption_flags_len = nonoption_flags_max_len; 00441 } 00442 else 00443 nonoption_flags_len = 0; 00444 #endif 00445 00446 return optstring; 00447 } 00448 00449 /* Scan elements of ARGV (whose length is ARGC) for option characters 00450 given in OPTSTRING. 00451 00452 If an element of ARGV starts with '-', and is not exactly "-" or "--", 00453 then it is an option element. The characters of this element 00454 (aside from the initial '-') are option characters. If `getopt' 00455 is called repeatedly, it returns successively each of the option characters 00456 from each of the option elements. 00457 00458 If `getopt' finds another option character, it returns that character, 00459 updating `optind' and `nextchar' so that the next call to `getopt' can 00460 resume the scan with the following option character or ARGV-element. 00461 00462 If there are no more option characters, `getopt' returns -1. 00463 Then `optind' is the index in ARGV of the first ARGV-element 00464 that is not an option. (The ARGV-elements have been permuted 00465 so that those that are not options now come last.) 00466 00467 OPTSTRING is a string containing the legitimate option characters. 00468 If an option character is seen that is not listed in OPTSTRING, 00469 return '?' after printing an error message. If you set `opterr' to 00470 zero, the error message is suppressed but we still return '?'. 00471 00472 If a char in OPTSTRING is followed by a colon, that means it wants an arg, 00473 so the following text in the same ARGV-element, or the text of the following 00474 ARGV-element, is returned in `optarg'. Two colons mean an option that 00475 wants an optional arg; if there is text in the current ARGV-element, 00476 it is returned in `optarg', otherwise `optarg' is set to zero. 00477 00478 If OPTSTRING starts with `-' or `+', it requests different methods of 00479 handling the non-option ARGV-elements. 00480 See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above. 00481 00482 Long-named options begin with `--' instead of `-'. 00483 Their names may be abbreviated as long as the abbreviation is unique 00484 or is an exact match for some defined option. If they have an 00485 argument, it follows the option name in the same ARGV-element, separated 00486 from the option name by a `=', or else the in next ARGV-element. 00487 When `getopt' finds a long-named option, it returns 0 if that option's 00488 `flag' field is nonzero, the value of the option's `val' field 00489 if the `flag' field is zero. 00490 00491 The elements of ARGV aren't really const, because we permute them. 00492 But we pretend they're const in the prototype to be compatible 00493 with other systems. 00494 00495 LONGOPTS is a vector of `struct option' terminated by an 00496 element containing a name which is zero. 00497 00498 LONGIND returns the index in LONGOPT of the long-named option found. 00499 It is only valid when a long-named option has been found by the most 00500 recent call. 00501 00502 If LONG_ONLY is nonzero, '-' as well as '--' can introduce 00503 long-named options. */ 00504 00505 int 00506 _getopt_internal (argc, argv, optstring, longopts, longind, long_only) 00507 int argc; 00508 char *const *argv; 00509 const char *optstring; 00510 const struct option *longopts; 00511 int *longind; 00512 int long_only; 00513 { 00514 int print_errors = opterr; 00515 if (optstring[0] == ':') 00516 print_errors = 0; 00517 00518 if (argc < 1) 00519 return -1; 00520 00521 optarg = NULL; 00522 00523 if (optind == 0 || !__getopt_initialized) 00524 { 00525 if (optind == 0) 00526 optind = 1; /* Don't scan ARGV[0], the program name. */ 00527 optstring = _getopt_initialize (argc, argv, optstring); 00528 __getopt_initialized = 1; 00529 } 00530 00531 /* Test whether ARGV[optind] points to a non-option argument. 00532 Either it does not have option syntax, or there is an environment flag 00533 from the shell indicating it is not an option. The later information 00534 is only used when the used in the GNU libc. */ 00535 #if defined _LIBC && defined USE_NONOPTION_FLAGS 00536 # define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0' \ 00537 || (optind < nonoption_flags_len \ 00538 && __getopt_nonoption_flags[optind] == '1')) 00539 #else 00540 # define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0') 00541 #endif 00542 00543 if (nextchar == NULL || *nextchar == '\0') 00544 { 00545 /* Advance to the next ARGV-element. */ 00546 00547 /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been 00548 moved back by the user (who may also have changed the arguments). */ 00549 if (last_nonopt > optind) 00550 last_nonopt = optind; 00551 if (first_nonopt > optind) 00552 first_nonopt = optind; 00553 00554 if (ordering == PERMUTE) 00555 { 00556 /* If we have just processed some options following some non-options, 00557 exchange them so that the options come first. */ 00558 00559 if (first_nonopt != last_nonopt && last_nonopt != optind) 00560 exchange ((char **) argv); 00561 else if (last_nonopt != optind) 00562 first_nonopt = optind; 00563 00564 /* Skip any additional non-options 00565 and extend the range of non-options previously skipped. */ 00566 00567 while (optind < argc && NONOPTION_P) 00568 optind++; 00569 last_nonopt = optind; 00570 } 00571 00572 /* The special ARGV-element `--' means premature end of options. 00573 Skip it like a null option, 00574 then exchange with previous non-options as if it were an option, 00575 then skip everything else like a non-option. */ 00576 00577 if (optind != argc && !strcmp (argv[optind], "--")) 00578 { 00579 optind++; 00580 00581 if (first_nonopt != last_nonopt && last_nonopt != optind) 00582 exchange ((char **) argv); 00583 else if (first_nonopt == last_nonopt) 00584 first_nonopt = optind; 00585 last_nonopt = argc; 00586 00587 optind = argc; 00588 } 00589 00590 /* If we have done all the ARGV-elements, stop the scan 00591 and back over any non-options that we skipped and permuted. */ 00592 00593 if (optind == argc) 00594 { 00595 /* Set the next-arg-index to point at the non-options 00596 that we previously skipped, so the caller will digest them. */ 00597 if (first_nonopt != last_nonopt) 00598 optind = first_nonopt; 00599 return -1; 00600 } 00601 00602 /* If we have come to a non-option and did not permute it, 00603 either stop the scan or describe it to the caller and pass it by. */ 00604 00605 if (NONOPTION_P) 00606 { 00607 if (ordering == REQUIRE_ORDER) 00608 return -1; 00609 optarg = argv[optind++]; 00610 return 1; 00611 } 00612 00613 /* We have found another option-ARGV-element. 00614 Skip the initial punctuation. */ 00615 00616 nextchar = (argv[optind] + 1 00617 + (longopts != NULL && argv[optind][1] == '-')); 00618 } 00619 00620 /* Decode the current option-ARGV-element. */ 00621 00622 /* Check whether the ARGV-element is a long option. 00623 00624 If long_only and the ARGV-element has the form "-f", where f is 00625 a valid short option, don't consider it an abbreviated form of 00626 a long option that starts with f. Otherwise there would be no 00627 way to give the -f short option. 00628 00629 On the other hand, if there's a long option "fubar" and 00630 the ARGV-element is "-fu", do consider that an abbreviation of 00631 the long option, just like "--fu", and not "-f" with arg "u". 00632 00633 This distinction seems to be the most useful approach. */ 00634 00635 if (longopts != NULL 00636 && (argv[optind][1] == '-' 00637 || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1]))))) 00638 { 00639 char *nameend; 00640 const struct option *p; 00641 const struct option *pfound = NULL; 00642 int exact = 0; 00643 int ambig = 0; 00644 int indfound = -1; 00645 int option_index; 00646 00647 for (nameend = nextchar; *nameend && *nameend != '='; nameend++) 00648 /* Do nothing. */ ; 00649 00650 /* Test all long options for either exact match 00651 or abbreviated matches. */ 00652 for (p = longopts, option_index = 0; p->name; p++, option_index++) 00653 if (!strncmp (p->name, nextchar, nameend - nextchar)) 00654 { 00655 if ((unsigned int) (nameend - nextchar) 00656 == (unsigned int) strlen (p->name)) 00657 { 00658 /* Exact match found. */ 00659 pfound = p; 00660 indfound = option_index; 00661 exact = 1; 00662 break; 00663 } 00664 else if (pfound == NULL) 00665 { 00666 /* First nonexact match found. */ 00667 pfound = p; 00668 indfound = option_index; 00669 } 00670 else if (long_only 00671 || pfound->has_arg != p->has_arg 00672 || pfound->flag != p->flag 00673 || pfound->val != p->val) 00674 /* Second or later nonexact match found. */ 00675 ambig = 1; 00676 } 00677 00678 if (ambig && !exact) 00679 { 00680 if (print_errors) 00681 fprintf (stderr, _("%s: option `%s' is ambiguous\n"), 00682 argv[0], argv[optind]); 00683 nextchar += strlen (nextchar); 00684 optind++; 00685 optopt = 0; 00686 return '?'; 00687 } 00688 00689 if (pfound != NULL) 00690 { 00691 option_index = indfound; 00692 optind++; 00693 if (*nameend) 00694 { 00695 /* Don't test has_arg with >, because some C compilers don't 00696 allow it to be used on enums. */ 00697 if (pfound->has_arg) 00698 optarg = nameend + 1; 00699 else 00700 { 00701 if (print_errors) 00702 { 00703 if (argv[optind - 1][1] == '-') 00704 /* --option */ 00705 fprintf (stderr, 00706 _("%s: option `--%s' doesn't allow an argument\n"), 00707 argv[0], pfound->name); 00708 else 00709 /* +option or -option */ 00710 fprintf (stderr, 00711 _("%s: option `%c%s' doesn't allow an argument\n"), 00712 argv[0], argv[optind - 1][0], pfound->name); 00713 } 00714 00715 nextchar += strlen (nextchar); 00716 00717 optopt = pfound->val; 00718 return '?'; 00719 } 00720 } 00721 else if (pfound->has_arg == 1) 00722 { 00723 if (optind < argc) 00724 optarg = argv[optind++]; 00725 else 00726 { 00727 if (print_errors) 00728 fprintf (stderr, 00729 _("%s: option `%s' requires an argument\n"), 00730 argv[0], argv[optind - 1]); 00731 nextchar += strlen (nextchar); 00732 optopt = pfound->val; 00733 return optstring[0] == ':' ? ':' : '?'; 00734 } 00735 } 00736 nextchar += strlen (nextchar); 00737 if (longind != NULL) 00738 *longind = option_index; 00739 if (pfound->flag) 00740 { 00741 *(pfound->flag) = pfound->val; 00742 return 0; 00743 } 00744 return pfound->val; 00745 } 00746 00747 /* Can't find it as a long option. If this is not getopt_long_only, 00748 or the option starts with '--' or is not a valid short 00749 option, then it's an error. 00750 Otherwise interpret it as a short option. */ 00751 if (!long_only || argv[optind][1] == '-' 00752 || my_index (optstring, *nextchar) == NULL) 00753 { 00754 if (print_errors) 00755 { 00756 if (argv[optind][1] == '-') 00757 /* --option */ 00758 fprintf (stderr, _("%s: unrecognized option `--%s'\n"), 00759 argv[0], nextchar); 00760 else 00761 /* +option or -option */ 00762 fprintf (stderr, _("%s: unrecognized option `%c%s'\n"), 00763 argv[0], argv[optind][0], nextchar); 00764 } 00765 nextchar = (char *) ""; 00766 optind++; 00767 optopt = 0; 00768 return '?'; 00769 } 00770 } 00771 00772 /* Look at and handle the next short option-character. */ 00773 00774 { 00775 char c = *nextchar++; 00776 char *temp = my_index (optstring, c); 00777 00778 /* Increment `optind' when we start to process its last character. */ 00779 if (*nextchar == '\0') 00780 ++optind; 00781 00782 if (temp == NULL || c == ':') 00783 { 00784 if (print_errors) 00785 { 00786 if (posixly_correct) 00787 /* 1003.2 specifies the format of this message. */ 00788 fprintf (stderr, _("%s: illegal option -- %c\n"), 00789 argv[0], c); 00790 else 00791 fprintf (stderr, _("%s: invalid option -- %c\n"), 00792 argv[0], c); 00793 } 00794 optopt = c; 00795 return '?'; 00796 } 00797 /* Convenience. Treat POSIX -W foo same as long option --foo */ 00798 if (temp[0] == 'W' && temp[1] == ';') 00799 { 00800 char *nameend; 00801 const struct option *p; 00802 const struct option *pfound = NULL; 00803 int exact = 0; 00804 int ambig = 0; 00805 int indfound = 0; 00806 int option_index; 00807 00808 /* This is an option that requires an argument. */ 00809 if (*nextchar != '\0') 00810 { 00811 optarg = nextchar; 00812 /* If we end this ARGV-element by taking the rest as an arg, 00813 we must advance to the next element now. */ 00814 optind++; 00815 } 00816 else if (optind == argc) 00817 { 00818 if (print_errors) 00819 { 00820 /* 1003.2 specifies the format of this message. */ 00821 fprintf (stderr, _("%s: option requires an argument -- %c\n"), 00822 argv[0], c); 00823 } 00824 optopt = c; 00825 if (optstring[0] == ':') 00826 c = ':'; 00827 else 00828 c = '?'; 00829 return c; 00830 } 00831 else 00832 /* We already incremented `optind' once; 00833 increment it again when taking next ARGV-elt as argument. */ 00834 optarg = argv[optind++]; 00835 00836 /* optarg is now the argument, see if it's in the 00837 table of longopts. */ 00838 00839 for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++) 00840 /* Do nothing. */ ; 00841 00842 /* Test all long options for either exact match 00843 or abbreviated matches. */ 00844 for (p = longopts, option_index = 0; p->name; p++, option_index++) 00845 if (!strncmp (p->name, nextchar, nameend - nextchar)) 00846 { 00847 if ((unsigned int) (nameend - nextchar) == strlen (p->name)) 00848 { 00849 /* Exact match found. */ 00850 pfound = p; 00851 indfound = option_index; 00852 exact = 1; 00853 break; 00854 } 00855 else if (pfound == NULL) 00856 { 00857 /* First nonexact match found. */ 00858 pfound = p; 00859 indfound = option_index; 00860 } 00861 else 00862 /* Second or later nonexact match found. */ 00863 ambig = 1; 00864 } 00865 if (ambig && !exact) 00866 { 00867 if (print_errors) 00868 fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"), 00869 argv[0], argv[optind]); 00870 nextchar += strlen (nextchar); 00871 optind++; 00872 return '?'; 00873 } 00874 if (pfound != NULL) 00875 { 00876 option_index = indfound; 00877 if (*nameend) 00878 { 00879 /* Don't test has_arg with >, because some C compilers don't 00880 allow it to be used on enums. */ 00881 if (pfound->has_arg) 00882 optarg = nameend + 1; 00883 else 00884 { 00885 if (print_errors) 00886 fprintf (stderr, _("\ 00887 %s: option `-W %s' doesn't allow an argument\n"), 00888 argv[0], pfound->name); 00889 00890 nextchar += strlen (nextchar); 00891 return '?'; 00892 } 00893 } 00894 else if (pfound->has_arg == 1) 00895 { 00896 if (optind < argc) 00897 optarg = argv[optind++]; 00898 else 00899 { 00900 if (print_errors) 00901 fprintf (stderr, 00902 _("%s: option `%s' requires an argument\n"), 00903 argv[0], argv[optind - 1]); 00904 nextchar += strlen (nextchar); 00905 return optstring[0] == ':' ? ':' : '?'; 00906 } 00907 } 00908 nextchar += strlen (nextchar); 00909 if (longind != NULL) 00910 *longind = option_index; 00911 if (pfound->flag) 00912 { 00913 *(pfound->flag) = pfound->val; 00914 return 0; 00915 } 00916 return pfound->val; 00917 } 00918 nextchar = NULL; 00919 return 'W'; /* Let the application handle it. */ 00920 } 00921 if (temp[1] == ':') 00922 { 00923 if (temp[2] == ':') 00924 { 00925 /* This is an option that accepts an argument optionally. */ 00926 if (*nextchar != '\0') 00927 { 00928 optarg = nextchar; 00929 optind++; 00930 } 00931 else 00932 optarg = NULL; 00933 nextchar = NULL; 00934 } 00935 else 00936 { 00937 /* This is an option that requires an argument. */ 00938 if (*nextchar != '\0') 00939 { 00940 optarg = nextchar; 00941 /* If we end this ARGV-element by taking the rest as an arg, 00942 we must advance to the next element now. */ 00943 optind++; 00944 } 00945 else if (optind == argc) 00946 { 00947 if (print_errors) 00948 { 00949 /* 1003.2 specifies the format of this message. */ 00950 fprintf (stderr, 00951 _("%s: option requires an argument -- %c\n"), 00952 argv[0], c); 00953 } 00954 optopt = c; 00955 if (optstring[0] == ':') 00956 c = ':'; 00957 else 00958 c = '?'; 00959 } 00960 else 00961 /* We already incremented `optind' once; 00962 increment it again when taking next ARGV-elt as argument. */ 00963 optarg = argv[optind++]; 00964 nextchar = NULL; 00965 } 00966 } 00967 return c; 00968 } 00969 } 00970 00971 int 00972 getopt (argc, argv, optstring) 00973 int argc; 00974 char *const *argv; 00975 const char *optstring; 00976 { 00977 return _getopt_internal (argc, argv, optstring, 00978 (const struct option *) 0, 00979 (int *) 0, 00980 0); 00981 } 00982 00983 #endif /* Not ELIDE_CODE. */ 00984 00985 #ifdef TEST 00986 00987 /* Compile with -DTEST to make an executable for use in testing 00988 the above definition of `getopt'. */ 00989 00990 int 00991 main (argc, argv) 00992 int argc; 00993 char **argv; 00994 { 00995 int c; 00996 int digit_optind = 0; 00997 00998 while (1) 00999 { 01000 int this_option_optind = optind ? optind : 1; 01001 01002 c = getopt (argc, argv, "abc:d:0123456789"); 01003 if (c == -1) 01004 break; 01005 01006 switch (c) 01007 { 01008 case '0': 01009 case '1': 01010 case '2': 01011 case '3': 01012 case '4': 01013 case '5': 01014 case '6': 01015 case '7': 01016 case '8': 01017 case '9': 01018 if (digit_optind != 0 && digit_optind != this_option_optind) 01019 printf ("digits occur in two different argv-elements.\n"); 01020 digit_optind = this_option_optind; 01021 printf ("option %c\n", c); 01022 break; 01023 01024 case 'a': 01025 printf ("option a\n"); 01026 break; 01027 01028 case 'b': 01029 printf ("option b\n"); 01030 break; 01031 01032 case 'c': 01033 printf ("option c with value `%s'\n", optarg); 01034 break; 01035 01036 case '?': 01037 break; 01038 01039 default: 01040 printf ("?? getopt returned character code 0%o ??\n", c); 01041 } 01042 } 01043 01044 if (optind < argc) 01045 { 01046 printf ("non-option ARGV-elements: "); 01047 while (optind < argc) 01048 printf ("%s ", argv[optind++]); 01049 printf ("\n"); 01050 } 01051 01052 exit (0); 01053 } 01054 01055 #endif /* TEST */