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