lib/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    The GNU C Library is free software; you can redistribute it and/or
  10    modify it under the terms of the GNU Lesser General Public
  11    License as published by the Free Software Foundation; either
  12    version 2.1 of the License, or (at your option) any later version.
  13
  14    The GNU C Library is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17    Lesser General Public License for more details.
  18
  19    You should have received a copy of the GNU Lesser General Public
  20    License along with the GNU C Library; if not, write to the Free
  21    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  22    02111-1307 USA.  */
  23 \f
  24 /* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
  25    Ditto for AIX 3.2 and <stdlib.h>.  */
  26 #ifndef _NO_PROTO
  27 #define _NO_PROTO
  28 #endif
  29
  30 #ifdef HAVE_CONFIG_H
  31 #include <config.h>
  32 #endif
  33
  34 #if !defined __STDC__ || !__STDC__
  35 /* This is a separate conditional since some stdc systems
  36    reject `defined (const)'.  */
  37 #ifndef const
  38 #define const
  39 #endif
  40 #endif
  41
  42 #include <stdio.h>
  43
  44 /* Comment out all this code if we are using the GNU C Library, and are not
  45    actually compiling the library itself.  This code is part of the GNU C
  46    Library, but also included in many other GNU distributions.  Compiling
  47    and linking in this code is a waste when using the GNU C library
  48    (especially if it is a shared library).  Rather than having every GNU
  49    program understand `configure --with-gnu-libc' and omit the object files,
  50    it is simpler to just do this in the source for each such file.  */
  51
  52 #define GETOPT_INTERFACE_VERSION 2
  53 #if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2
  54 #include <gnu-versions.h>
  55 #if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
  56 #define ELIDE_CODE
  57 #endif
  58 #endif
  59
  60 #ifndef ELIDE_CODE
  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 defined HAVE_LIBINTL_H || 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 /* Stored original parameters.
 250    XXX This is no good solution.  We should rather copy the args so
 251    that we can compare them later.  But we must not use malloc(3).  */
 252 extern int __libc_argc;
 253 extern char **__libc_argv;
 254
 255 /* Bash 2.0 gives us an environment variable containing flags
 256    indicating ARGV elements that should not be considered arguments.  */
 257
 258 #ifdef USE_NONOPTION_FLAGS
 259 /* Defined in getopt_init.c  */
 260 extern char *__getopt_nonoption_flags;
 261
 262 static int nonoption_flags_max_len;
 263 static int nonoption_flags_len;
 264 #endif
 265
 266 #ifdef USE_NONOPTION_FLAGS
 267 #define SWAP_FLAGS(ch1, ch2) \
 268   if (nonoption_flags_len > 0)                                                \
 269     {                                                                         \
 270       char __tmp = __getopt_nonoption_flags[ch1];                             \
 271       __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2];          \
 272       __getopt_nonoption_flags[ch2] = __tmp;                                  \
 273     }
 274 #else
 275 #define SWAP_FLAGS(ch1, ch2)
 276 #endif
 277 #else /* !_LIBC */
 278 #define SWAP_FLAGS(ch1, ch2)
 279 #endif /* _LIBC */
 280
 281 /* Exchange two adjacent subsequences of ARGV.
 282    One subsequence is elements [first_nonopt,last_nonopt)
 283    which contains all the non-options that have been skipped so far.
 284    The other is elements [last_nonopt,optind), which contains all
 285    the options processed since those non-options were skipped.
 286
 287    `first_nonopt' and `last_nonopt' are relocated so that they describe
 288    the new indices of the non-options in ARGV after they are moved.  */
 289
 290 #if defined __STDC__ && __STDC__
 291 static void exchange(char **);
 292 #endif
 293
 294 static void exchange(argv)
 295 char **argv;
 296 {
 297         int bottom = first_nonopt;
 298         int middle = last_nonopt;
 299         int top = optind;
 300         char *tem;
 301
 302         /* Exchange the shorter segment with the far end of the longer segment.
 303            That puts the shorter segment into the right place.
 304            It leaves the longer segment in the right place overall,
 305            but it consists of two parts that need to be swapped next.  */
 306
 307 #if defined _LIBC && defined USE_NONOPTION_FLAGS
 308         /* First make sure the handling of the `__getopt_nonoption_flags'
 309            string can work normally.  Our top argument must be in the range
 310            of the string.  */
 311         if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len) {
 312                 /* We must extend the array.  The user plays games with us and
 313                    presents new arguments.  */
 314                 char *new_str = malloc(top + 1);
 315                 if (new_str == NULL)
 316                         nonoption_flags_len = nonoption_flags_max_len = 0;
 317                 else {
 318                         memset(__mempcpy(new_str, __getopt_nonoption_flags,
 319                                          nonoption_flags_max_len),
 320                                '\0', top + 1 - nonoption_flags_max_len);
 321                         nonoption_flags_max_len = top + 1;
 322                         __getopt_nonoption_flags = new_str;
 323                 }
 324         }
 325 #endif
 326
 327         while (top > middle && middle > bottom) {
 328                 if (top - middle > middle - bottom) {
 329                         /* Bottom segment is the short one.  */
 330                         int len = middle - bottom;
 331                         register int i;
 332
 333                         /* Swap it with the top part of the top segment.  */
 334                         for (i = 0; i < len; i++) {
 335                                 tem = argv[bottom + i];
 336                                 argv[bottom + i] =
 337                                     argv[top - (middle - bottom) + i];
 338                                 argv[top - (middle - bottom) + i] = tem;
 339                                 SWAP_FLAGS(bottom + i,
 340                                            top - (middle - bottom) + i);
 341                         }
 342                         /* Exclude the moved bottom segment from further swapping.  */
 343                         top -= len;
 344                 } else {
 345                         /* Top segment is the short one.  */
 346                         int len = top - middle;
 347                         register int i;
 348
 349                         /* Swap it with the bottom part of the bottom segment.  */
 350                         for (i = 0; i < len; i++) {
 351                                 tem = argv[bottom + i];
 352                                 argv[bottom + i] = argv[middle + i];
 353                                 argv[middle + i] = tem;
 354                                 SWAP_FLAGS(bottom + i, middle + i);
 355                         }
 356                         /* Exclude the moved top segment from further swapping.  */
 357                         bottom += len;
 358                 }
 359         }
 360
 361         /* Update records for the slots the non-options now occupy.  */
 362
 363         first_nonopt += (optind - last_nonopt);
 364         last_nonopt = optind;
 365 }
 366
 367 /* Initialize the internal data when the first call is made.  */
 368
 369 #if defined __STDC__ && __STDC__
 370 static const char *_getopt_initialize(int, char *const *, const char *);
 371 #endif
 372 static const char *_getopt_initialize(argc, argv, optstring)
 373 int argc;
 374 char *const *argv;
 375 const char *optstring;
 376 {
 377         /* Start processing options with ARGV-element 1 (since ARGV-element 0
 378            is the program name); the sequence of previously skipped
 379            non-option ARGV-elements is empty.  */
 380
 381         first_nonopt = last_nonopt = optind;
 382
 383         nextchar = NULL;
 384
 385         posixly_correct = getenv("POSIXLY_CORRECT");
 386
 387         /* Determine how to handle the ordering of options and nonoptions.  */
 388
 389         if (optstring[0] == '-') {
 390                 ordering = RETURN_IN_ORDER;
 391                 ++optstring;
 392         } else if (optstring[0] == '+') {
 393                 ordering = REQUIRE_ORDER;
 394                 ++optstring;
 395         } else if (posixly_correct != NULL)
 396                 ordering = REQUIRE_ORDER;
 397         else
 398                 ordering = PERMUTE;
 399
 400 #if defined _LIBC && defined USE_NONOPTION_FLAGS
 401         if (posixly_correct == NULL
 402             && argc == __libc_argc && argv == __libc_argv) {
 403                 if (nonoption_flags_max_len == 0) {
 404                         if (__getopt_nonoption_flags == NULL
 405                             || __getopt_nonoption_flags[0] == '\0')
 406                                 nonoption_flags_max_len = -1;
 407                         else {
 408                                 const char *orig_str = __getopt_nonoption_flags;
 409                                 int len = nonoption_flags_max_len =
 410                                     strlen(orig_str);
 411                                 if (nonoption_flags_max_len < argc)
 412                                         nonoption_flags_max_len = argc;
 413                                 __getopt_nonoption_flags =
 414                                     (char *)malloc(nonoption_flags_max_len);
 415                                 if (__getopt_nonoption_flags == NULL)
 416                                         nonoption_flags_max_len = -1;
 417                                 else
 418                                         memset(__mempcpy
 419                                                (__getopt_nonoption_flags,
 420                                                 orig_str, len), '\0',
 421                                                nonoption_flags_max_len - len);
 422                         }
 423                 }
 424                 nonoption_flags_len = nonoption_flags_max_len;
 425         } else
 426                 nonoption_flags_len = 0;
 427 #endif
 428
 429         return optstring;
 430 }
 431 \f
 432 /* Scan elements of ARGV (whose length is ARGC) for option characters
 433    given in OPTSTRING.
 434
 435    If an element of ARGV starts with '-', and is not exactly "-" or "--",
 436    then it is an option element.  The characters of this element
 437    (aside from the initial '-') are option characters.  If `getopt'
 438    is called repeatedly, it returns successively each of the option characters
 439    from each of the option elements.
 440
 441    If `getopt' finds another option character, it returns that character,
 442    updating `optind' and `nextchar' so that the next call to `getopt' can
 443    resume the scan with the following option character or ARGV-element.
 444
 445    If there are no more option characters, `getopt' returns -1.
 446    Then `optind' is the index in ARGV of the first ARGV-element
 447    that is not an option.  (The ARGV-elements have been permuted
 448    so that those that are not options now come last.)
 449
 450    OPTSTRING is a string containing the legitimate option characters.
 451    If an option character is seen that is not listed in OPTSTRING,
 452    return '?' after printing an error message.  If you set `opterr' to
 453    zero, the error message is suppressed but we still return '?'.
 454
 455    If a char in OPTSTRING is followed by a colon, that means it wants an arg,
 456    so the following text in the same ARGV-element, or the text of the following
 457    ARGV-element, is returned in `optarg'.  Two colons mean an option that
 458    wants an optional arg; if there is text in the current ARGV-element,
 459    it is returned in `optarg', otherwise `optarg' is set to zero.
 460
 461    If OPTSTRING starts with `-' or `+', it requests different methods of
 462    handling the non-option ARGV-elements.
 463    See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
 464
 465    Long-named options begin with `--' instead of `-'.
 466    Their names may be abbreviated as long as the abbreviation is unique
 467    or is an exact match for some defined option.  If they have an
 468    argument, it follows the option name in the same ARGV-element, separated
 469    from the option name by a `=', or else the in next ARGV-element.
 470    When `getopt' finds a long-named option, it returns 0 if that option's
 471    `flag' field is nonzero, the value of the option's `val' field
 472    if the `flag' field is zero.
 473
 474    The elements of ARGV aren't really const, because we permute them.
 475    But we pretend they're const in the prototype to be compatible
 476    with other systems.
 477
 478    LONGOPTS is a vector of `struct option' terminated by an
 479    element containing a name which is zero.
 480
 481    LONGIND returns the index in LONGOPT of the long-named option found.
 482    It is only valid when a long-named option has been found by the most
 483    recent call.
 484
 485    If LONG_ONLY is nonzero, '-' as well as '--' can introduce
 486    long-named options.  */
 487
 488 int _getopt_internal(argc, argv, optstring, longopts, longind, long_only)
 489 int argc;
 490 char *const *argv;
 491 const char *optstring;
 492 const struct option *longopts;
 493 int *longind;
 494 int long_only;
 495 {
 496         int print_errors = opterr;
 497         if (optstring[0] == ':')
 498                 print_errors = 0;
 499
 500         if (argc < 1)
 501                 return -1;
 502
 503         optarg = NULL;
 504
 505         if (optind == 0 || !__getopt_initialized) {
 506                 if (optind == 0)
 507                         optind = 1;     /* Don't scan ARGV[0], the program name.  */
 508                 optstring = _getopt_initialize(argc, argv, optstring);
 509                 __getopt_initialized = 1;
 510         }
 511
 512         /* Test whether ARGV[optind] points to a non-option argument.
 513            Either it does not have option syntax, or there is an environment flag
 514            from the shell indicating it is not an option.  The later information
 515            is only used when the used in the GNU libc.  */
 516 #if defined _LIBC && defined USE_NONOPTION_FLAGS
 517 #define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0'        \
 518                       || (optind < nonoption_flags_len                        \
 519                           && __getopt_nonoption_flags[optind] == '1'))
 520 #else
 521 #define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')
 522 #endif
 523
 524         if (nextchar == NULL || *nextchar == '\0') {
 525                 /* Advance to the next ARGV-element.  */
 526
 527                 /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
 528                    moved back by the user (who may also have changed the arguments).  */
 529                 if (last_nonopt > optind)
 530                         last_nonopt = optind;
 531                 if (first_nonopt > optind)
 532                         first_nonopt = optind;
 533
 534                 if (ordering == PERMUTE) {
 535                         /* If we have just processed some options following some non-options,
 536                            exchange them so that the options come first.  */
 537
 538                         if (first_nonopt != last_nonopt
 539                             && last_nonopt != optind)
 540                                 exchange((char **)argv);
 541                         else if (last_nonopt != optind)
 542                                 first_nonopt = optind;
 543
 544                         /* Skip any additional non-options
 545                            and extend the range of non-options previously skipped.  */
 546
 547                         while (optind < argc && NONOPTION_P)
 548                                 optind++;
 549                         last_nonopt = optind;
 550                 }
 551
 552                 /* The special ARGV-element `--' means premature end of options.
 553                    Skip it like a null option,
 554                    then exchange with previous non-options as if it were an option,
 555                    then skip everything else like a non-option.  */
 556
 557                 if (optind != argc && !strcmp(argv[optind], "--")) {
 558                         optind++;
 559
 560                         if (first_nonopt != last_nonopt
 561                             && last_nonopt != optind)
 562                                 exchange((char **)argv);
 563                         else if (first_nonopt == last_nonopt)
 564                                 first_nonopt = optind;
 565                         last_nonopt = argc;
 566
 567                         optind = argc;
 568                 }
 569
 570                 /* If we have done all the ARGV-elements, stop the scan
 571                    and back over any non-options that we skipped and permuted.  */
 572
 573                 if (optind == argc) {
 574                         /* Set the next-arg-index to point at the non-options
 575                            that we previously skipped, so the caller will digest them.  */
 576                         if (first_nonopt != last_nonopt)
 577                                 optind = first_nonopt;
 578                         return -1;
 579                 }
 580
 581                 /* If we have come to a non-option and did not permute it,
 582                    either stop the scan or describe it to the caller and pass it by.  */
 583
 584                 if (NONOPTION_P) {
 585                         if (ordering == REQUIRE_ORDER)
 586                                 return -1;
 587                         optarg = argv[optind++];
 588                         return 1;
 589                 }
 590
 591                 /* We have found another option-ARGV-element.
 592                    Skip the initial punctuation.  */
 593
 594                 nextchar = (argv[optind] + 1
 595                             + (longopts != NULL && argv[optind][1] == '-'));
 596         }
 597
 598         /* Decode the current option-ARGV-element.  */
 599
 600         /* Check whether the ARGV-element is a long option.
 601
 602            If long_only and the ARGV-element has the form "-f", where f is
 603            a valid short option, don't consider it an abbreviated form of
 604            a long option that starts with f.  Otherwise there would be no
 605            way to give the -f short option.
 606
 607            On the other hand, if there's a long option "fubar" and
 608            the ARGV-element is "-fu", do consider that an abbreviation of
 609            the long option, just like "--fu", and not "-f" with arg "u".
 610
 611            This distinction seems to be the most useful approach.  */
 612
 613         if (longopts != NULL
 614             && (argv[optind][1] == '-'
 615                 || (long_only
 616                     && (argv[optind][2]
 617                         || !my_index(optstring, argv[optind][1]))))) {
 618                 char *nameend;
 619                 const struct option *p;
 620                 const struct option *pfound = NULL;
 621                 int exact = 0;
 622                 int ambig = 0;
 623                 int indfound = -1;
 624                 int option_index;
 625
 626                 for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
 627                         /* Do nothing.  */ ;
 628
 629                 /* Test all long options for either exact match
 630                    or abbreviated matches.  */
 631                 for (p = longopts, option_index = 0; p->name;
 632                      p++, option_index++)
 633                         if (!strncmp(p->name, nextchar, nameend - nextchar)) {
 634                                 if ((unsigned int)(nameend - nextchar)
 635                                     == (unsigned int)strlen(p->name)) {
 636                                         /* Exact match found.  */
 637                                         pfound = p;
 638                                         indfound = option_index;
 639                                         exact = 1;
 640                                         break;
 641                                 } else if (pfound == NULL) {
 642                                         /* First nonexact match found.  */
 643                                         pfound = p;
 644                                         indfound = option_index;
 645                                 } else if (long_only
 646                                            || pfound->has_arg != p->has_arg
 647                                            || pfound->flag != p->flag
 648                                            || pfound->val != p->val)
 649                                         /* Second or later nonexact match found.  */
 650                                         ambig = 1;
 651                         }
 652
 653                 if (ambig && !exact) {
 654                         if (print_errors)
 655                                 fprintf(stderr,
 656                                         _("%s: option `%s' is ambiguous\n"),
 657                                         argv[0], argv[optind]);
 658                         nextchar += strlen(nextchar);
 659                         optind++;
 660                         optopt = 0;
 661                         return '?';
 662                 }
 663
 664                 if (pfound != NULL) {
 665                         option_index = indfound;
 666                         optind++;
 667                         if (*nameend) {
 668                                 /* Don't test has_arg with >, because some C compilers don't
 669                                    allow it to be used on enums.  */
 670                                 if (pfound->has_arg)
 671                                         optarg = nameend + 1;
 672                                 else {
 673                                         if (print_errors) {
 674                                                 if (argv[optind - 1][1] == '-')
 675                                                         /* --option */
 676                                                         fprintf(stderr,
 677                                                                 _
 678                                                                 ("%s: option `--%s' doesn't allow an argument\n"),
 679                                                                 argv[0],
 680                                                                 pfound->name);
 681                                                 else
 682                                                         /* +option or -option */
 683                                                         fprintf(stderr,
 684                                                                 _
 685                                                                 ("%s: option `%c%s' doesn't allow an argument\n"),
 686                                                                 argv[0],
 687                                                                 argv[optind -
 688                                                                      1][0],
 689                                                                 pfound->name);
 690                                         }
 691
 692                                         nextchar += strlen(nextchar);
 693
 694                                         optopt = pfound->val;
 695                                         return '?';
 696                                 }
 697                         } else if (pfound->has_arg == 1) {
 698                                 if (optind < argc)
 699                                         optarg = argv[optind++];
 700                                 else {
 701                                         if (print_errors)
 702                                                 fprintf(stderr,
 703                                                         _
 704                                                         ("%s: option `%s' requires an argument\n"),
 705                                                         argv[0],
 706                                                         argv[optind - 1]);
 707                                         nextchar += strlen(nextchar);
 708                                         optopt = pfound->val;
 709                                         return optstring[0] == ':' ? ':' : '?';
 710                                 }
 711                         }
 712                         nextchar += strlen(nextchar);
 713                         if (longind != NULL)
 714                                 *longind = option_index;
 715                         if (pfound->flag) {
 716                                 *(pfound->flag) = pfound->val;
 717                                 return 0;
 718                         }
 719                         return pfound->val;
 720                 }
 721
 722                 /* Can't find it as a long option.  If this is not getopt_long_only,
 723                    or the option starts with '--' or is not a valid short
 724                    option, then it's an error.
 725                    Otherwise interpret it as a short option.  */
 726                 if (!long_only || argv[optind][1] == '-'
 727                     || my_index(optstring, *nextchar) == NULL) {
 728                         if (print_errors) {
 729                                 if (argv[optind][1] == '-')
 730                                         /* --option */
 731                                         fprintf(stderr,
 732                                                 _
 733                                                 ("%s: unrecognized option `--%s'\n"),
 734                                                 argv[0], nextchar);
 735                                 else
 736                                         /* +option or -option */
 737                                         fprintf(stderr,
 738                                                 _
 739                                                 ("%s: unrecognized option `%c%s'\n"),
 740                                                 argv[0], argv[optind][0],
 741                                                 nextchar);
 742                         }
 743                         nextchar = (char *)"";
 744                         optind++;
 745                         optopt = 0;
 746                         return '?';
 747                 }
 748         }
 749
 750         /* Look at and handle the next short option-character.  */
 751
 752         {
 753                 char c = *nextchar++;
 754                 char *temp = my_index(optstring, c);
 755
 756                 /* Increment `optind' when we start to process its last character.  */
 757                 if (*nextchar == '\0')
 758                         ++optind;
 759
 760                 if (temp == NULL || c == ':') {
 761                         if (print_errors) {
 762                                 if (posixly_correct)
 763                                         /* 1003.2 specifies the format of this message.  */
 764                                         fprintf(stderr,
 765                                                 _("%s: illegal option -- %c\n"),
 766                                                 argv[0], c);
 767                                 else
 768                                         fprintf(stderr,
 769                                                 _("%s: invalid option -- %c\n"),
 770                                                 argv[0], c);
 771                         }
 772                         optopt = c;
 773                         return '?';
 774                 }
 775                 /* Convenience. Treat POSIX -W foo same as long option --foo */
 776                 if (temp[0] == 'W' && temp[1] == ';') {
 777                         char *nameend;
 778                         const struct option *p;
 779                         const struct option *pfound = NULL;
 780                         int exact = 0;
 781                         int ambig = 0;
 782                         int indfound = 0;
 783                         int option_index;
 784
 785                         /* This is an option that requires an argument.  */
 786                         if (*nextchar != '\0') {
 787                                 optarg = nextchar;
 788                                 /* If we end this ARGV-element by taking the rest as an arg,
 789                                    we must advance to the next element now.  */
 790                                 optind++;
 791                         } else if (optind == argc) {
 792                                 if (print_errors) {
 793                                         /* 1003.2 specifies the format of this message.  */
 794                                         fprintf(stderr,
 795                                                 _
 796                                                 ("%s: option requires an argument -- %c\n"),
 797                                                 argv[0], c);
 798                                 }
 799                                 optopt = c;
 800                                 if (optstring[0] == ':')
 801                                         c = ':';
 802                                 else
 803                                         c = '?';
 804                                 return c;
 805                         } else
 806                                 /* We already incremented `optind' once;
 807                                    increment it again when taking next ARGV-elt as argument.  */
 808                                 optarg = argv[optind++];
 809
 810                         /* optarg is now the argument, see if it's in the
 811                            table of longopts.  */
 812
 813                         for (nextchar = nameend = optarg;
 814                              *nameend && *nameend != '='; nameend++)
 815                                 /* Do nothing.  */ ;
 816
 817                         /* Test all long options for either exact match
 818                            or abbreviated matches.  */
 819                         for (p = longopts, option_index = 0; p->name;
 820                              p++, option_index++)
 821                                 if (!strncmp
 822                                     (p->name, nextchar, nameend - nextchar)) {
 823                                         if ((unsigned int)(nameend -
 824                                                            nextchar) ==
 825                                             strlen(p->name)) {
 826                                                 /* Exact match found.  */
 827                                                 pfound = p;
 828                                                 indfound = option_index;
 829                                                 exact = 1;
 830                                                 break;
 831                                         } else if (pfound == NULL) {
 832                                                 /* First nonexact match found.  */
 833                                                 pfound = p;
 834                                                 indfound = option_index;
 835                                         } else
 836                                                 /* Second or later nonexact match found.  */
 837                                                 ambig = 1;
 838                                 }
 839                         if (ambig && !exact) {
 840                                 if (print_errors)
 841                                         fprintf(stderr,
 842                                                 _
 843                                                 ("%s: option `-W %s' is ambiguous\n"),
 844                                                 argv[0], argv[optind]);
 845                                 nextchar += strlen(nextchar);
 846                                 optind++;
 847                                 return '?';
 848                         }
 849                         if (pfound != NULL) {
 850                                 option_index = indfound;
 851                                 if (*nameend) {
 852                                         /* Don't test has_arg with >, because some C compilers don't
 853                                            allow it to be used on enums.  */
 854                                         if (pfound->has_arg)
 855                                                 optarg = nameend + 1;
 856                                         else {
 857                                                 if (print_errors)
 858                                                         fprintf(stderr, _("\
 859 %s: option `-W %s' doesn't allow an argument\n"), argv[0], pfound->name);
 860
 861                                                 nextchar += strlen(nextchar);
 862                                                 return '?';
 863                                         }
 864                                 } else if (pfound->has_arg == 1) {
 865                                         if (optind < argc)
 866                                                 optarg = argv[optind++];
 867                                         else {
 868                                                 if (print_errors)
 869                                                         fprintf(stderr,
 870                                                                 _
 871                                                                 ("%s: option `%s' requires an argument\n"),
 872                                                                 argv[0],
 873                                                                 argv[optind -
 874                                                                      1]);
 875                                                 nextchar += strlen(nextchar);
 876                                                 return optstring[0] ==
 877                                                     ':' ? ':' : '?';
 878                                         }
 879                                 }
 880                                 nextchar += strlen(nextchar);
 881                                 if (longind != NULL)
 882                                         *longind = option_index;
 883                                 if (pfound->flag) {
 884                                         *(pfound->flag) = pfound->val;
 885                                         return 0;
 886                                 }
 887                                 return pfound->val;
 888                         }
 889                         nextchar = NULL;
 890                         return 'W';     /* Let the application handle it.   */
 891                 }
 892                 if (temp[1] == ':') {
 893                         if (temp[2] == ':') {
 894                                 /* This is an option that accepts an argument optionally.  */
 895                                 if (*nextchar != '\0') {
 896                                         optarg = nextchar;
 897                                         optind++;
 898                                 } else
 899                                         optarg = NULL;
 900                                 nextchar = NULL;
 901                         } else {
 902                                 /* This is an option that requires an argument.  */
 903                                 if (*nextchar != '\0') {
 904                                         optarg = nextchar;
 905                                         /* If we end this ARGV-element by taking the rest as an arg,
 906                                            we must advance to the next element now.  */
 907                                         optind++;
 908                                 } else if (optind == argc) {
 909                                         if (print_errors) {
 910                                                 /* 1003.2 specifies the format of this message.  */
 911                                                 fprintf(stderr,
 912                                                         _
 913                                                         ("%s: option requires an argument -- %c\n"),
 914                                                         argv[0], c);
 915                                         }
 916                                         optopt = c;
 917                                         if (optstring[0] == ':')
 918                                                 c = ':';
 919                                         else
 920                                                 c = '?';
 921                                 } else
 922                                         /* We already incremented `optind' once;
 923                                            increment it again when taking next ARGV-elt as argument.  */
 924                                         optarg = argv[optind++];
 925                                 nextchar = NULL;
 926                         }
 927                 }
 928                 return c;
 929         }
 930 }
 931
 932 int getopt(argc, argv, optstring)
 933 int argc;
 934 char *const *argv;
 935 const char *optstring;
 936 {
 937         return _getopt_internal(argc, argv, optstring,
 938                                 (const struct option *)0, (int *)0, 0);
 939 }
 940
 941 #endif /* Not ELIDE_CODE.  */
 942 \f
 943 #ifdef TEST
 944
 945 /* Compile with -DTEST to make an executable for use in testing
 946    the above definition of `getopt'.  */
 947
 948 int main(argc, argv)
 949 int argc;
 950 char **argv;
 951 {
 952         int c;
 953         int digit_optind = 0;
 954
 955         while (1) {
 956                 int this_option_optind = optind ? optind : 1;
 957
 958                 c = getopt(argc, argv, "abc:d:0123456789");
 959                 if (c == -1)
 960                         break;
 961
 962                 switch (c) {
 963                 case '0':
 964                 case '1':
 965                 case '2':
 966                 case '3':
 967                 case '4':
 968                 case '5':
 969                 case '6':
 970                 case '7':
 971                 case '8':
 972                 case '9':
 973                         if (digit_optind != 0
 974                             && digit_optind != this_option_optind)
 975                                 printf
 976                                     ("digits occur in two different argv-elements.\n");
 977                         digit_optind = this_option_optind;
 978                         printf("option %c\n", c);
 979                         break;
 980
 981                 case 'a':
 982                         printf("option a\n");
 983                         break;
 984
 985                 case 'b':
 986                         printf("option b\n");
 987                         break;
 988
 989                 case 'c':
 990                         printf("option c with value `%s'\n", optarg);
 991                         break;
 992
 993                 case '?':
 994                         break;
 995
 996                 default:
 997                         printf("?? getopt returned character code 0%o ??\n", c);
 998                 }
 999         }
1000
1001         if (optind < argc) {
1002                 printf("non-option ARGV-elements: ");
1003                 while (optind < argc)
1004                         printf("%s ", argv[optind++]);
1005                 printf("\n");
1006         }
1007
1008         exit(0);
1009 }
1010
1011 #endif /* TEST */