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