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