"Fossies" - the Fresh Open Source Software Archive

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