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