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