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