contrib/texinfo/gnulib/lib/getopt.c

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