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