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