"Fossies" - the Fresh Open Source Software Archive

Member "which-2.21/getopt.c" (25 May 2007, 30245 Bytes) of package /linux/privat/which-2.21.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "getopt.c" see the Fossies "Dox" file reference documentation.

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