Code

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