contrib/grep/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 indfound = -1;
 492       int option_index;
 493
 494       for (nameend = d->__nextchar; *nameend && *nameend != '='; nameend++)
 495         /* Do nothing.  */ ;
 496       namelen = nameend - d->__nextchar;
 497
 498       /* Test all long options for either exact match
 499          or abbreviated matches.  */
 500       for (p = longopts, option_index = 0; p->name; p++, option_index++)
 501         if (!strncmp (p->name, d->__nextchar, namelen))
 502           {
 503             if (namelen == (unsigned int) strlen (p->name))
 504               {
 505                 /* Exact match found.  */
 506                 pfound = p;
 507                 indfound = option_index;
 508                 exact = 1;
 509                 break;
 510               }
 511             else if (pfound == NULL)
 512               {
 513                 /* First nonexact match found.  */
 514                 pfound = p;
 515                 indfound = option_index;
 516               }
 517             else if (long_only
 518                      || pfound->has_arg != p->has_arg
 519                      || pfound->flag != p->flag
 520                      || pfound->val != p->val)
 521               {
 522                 /* Second or later nonexact match found.  */
 523                 struct option_list *newp = malloc (sizeof (*newp));
 524                 newp->p = p;
 525                 newp->next = ambig_list;
 526                 ambig_list = newp;
 527               }
 528           }
 529
 530       if (ambig_list != NULL && !exact)
 531         {
 532           if (print_errors)
 533             {
 534               struct option_list first;
 535               first.p = pfound;
 536               first.next = ambig_list;
 537               ambig_list = &first;
 538
 539 #if defined _LIBC && defined USE_IN_LIBIO
 540               char *buf = NULL;
 541               size_t buflen = 0;
 542
 543               FILE *fp = open_memstream (&buf, &buflen);
 544               if (fp != NULL)
 545                 {
 546                   fprintf (fp,
 547                            _("%s: option '%s' is ambiguous; possibilities:"),
 548                            argv[0], argv[d->optind]);
 549
 550                   do
 551                     {
 552                       fprintf (fp, " '--%s'", ambig_list->p->name);
 553                       ambig_list = ambig_list->next;
 554                     }
 555                   while (ambig_list != NULL);
 556
 557                   fputc_unlocked ('\n', fp);
 558
 559                   if (__builtin_expect (fclose (fp) != EOF, 1))
 560                     {
 561                       _IO_flockfile (stderr);
 562
 563                       int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
 564                       ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
 565
 566                       __fxprintf (NULL, "%s", buf);
 567
 568                       ((_IO_FILE *) stderr)->_flags2 = old_flags2;
 569                       _IO_funlockfile (stderr);
 570
 571                       free (buf);
 572                     }
 573                 }
 574 #else
 575               fprintf (stderr,
 576                        _("%s: option '%s' is ambiguous; possibilities:"),
 577                        argv[0], argv[d->optind]);
 578               do
 579                 {
 580                   fprintf (stderr, " '--%s'", ambig_list->p->name);
 581                   ambig_list = ambig_list->next;
 582                 }
 583               while (ambig_list != NULL);
 584
 585               fputc ('\n', stderr);
 586 #endif
 587             }
 588           d->__nextchar += strlen (d->__nextchar);
 589           d->optind++;
 590           d->optopt = 0;
 591           return '?';
 592         }
 593
 594       while (ambig_list != NULL)
 595         {
 596           struct option_list *pn = ambig_list->next;
 597           free (ambig_list);
 598           ambig_list = pn;
 599         }
 600
 601       if (pfound != NULL)
 602         {
 603           option_index = indfound;
 604           d->optind++;
 605           if (*nameend)
 606             {
 607               /* Don't test has_arg with >, because some C compilers don't
 608                  allow it to be used on enums.  */
 609               if (pfound->has_arg)
 610                 d->optarg = nameend + 1;
 611               else
 612                 {
 613                   if (print_errors)
 614                     {
 615 #if defined _LIBC && defined USE_IN_LIBIO
 616                       char *buf;
 617                       int n;
 618 #endif
 619
 620                       if (argv[d->optind - 1][1] == '-')
 621                         {
 622                           /* --option */
 623 #if defined _LIBC && defined USE_IN_LIBIO
 624                           n = __asprintf (&buf, _("\
 625 %s: option '--%s' doesn't allow an argument\n"),
 626                                           argv[0], pfound->name);
 627 #else
 628                           fprintf (stderr, _("\
 629 %s: option '--%s' doesn't allow an argument\n"),
 630                                    argv[0], pfound->name);
 631 #endif
 632                         }
 633                       else
 634                         {
 635                           /* +option or -option */
 636 #if defined _LIBC && defined USE_IN_LIBIO
 637                           n = __asprintf (&buf, _("\
 638 %s: option '%c%s' doesn't allow an argument\n"),
 639                                           argv[0], argv[d->optind - 1][0],
 640                                           pfound->name);
 641 #else
 642                           fprintf (stderr, _("\
 643 %s: option '%c%s' doesn't allow an argument\n"),
 644                                    argv[0], argv[d->optind - 1][0],
 645                                    pfound->name);
 646 #endif
 647                         }
 648
 649 #if defined _LIBC && defined USE_IN_LIBIO
 650                       if (n >= 0)
 651                         {
 652                           _IO_flockfile (stderr);
 653
 654                           int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
 655                           ((_IO_FILE *) stderr)->_flags2
 656                             |= _IO_FLAGS2_NOTCANCEL;
 657
 658                           __fxprintf (NULL, "%s", buf);
 659
 660                           ((_IO_FILE *) stderr)->_flags2 = old_flags2;
 661                           _IO_funlockfile (stderr);
 662
 663                           free (buf);
 664                         }
 665 #endif
 666                     }
 667
 668                   d->__nextchar += strlen (d->__nextchar);
 669
 670                   d->optopt = pfound->val;
 671                   return '?';
 672                 }
 673             }
 674           else if (pfound->has_arg == 1)
 675             {
 676               if (d->optind < argc)
 677                 d->optarg = argv[d->optind++];
 678               else
 679                 {
 680                   if (print_errors)
 681                     {
 682 #if defined _LIBC && defined USE_IN_LIBIO
 683                       char *buf;
 684
 685                       if (__asprintf (&buf, _("\
 686 %s: option '--%s' requires an argument\n"),
 687                                       argv[0], pfound->name) >= 0)
 688                         {
 689                           _IO_flockfile (stderr);
 690
 691                           int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
 692                           ((_IO_FILE *) stderr)->_flags2
 693                             |= _IO_FLAGS2_NOTCANCEL;
 694
 695                           __fxprintf (NULL, "%s", buf);
 696
 697                           ((_IO_FILE *) stderr)->_flags2 = old_flags2;
 698                           _IO_funlockfile (stderr);
 699
 700                           free (buf);
 701                         }
 702 #else
 703                       fprintf (stderr,
 704                                _("%s: option '--%s' requires an argument\n"),
 705                                argv[0], pfound->name);
 706 #endif
 707                     }
 708                   d->__nextchar += strlen (d->__nextchar);
 709                   d->optopt = pfound->val;
 710                   return optstring[0] == ':' ? ':' : '?';
 711                 }
 712             }
 713           d->__nextchar += strlen (d->__nextchar);
 714           if (longind != NULL)
 715             *longind = option_index;
 716           if (pfound->flag)
 717             {
 718               *(pfound->flag) = pfound->val;
 719               return 0;
 720             }
 721           return pfound->val;
 722         }
 723
 724       /* Can't find it as a long option.  If this is not getopt_long_only,
 725          or the option starts with '--' or is not a valid short
 726          option, then it's an error.
 727          Otherwise interpret it as a short option.  */
 728       if (!long_only || argv[d->optind][1] == '-'
 729           || strchr (optstring, *d->__nextchar) == NULL)
 730         {
 731           if (print_errors)
 732             {
 733 #if defined _LIBC && defined USE_IN_LIBIO
 734               char *buf;
 735               int n;
 736 #endif
 737
 738               if (argv[d->optind][1] == '-')
 739                 {
 740                   /* --option */
 741 #if defined _LIBC && defined USE_IN_LIBIO
 742                   n = __asprintf (&buf, _("%s: unrecognized option '--%s'\n"),
 743                                   argv[0], d->__nextchar);
 744 #else
 745                   fprintf (stderr, _("%s: unrecognized option '--%s'\n"),
 746                            argv[0], d->__nextchar);
 747 #endif
 748                 }
 749               else
 750                 {
 751                   /* +option or -option */
 752 #if defined _LIBC && defined USE_IN_LIBIO
 753                   n = __asprintf (&buf, _("%s: unrecognized option '%c%s'\n"),
 754                                   argv[0], argv[d->optind][0], d->__nextchar);
 755 #else
 756                   fprintf (stderr, _("%s: unrecognized option '%c%s'\n"),
 757                            argv[0], argv[d->optind][0], d->__nextchar);
 758 #endif
 759                 }
 760
 761 #if defined _LIBC && defined USE_IN_LIBIO
 762               if (n >= 0)
 763                 {
 764                   _IO_flockfile (stderr);
 765
 766                   int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
 767                   ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
 768
 769                   __fxprintf (NULL, "%s", buf);
 770
 771                   ((_IO_FILE *) stderr)->_flags2 = old_flags2;
 772                   _IO_funlockfile (stderr);
 773
 774                   free (buf);
 775                 }
 776 #endif
 777             }
 778           d->__nextchar = (char *) "";
 779           d->optind++;
 780           d->optopt = 0;
 781           return '?';
 782         }
 783     }
 784
 785   /* Look at and handle the next short option-character.  */
 786
 787   {
 788     char c = *d->__nextchar++;
 789     const char *temp = strchr (optstring, c);
 790
 791     /* Increment `optind' when we start to process its last character.  */
 792     if (*d->__nextchar == '\0')
 793       ++d->optind;
 794
 795     if (temp == NULL || c == ':' || c == ';')
 796       {
 797         if (print_errors)
 798           {
 799 #if defined _LIBC && defined USE_IN_LIBIO
 800               char *buf;
 801               int n;
 802 #endif
 803
 804 #if defined _LIBC && defined USE_IN_LIBIO
 805               n = __asprintf (&buf, _("%s: invalid option -- '%c'\n"),
 806                               argv[0], c);
 807 #else
 808               fprintf (stderr, _("%s: invalid option -- '%c'\n"), argv[0], c);
 809 #endif
 810
 811 #if defined _LIBC && defined USE_IN_LIBIO
 812             if (n >= 0)
 813               {
 814                 _IO_flockfile (stderr);
 815
 816                 int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
 817                 ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
 818
 819                 __fxprintf (NULL, "%s", buf);
 820
 821                 ((_IO_FILE *) stderr)->_flags2 = old_flags2;
 822                 _IO_funlockfile (stderr);
 823
 824                 free (buf);
 825               }
 826 #endif
 827           }
 828         d->optopt = c;
 829         return '?';
 830       }
 831     /* Convenience. Treat POSIX -W foo same as long option --foo */
 832     if (temp[0] == 'W' && temp[1] == ';')
 833       {
 834         char *nameend;
 835         const struct option *p;
 836         const struct option *pfound = NULL;
 837         int exact = 0;
 838         int ambig = 0;
 839         int indfound = 0;
 840         int option_index;
 841
 842         /* This is an option that requires an argument.  */
 843         if (*d->__nextchar != '\0')
 844           {
 845             d->optarg = d->__nextchar;
 846             /* If we end this ARGV-element by taking the rest as an arg,
 847                we must advance to the next element now.  */
 848             d->optind++;
 849           }
 850         else if (d->optind == argc)
 851           {
 852             if (print_errors)
 853               {
 854 #if defined _LIBC && defined USE_IN_LIBIO
 855                 char *buf;
 856
 857                 if (__asprintf (&buf,
 858                                 _("%s: option requires an argument -- '%c'\n"),
 859                                 argv[0], c) >= 0)
 860                   {
 861                     _IO_flockfile (stderr);
 862
 863                     int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
 864                     ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
 865
 866                     __fxprintf (NULL, "%s", buf);
 867
 868                     ((_IO_FILE *) stderr)->_flags2 = old_flags2;
 869                     _IO_funlockfile (stderr);
 870
 871                     free (buf);
 872                   }
 873 #else
 874                 fprintf (stderr,
 875                          _("%s: option requires an argument -- '%c'\n"),
 876                          argv[0], c);
 877 #endif
 878               }
 879             d->optopt = c;
 880             if (optstring[0] == ':')
 881               c = ':';
 882             else
 883               c = '?';
 884             return c;
 885           }
 886         else
 887           /* We already incremented `d->optind' once;
 888              increment it again when taking next ARGV-elt as argument.  */
 889           d->optarg = argv[d->optind++];
 890
 891         /* optarg is now the argument, see if it's in the
 892            table of longopts.  */
 893
 894         for (d->__nextchar = nameend = d->optarg; *nameend && *nameend != '=';
 895              nameend++)
 896           /* Do nothing.  */ ;
 897
 898         /* Test all long options for either exact match
 899            or abbreviated matches.  */
 900         for (p = longopts, option_index = 0; p->name; p++, option_index++)
 901           if (!strncmp (p->name, d->__nextchar, nameend - d->__nextchar))
 902             {
 903               if ((unsigned int) (nameend - d->__nextchar) == strlen (p->name))
 904                 {
 905                   /* Exact match found.  */
 906                   pfound = p;
 907                   indfound = option_index;
 908                   exact = 1;
 909                   break;
 910                 }
 911               else if (pfound == NULL)
 912                 {
 913                   /* First nonexact match found.  */
 914                   pfound = p;
 915                   indfound = option_index;
 916                 }
 917               else if (long_only
 918                        || pfound->has_arg != p->has_arg
 919                        || pfound->flag != p->flag
 920                        || pfound->val != p->val)
 921                 /* Second or later nonexact match found.  */
 922                 ambig = 1;
 923             }
 924         if (ambig && !exact)
 925           {
 926             if (print_errors)
 927               {
 928 #if defined _LIBC && defined USE_IN_LIBIO
 929                 char *buf;
 930
 931                 if (__asprintf (&buf, _("%s: option '-W %s' is ambiguous\n"),
 932                                 argv[0], d->optarg) >= 0)
 933                   {
 934                     _IO_flockfile (stderr);
 935
 936                     int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
 937                     ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
 938
 939                     __fxprintf (NULL, "%s", buf);
 940
 941                     ((_IO_FILE *) stderr)->_flags2 = old_flags2;
 942                     _IO_funlockfile (stderr);
 943
 944                     free (buf);
 945                   }
 946 #else
 947                 fprintf (stderr, _("%s: option '-W %s' is ambiguous\n"),
 948                          argv[0], d->optarg);
 949 #endif
 950               }
 951             d->__nextchar += strlen (d->__nextchar);
 952             d->optind++;
 953             return '?';
 954           }
 955         if (pfound != NULL)
 956           {
 957             option_index = indfound;
 958             if (*nameend)
 959               {
 960                 /* Don't test has_arg with >, because some C compilers don't
 961                    allow it to be used on enums.  */
 962                 if (pfound->has_arg)
 963                   d->optarg = nameend + 1;
 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 '-W %s' doesn't allow an argument\n"),
 973                                         argv[0], pfound->name) >= 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 '-W %s' doesn't allow an argument\n"),
 991                                  argv[0], pfound->name);
 992 #endif
 993                       }
 994
 995                     d->__nextchar += strlen (d->__nextchar);
 996                     return '?';
 997                   }
 998               }
 999             else if (pfound->has_arg == 1)
1000               {
1001                 if (d->optind < argc)
1002                   d->optarg = argv[d->optind++];
1003                 else
1004                   {
1005                     if (print_errors)
1006                       {
1007 #if defined _LIBC && defined USE_IN_LIBIO
1008                         char *buf;
1009
1010                         if (__asprintf (&buf, _("\
1011 %s: option '-W %s' requires an argument\n"),
1012                                         argv[0], pfound->name) >= 0)
1013                           {
1014                             _IO_flockfile (stderr);
1015
1016                             int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
1017                             ((_IO_FILE *) stderr)->_flags2
1018                               |= _IO_FLAGS2_NOTCANCEL;
1019
1020                             __fxprintf (NULL, "%s", buf);
1021
1022                             ((_IO_FILE *) stderr)->_flags2 = old_flags2;
1023                             _IO_funlockfile (stderr);
1024
1025                             free (buf);
1026                           }
1027 #else
1028                         fprintf (stderr, _("\
1029 %s: option '-W %s' requires an argument\n"),
1030                                  argv[0], pfound->name);
1031 #endif
1032                       }
1033                     d->__nextchar += strlen (d->__nextchar);
1034                     return optstring[0] == ':' ? ':' : '?';
1035                   }
1036               }
1037             else
1038               d->optarg = NULL;
1039             d->__nextchar += strlen (d->__nextchar);
1040             if (longind != NULL)
1041               *longind = option_index;
1042             if (pfound->flag)
1043               {
1044                 *(pfound->flag) = pfound->val;
1045                 return 0;
1046               }
1047             return pfound->val;
1048           }
1049           d->__nextchar = NULL;
1050           return 'W';   /* Let the application handle it.   */
1051       }
1052     if (temp[1] == ':')
1053       {
1054         if (temp[2] == ':')
1055           {
1056             /* This is an option that accepts an argument optionally.  */
1057             if (*d->__nextchar != '\0')
1058               {
1059                 d->optarg = d->__nextchar;
1060                 d->optind++;
1061               }
1062             else
1063               d->optarg = NULL;
1064             d->__nextchar = NULL;
1065           }
1066         else
1067           {
1068             /* This is an option that requires an argument.  */
1069             if (*d->__nextchar != '\0')
1070               {
1071                 d->optarg = d->__nextchar;
1072                 /* If we end this ARGV-element by taking the rest as an arg,
1073                    we must advance to the next element now.  */
1074                 d->optind++;
1075               }
1076             else if (d->optind == argc)
1077               {
1078                 if (print_errors)
1079                   {
1080 #if defined _LIBC && defined USE_IN_LIBIO
1081                     char *buf;
1082
1083                     if (__asprintf (&buf, _("\
1084 %s: option requires an argument -- '%c'\n"),
1085                                     argv[0], c) >= 0)
1086                       {
1087                         _IO_flockfile (stderr);
1088
1089                         int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
1090                         ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
1091
1092                         __fxprintf (NULL, "%s", buf);
1093
1094                         ((_IO_FILE *) stderr)->_flags2 = old_flags2;
1095                         _IO_funlockfile (stderr);
1096
1097                         free (buf);
1098                       }
1099 #else
1100                     fprintf (stderr,
1101                              _("%s: option requires an argument -- '%c'\n"),
1102                              argv[0], c);
1103 #endif
1104                   }
1105                 d->optopt = c;
1106                 if (optstring[0] == ':')
1107                   c = ':';
1108                 else
1109                   c = '?';
1110               }
1111             else
1112               /* We already incremented `optind' once;
1113                  increment it again when taking next ARGV-elt as argument.  */
1114               d->optarg = argv[d->optind++];
1115             d->__nextchar = NULL;
1116           }
1117       }
1118     return c;
1119   }
1120 }
1121
1122 int
1123 _getopt_internal (int argc, char **argv, const char *optstring,
1124                   const struct option *longopts, int *longind, int long_only,
1125                   int posixly_correct)
1126 {
1127   int result;
1128
1129   getopt_data.optind = optind;
1130   getopt_data.opterr = opterr;
1131
1132   result = _getopt_internal_r (argc, argv, optstring, longopts,
1133                                longind, long_only, &getopt_data,
1134                                posixly_correct);
1135
1136   optind = getopt_data.optind;
1137   optarg = getopt_data.optarg;
1138   optopt = getopt_data.optopt;
1139
1140   return result;
1141 }
1142
1143 /* glibc gets a LSB-compliant getopt.
1144    Standalone applications get a POSIX-compliant getopt.  */
1145 #if _LIBC
1146 enum { POSIXLY_CORRECT = 0 };
1147 #else
1148 enum { POSIXLY_CORRECT = 1 };
1149 #endif
1150
1151 int
1152 getopt (int argc, char *const *argv, const char *optstring)
1153 {
1154   return _getopt_internal (argc, (char **) argv, optstring,
1155                            (const struct option *) 0,
1156                            (int *) 0,
1157                            0, POSIXLY_CORRECT);
1158 }
1159
1160 #ifdef _LIBC
1161 int
1162 __posix_getopt (int argc, char *const *argv, const char *optstring)
1163 {
1164   return _getopt_internal (argc, argv, optstring,
1165                            (const struct option *) 0,
1166                            (int *) 0,
1167                            0, 1);
1168 }
1169 #endif
1170
1171 \f
1172 #ifdef TEST
1173
1174 /* Compile with -DTEST to make an executable for use in testing
1175    the above definition of `getopt'.  */
1176
1177 int
1178 main (int argc, char **argv)
1179 {
1180   int c;
1181   int digit_optind = 0;
1182
1183   while (1)
1184     {
1185       int this_option_optind = optind ? optind : 1;
1186
1187       c = getopt (argc, argv, "abc:d:0123456789");
1188       if (c == -1)
1189         break;
1190
1191       switch (c)
1192         {
1193         case '0':
1194         case '1':
1195         case '2':
1196         case '3':
1197         case '4':
1198         case '5':
1199         case '6':
1200         case '7':
1201         case '8':
1202         case '9':
1203           if (digit_optind != 0 && digit_optind != this_option_optind)
1204             printf ("digits occur in two different argv-elements.\n");
1205           digit_optind = this_option_optind;
1206           printf ("option %c\n", c);
1207           break;
1208
1209         case 'a':
1210           printf ("option a\n");
1211           break;
1212
1213         case 'b':
1214           printf ("option b\n");
1215           break;
1216
1217         case 'c':
1218           printf ("option c with value '%s'\n", optarg);
1219           break;
1220
1221         case '?':
1222           break;
1223
1224         default:
1225           printf ("?? getopt returned character code 0%o ??\n", c);
1226         }
1227     }
1228
1229   if (optind < argc)
1230     {
1231       printf ("non-option ARGV-elements: ");
1232       while (optind < argc)
1233         printf ("%s ", argv[optind++]);
1234       printf ("\n");
1235     }
1236
1237   exit (0);
1238 }
1239
1240 #endif /* TEST */