src/getopt.c

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