fix "unused variables" warnings and others
[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 #else
463   (void)argc, (void)argv;
464 #endif
465
466   return optstring;
467 }
468 \f
469 /* Scan elements of ARGV (whose length is ARGC) for option characters
470    given in OPTSTRING.
471
472    If an element of ARGV starts with '-', and is not exactly "-" or "--",
473    then it is an option element.  The characters of this element
474    (aside from the initial '-') are option characters.  If `FLAC__share__getopt'
475    is called repeatedly, it returns successively each of the option characters
476    from each of the option elements.
477
478    If `FLAC__share__getopt' finds another option character, it returns that character,
479    updating `FLAC__share__optind' and `nextchar' so that the next call to `FLAC__share__getopt' can
480    resume the scan with the following option character or ARGV-element.
481
482    If there are no more option characters, `FLAC__share__getopt' returns -1.
483    Then `FLAC__share__optind' is the index in ARGV of the first ARGV-element
484    that is not an option.  (The ARGV-elements have been permuted
485    so that those that are not options now come last.)
486
487    OPTSTRING is a string containing the legitimate option characters.
488    If an option character is seen that is not listed in OPTSTRING,
489    return '?' after printing an error message.  If you set `FLAC__share__opterr' to
490    zero, the error message is suppressed but we still return '?'.
491
492    If a char in OPTSTRING is followed by a colon, that means it wants an arg,
493    so the following text in the same ARGV-element, or the text of the following
494    ARGV-element, is returned in `FLAC__share__optarg'.  Two colons mean an option that
495    wants an optional arg; if there is text in the current ARGV-element,
496    it is returned in `FLAC__share__optarg', otherwise `FLAC__share__optarg' is set to zero.
497
498    If OPTSTRING starts with `-' or `+', it requests different methods of
499    handling the non-option ARGV-elements.
500    See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
501
502    Long-named options begin with `--' instead of `-'.
503    Their names may be abbreviated as long as the abbreviation is unique
504    or is an exact match for some defined option.  If they have an
505    argument, it follows the option name in the same ARGV-element, separated
506    from the option name by a `=', or else the in next ARGV-element.
507    When `FLAC__share__getopt' finds a long-named option, it returns 0 if that option's
508    `flag' field is nonzero, the value of the option's `val' field
509    if the `flag' field is zero.
510
511    The elements of ARGV aren't really const, because we permute them.
512    But we pretend they're const in the prototype to be compatible
513    with other systems.
514
515    LONGOPTS is a vector of `struct FLAC__share__option' terminated by an
516    element containing a name which is zero.
517
518    LONGIND returns the index in LONGOPT of the long-named option found.
519    It is only valid when a long-named option has been found by the most
520    recent call.
521
522    If LONG_ONLY is nonzero, '-' as well as '--' can introduce
523    long-named options.  */
524
525 int
526 FLAC__share___getopt_internal (argc, argv, optstring, longopts, longind, long_only)
527      int argc;
528      char *const *argv;
529      const char *optstring;
530      const struct FLAC__share__option *longopts;
531      int *longind;
532      int long_only;
533 {
534   FLAC__share__optarg = NULL;
535
536   if (FLAC__share__optind == 0 || !FLAC__share____getopt_initialized)
537     {
538       if (FLAC__share__optind == 0)
539         FLAC__share__optind = 1;        /* Don't scan ARGV[0], the program name.  */
540       optstring = FLAC__share___getopt_initialize (argc, argv, optstring);
541       FLAC__share____getopt_initialized = 1;
542     }
543
544   /* Test whether ARGV[FLAC__share__optind] points to a non-option argument.
545      Either it does not have option syntax, or there is an environment flag
546      from the shell indicating it is not an option.  The later information
547      is only used when the used in the GNU libc.  */
548 #ifdef _LIBC
549 # define NONOPTION_P (argv[FLAC__share__optind][0] != '-' || argv[FLAC__share__optind][1] == '\0'             \
550                       || (FLAC__share__optind < nonoption_flags_len                           \
551                           && __getopt_nonoption_flags[FLAC__share__optind] == '1'))
552 #else
553 # define NONOPTION_P (argv[FLAC__share__optind][0] != '-' || argv[FLAC__share__optind][1] == '\0')
554 #endif
555
556   if (nextchar == NULL || *nextchar == '\0')
557     {
558       /* Advance to the next ARGV-element.  */
559
560       /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
561          moved back by the user (who may also have changed the arguments).  */
562       if (last_nonopt > FLAC__share__optind)
563         last_nonopt = FLAC__share__optind;
564       if (first_nonopt > FLAC__share__optind)
565         first_nonopt = FLAC__share__optind;
566
567       if (ordering == PERMUTE)
568         {
569           /* If we have just processed some options following some non-options,
570              exchange them so that the options come first.  */
571
572           if (first_nonopt != last_nonopt && last_nonopt != FLAC__share__optind)
573             exchange ((char **) argv);
574           else if (last_nonopt != FLAC__share__optind)
575             first_nonopt = FLAC__share__optind;
576
577           /* Skip any additional non-options
578              and extend the range of non-options previously skipped.  */
579
580           while (FLAC__share__optind < argc && NONOPTION_P)
581             FLAC__share__optind++;
582           last_nonopt = FLAC__share__optind;
583         }
584
585       /* The special ARGV-element `--' means premature end of options.
586          Skip it like a null option,
587          then exchange with previous non-options as if it were an option,
588          then skip everything else like a non-option.  */
589
590       if (FLAC__share__optind != argc && !strcmp (argv[FLAC__share__optind], "--"))
591         {
592           FLAC__share__optind++;
593
594           if (first_nonopt != last_nonopt && last_nonopt != FLAC__share__optind)
595             exchange ((char **) argv);
596           else if (first_nonopt == last_nonopt)
597             first_nonopt = FLAC__share__optind;
598           last_nonopt = argc;
599
600           FLAC__share__optind = argc;
601         }
602
603       /* If we have done all the ARGV-elements, stop the scan
604          and back over any non-options that we skipped and permuted.  */
605
606       if (FLAC__share__optind == argc)
607         {
608           /* Set the next-arg-index to point at the non-options
609              that we previously skipped, so the caller will digest them.  */
610           if (first_nonopt != last_nonopt)
611             FLAC__share__optind = first_nonopt;
612           return -1;
613         }
614
615       /* If we have come to a non-option and did not permute it,
616          either stop the scan or describe it to the caller and pass it by.  */
617
618       if (NONOPTION_P)
619         {
620           if (ordering == REQUIRE_ORDER)
621             return -1;
622           FLAC__share__optarg = argv[FLAC__share__optind++];
623           return 1;
624         }
625
626       /* We have found another option-ARGV-element.
627          Skip the initial punctuation.  */
628
629       nextchar = (argv[FLAC__share__optind] + 1
630                   + (longopts != NULL && argv[FLAC__share__optind][1] == '-'));
631     }
632
633   /* Decode the current option-ARGV-element.  */
634
635   /* Check whether the ARGV-element is a long option.
636
637      If long_only and the ARGV-element has the form "-f", where f is
638      a valid short option, don't consider it an abbreviated form of
639      a long option that starts with f.  Otherwise there would be no
640      way to give the -f short option.
641
642      On the other hand, if there's a long option "fubar" and
643      the ARGV-element is "-fu", do consider that an abbreviation of
644      the long option, just like "--fu", and not "-f" with arg "u".
645
646      This distinction seems to be the most useful approach.  */
647
648   if (longopts != NULL
649       && (argv[FLAC__share__optind][1] == '-'
650           || (long_only && (argv[FLAC__share__optind][2] || !my_index (optstring, argv[FLAC__share__optind][1])))))
651     {
652       char *nameend;
653       const struct FLAC__share__option *p;
654       const struct FLAC__share__option *pfound = NULL;
655       int exact = 0;
656       int ambig = 0;
657       int indfound = -1;
658       int option_index;
659
660       for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
661         /* Do nothing.  */ ;
662
663       /* Test all long options for either exact match
664          or abbreviated matches.  */
665       for (p = longopts, option_index = 0; p->name; p++, option_index++)
666         if (!strncmp (p->name, nextchar, nameend - nextchar))
667           {
668             if ((unsigned int) (nameend - nextchar)
669                 == (unsigned int) strlen (p->name))
670               {
671                 /* Exact match found.  */
672                 pfound = p;
673                 indfound = option_index;
674                 exact = 1;
675                 break;
676               }
677             else if (pfound == NULL)
678               {
679                 /* First nonexact match found.  */
680                 pfound = p;
681                 indfound = option_index;
682               }
683             else
684               /* Second or later nonexact match found.  */
685               ambig = 1;
686           }
687
688       if (ambig && !exact)
689         {
690           if (FLAC__share__opterr)
691             fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
692                      argv[0], argv[FLAC__share__optind]);
693           nextchar += strlen (nextchar);
694           FLAC__share__optind++;
695           FLAC__share__optopt = 0;
696           return '?';
697         }
698
699       if (pfound != NULL)
700         {
701           option_index = indfound;
702           FLAC__share__optind++;
703           if (*nameend)
704             {
705               /* Don't test has_arg with >, because some C compilers don't
706                  allow it to be used on enums.  */
707               if (pfound->has_arg)
708                 FLAC__share__optarg = nameend + 1;
709               else
710                 {
711                   if (FLAC__share__opterr)
712                     {
713                       if (argv[FLAC__share__optind - 1][1] == '-')
714                         /* --option */
715                         fprintf (stderr,
716                                  _("%s: option `--%s' doesn't allow an argument\n"),
717                                  argv[0], pfound->name);
718                       else
719                         /* +option or -option */
720                         fprintf (stderr,
721                                  _("%s: option `%c%s' doesn't allow an argument\n"),
722                                  argv[0], argv[FLAC__share__optind - 1][0], pfound->name);
723                     }
724
725                   nextchar += strlen (nextchar);
726
727                   FLAC__share__optopt = pfound->val;
728                   return '?';
729                 }
730             }
731           else if (pfound->has_arg == 1)
732             {
733               if (FLAC__share__optind < argc)
734                 FLAC__share__optarg = argv[FLAC__share__optind++];
735               else
736                 {
737                   if (FLAC__share__opterr)
738                     fprintf (stderr,
739                            _("%s: option `%s' requires an argument\n"),
740                            argv[0], argv[FLAC__share__optind - 1]);
741                   nextchar += strlen (nextchar);
742                   FLAC__share__optopt = pfound->val;
743                   return optstring[0] == ':' ? ':' : '?';
744                 }
745             }
746           nextchar += strlen (nextchar);
747           if (longind != NULL)
748             *longind = option_index;
749           if (pfound->flag)
750             {
751               *(pfound->flag) = pfound->val;
752               return 0;
753             }
754           return pfound->val;
755         }
756
757       /* Can't find it as a long option.  If this is not FLAC__share__getopt_long_only,
758          or the option starts with '--' or is not a valid short
759          option, then it's an error.
760          Otherwise interpret it as a short option.  */
761       if (!long_only || argv[FLAC__share__optind][1] == '-'
762           || my_index (optstring, *nextchar) == NULL)
763         {
764           if (FLAC__share__opterr)
765             {
766               if (argv[FLAC__share__optind][1] == '-')
767                 /* --option */
768                 fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
769                          argv[0], nextchar);
770               else
771                 /* +option or -option */
772                 fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
773                          argv[0], argv[FLAC__share__optind][0], nextchar);
774             }
775           nextchar = (char *) "";
776           FLAC__share__optind++;
777           FLAC__share__optopt = 0;
778           return '?';
779         }
780     }
781
782   /* Look at and handle the next short option-character.  */
783
784   {
785     char c = *nextchar++;
786     char *temp = my_index (optstring, c);
787
788     /* Increment `FLAC__share__optind' when we start to process its last character.  */
789     if (*nextchar == '\0')
790       ++FLAC__share__optind;
791
792     if (temp == NULL || c == ':')
793       {
794         if (FLAC__share__opterr)
795           {
796             if (posixly_correct)
797               /* 1003.2 specifies the format of this message.  */
798               fprintf (stderr, _("%s: illegal option -- %c\n"),
799                        argv[0], c);
800             else
801               fprintf (stderr, _("%s: invalid option -- %c\n"),
802                        argv[0], c);
803           }
804         FLAC__share__optopt = c;
805         return '?';
806       }
807     /* Convenience. Treat POSIX -W foo same as long option --foo */
808     if (temp[0] == 'W' && temp[1] == ';')
809       {
810         char *nameend;
811         const struct FLAC__share__option *p;
812         const struct FLAC__share__option *pfound = NULL;
813         int exact = 0;
814         int ambig = 0;
815         int indfound = 0;
816         int option_index;
817
818         /* This is an option that requires an argument.  */
819         if (*nextchar != '\0')
820           {
821             FLAC__share__optarg = nextchar;
822             /* If we end this ARGV-element by taking the rest as an arg,
823                we must advance to the next element now.  */
824             FLAC__share__optind++;
825           }
826         else if (FLAC__share__optind == argc)
827           {
828             if (FLAC__share__opterr)
829               {
830                 /* 1003.2 specifies the format of this message.  */
831                 fprintf (stderr, _("%s: option requires an argument -- %c\n"),
832                          argv[0], c);
833               }
834             FLAC__share__optopt = c;
835             if (optstring[0] == ':')
836               c = ':';
837             else
838               c = '?';
839             return c;
840           }
841         else
842           /* We already incremented `FLAC__share__optind' once;
843              increment it again when taking next ARGV-elt as argument.  */
844           FLAC__share__optarg = argv[FLAC__share__optind++];
845
846         /* FLAC__share__optarg is now the argument, see if it's in the
847            table of longopts.  */
848
849         for (nextchar = nameend = FLAC__share__optarg; *nameend && *nameend != '='; nameend++)
850           /* Do nothing.  */ ;
851
852         /* Test all long options for either exact match
853            or abbreviated matches.  */
854         for (p = longopts, option_index = 0; p->name; p++, option_index++)
855           if (!strncmp (p->name, nextchar, nameend - nextchar))
856             {
857               if ((unsigned int) (nameend - nextchar) == strlen (p->name))
858                 {
859                   /* Exact match found.  */
860                   pfound = p;
861                   indfound = option_index;
862                   exact = 1;
863                   break;
864                 }
865               else if (pfound == NULL)
866                 {
867                   /* First nonexact match found.  */
868                   pfound = p;
869                   indfound = option_index;
870                 }
871               else
872                 /* Second or later nonexact match found.  */
873                 ambig = 1;
874             }
875         if (ambig && !exact)
876           {
877             if (FLAC__share__opterr)
878               fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
879                        argv[0], argv[FLAC__share__optind]);
880             nextchar += strlen (nextchar);
881             FLAC__share__optind++;
882             return '?';
883           }
884         if (pfound != NULL)
885           {
886             option_index = indfound;
887             if (*nameend)
888               {
889                 /* Don't test has_arg with >, because some C compilers don't
890                    allow it to be used on enums.  */
891                 if (pfound->has_arg)
892                   FLAC__share__optarg = nameend + 1;
893                 else
894                   {
895                     if (FLAC__share__opterr)
896                       fprintf (stderr, _("\
897 %s: option `-W %s' doesn't allow an argument\n"),
898                                argv[0], pfound->name);
899
900                     nextchar += strlen (nextchar);
901                     return '?';
902                   }
903               }
904             else if (pfound->has_arg == 1)
905               {
906                 if (FLAC__share__optind < argc)
907                   FLAC__share__optarg = argv[FLAC__share__optind++];
908                 else
909                   {
910                     if (FLAC__share__opterr)
911                       fprintf (stderr,
912                                _("%s: option `%s' requires an argument\n"),
913                                argv[0], argv[FLAC__share__optind - 1]);
914                     nextchar += strlen (nextchar);
915                     return optstring[0] == ':' ? ':' : '?';
916                   }
917               }
918             nextchar += strlen (nextchar);
919             if (longind != NULL)
920               *longind = option_index;
921             if (pfound->flag)
922               {
923                 *(pfound->flag) = pfound->val;
924                 return 0;
925               }
926             return pfound->val;
927           }
928           nextchar = NULL;
929           return 'W';   /* Let the application handle it.   */
930       }
931     if (temp[1] == ':')
932       {
933         if (temp[2] == ':')
934           {
935             /* This is an option that accepts an argument optionally.  */
936             if (*nextchar != '\0')
937               {
938                 FLAC__share__optarg = nextchar;
939                 FLAC__share__optind++;
940               }
941             else
942               FLAC__share__optarg = NULL;
943             nextchar = NULL;
944           }
945         else
946           {
947             /* This is an option that requires an argument.  */
948             if (*nextchar != '\0')
949               {
950                 FLAC__share__optarg = nextchar;
951                 /* If we end this ARGV-element by taking the rest as an arg,
952                    we must advance to the next element now.  */
953                 FLAC__share__optind++;
954               }
955             else if (FLAC__share__optind == argc)
956               {
957                 if (FLAC__share__opterr)
958                   {
959                     /* 1003.2 specifies the format of this message.  */
960                     fprintf (stderr,
961                            _("%s: option requires an argument -- %c\n"),
962                            argv[0], c);
963                   }
964                 FLAC__share__optopt = c;
965                 if (optstring[0] == ':')
966                   c = ':';
967                 else
968                   c = '?';
969               }
970             else
971               /* We already incremented `FLAC__share__optind' once;
972                  increment it again when taking next ARGV-elt as argument.  */
973               FLAC__share__optarg = argv[FLAC__share__optind++];
974             nextchar = NULL;
975           }
976       }
977     return c;
978   }
979 }
980
981 int
982 FLAC__share__getopt (argc, argv, optstring)
983      int argc;
984      char *const *argv;
985      const char *optstring;
986 {
987   return FLAC__share___getopt_internal (argc, argv, optstring,
988                            (const struct FLAC__share__option *) 0,
989                            (int *) 0,
990                            0);
991 }
992
993 #endif  /* Not ELIDE_CODE.  */
994 \f
995 #ifdef TEST
996
997 /* Compile with -DTEST to make an executable for use in testing
998    the above definition of `FLAC__share__getopt'.  */
999
1000 int
1001 main (argc, argv)
1002      int argc;
1003      char **argv;
1004 {
1005   int c;
1006   int digit_optind = 0;
1007
1008   while (1)
1009     {
1010       int this_option_optind = FLAC__share__optind ? FLAC__share__optind : 1;
1011
1012       c = FLAC__share__getopt (argc, argv, "abc:d:0123456789");
1013       if (c == -1)
1014         break;
1015
1016       switch (c)
1017         {
1018         case '0':
1019         case '1':
1020         case '2':
1021         case '3':
1022         case '4':
1023         case '5':
1024         case '6':
1025         case '7':
1026         case '8':
1027         case '9':
1028           if (digit_optind != 0 && digit_optind != this_option_optind)
1029             printf ("digits occur in two different argv-elements.\n");
1030           digit_optind = this_option_optind;
1031           printf ("option %c\n", c);
1032           break;
1033
1034         case 'a':
1035           printf ("option a\n");
1036           break;
1037
1038         case 'b':
1039           printf ("option b\n");
1040           break;
1041
1042         case 'c':
1043           printf ("option c with value `%s'\n", FLAC__share__optarg);
1044           break;
1045
1046         case '?':
1047           break;
1048
1049         default:
1050           printf ("?? getopt returned character code 0%o ??\n", c);
1051         }
1052     }
1053
1054   if (FLAC__share__optind < argc)
1055     {
1056       printf ("non-option ARGV-elements: ");
1057       while (FLAC__share__optind < argc)
1058         printf ("%s ", argv[FLAC__share__optind++]);
1059       printf ("\n");
1060     }
1061
1062   exit (0);
1063 }
1064
1065 #endif /* TEST */