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