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