lib/getopt.c

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