epan: use json_dumper for json outputs.
[metze/wireshark/wip.git] / wsutil / getopt_long.c
1 /*
2    Copied from glibc-2.15 modified to compile on Windows.
3
4    Getopt for GNU.
5    NOTE: getopt is part of the C library, so if you don't know what
6    "Keep this file name-space clean" means, talk to drepper@gnu.org
7    before changing it!
8    Copyright (C) 1987-1996,1998-2004,2008,2009,2010,2011
9    Free Software Foundation, Inc.
10    This file is part of the GNU C Library.
11
12    SPDX-License-Identifier: LGPL-2.0-or-later
13  */
14
15 /* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.
16    Ditto for AIX 3.2 and <stdlib.h>.  */
17 #ifndef _NO_PROTO
18 # define _NO_PROTO
19 #endif
20
21 #include "config.h"
22
23 #include <stdio.h>
24
25 /* Comment out all this code if we are using the GNU C Library, and are not
26    actually compiling the library itself.  This code is part of the GNU C
27    Library, but also included in many other GNU distributions.  Compiling
28    and linking in this code is a waste when using the GNU C library
29    (especially if it is a shared library).  Rather than having every GNU
30    program understand `configure --with-gnu-libc' and omit the object files,
31    it is simpler to just do this in the source for each such file.  */
32
33 #define GETOPT_INTERFACE_VERSION 2
34 #if !defined _LIBC && defined __GLIBC__ && __GLIBC__ >= 2
35 # include <gnu-versions.h>
36 # if _GNU_GETOPT_INTERFACE_VERSION == GETOPT_INTERFACE_VERSION
37 #  define ELIDE_CODE
38 # endif
39 #endif
40
41 #ifndef ELIDE_CODE
42
43
44 /* This needs to come after some library #include
45    to get __GNU_LIBRARY__ defined.  */
46 #ifdef  __GNU_LIBRARY__
47 /* Don't include stdlib.h for non-GNU C libraries because some of them
48    contain conflicting prototypes for getopt.  */
49 # include <stdlib.h>
50 # include <unistd.h>
51 #endif  /* GNU C library.  */
52
53 #include <string.h>
54
55 #ifdef VMS
56 # include <unixlib.h>
57 #endif
58
59 #ifdef _LIBC
60 # include <libintl.h>
61 #else
62 /*# include "gettext.h" */
63 /*# define _(msgid) gettext (msgid) */
64 # define _(msgid)      (msgid)
65 #endif
66
67 /*
68  * If we have alloca.h, we assume we need it.
69  */
70 #
71 #ifdef HAVE_ALLOCA_H
72 # include <alloca.h>
73 #endif
74
75 #ifdef _WIN32
76 #  define alloca _alloca
77 #endif
78
79 #if defined _LIBC
80 # include <wchar.h>
81 #endif
82
83 #ifndef attribute_hidden
84 # define attribute_hidden
85 #endif
86
87 /* This version of `getopt' appears to the caller like standard Unix `getopt'
88    but it behaves differently for the user, since it allows the user
89    to intersperse the options with the other arguments.
90
91    As `getopt' works, it permutes the elements of ARGV so that,
92    when it is done, all the options precede everything else.  Thus
93    all application programs are extended to handle flexible argument order.
94
95    Setting the environment variable POSIXLY_CORRECT disables permutation.
96    Then the behavior is completely standard.
97
98    GNU application programs can use a third alternative mode in which
99    they can distinguish the relative order of options and other arguments.  */
100
101 #include "wsgetopt.h"
102 #include "getopt_long.h"
103
104 /* For communication from `getopt' to the caller.
105    When `getopt' finds an option that takes an argument,
106    the argument value is returned here.
107    Also, when `ordering' is RETURN_IN_ORDER,
108    each non-option ARGV-element is returned here.  */
109
110 char *optarg;
111
112 /* Index in ARGV of the next element to be scanned.
113    This is used for communication to and from the caller
114    and for communication between successive calls to `getopt'.
115
116    On entry to `getopt', zero means this is the first call; initialize.
117
118    When `getopt' returns -1, this is the index of the first of the
119    non-option elements that the caller should itself scan.
120
121    Otherwise, `optind' communicates from one call to the next
122    how much of ARGV has been scanned so far.  */
123
124 /* 1003.2 says this must be 1 before any call.  */
125 int optind = 1;
126
127 /* Callers store zero here to inhibit the error message
128    for unrecognized options.  */
129
130 int opterr = 1;
131
132 /* Set to an option character which was unrecognized.
133    This must be initialized on some systems to avoid linking in the
134    system's own getopt implementation.  */
135
136 int optopt = '?';
137
138 /* Keep a global copy of all internal members of getopt_data.  */
139
140 static struct _getopt_data getopt_data;
141
142 #ifndef __GNU_LIBRARY__
143
144 /* Avoid depending on library functions or files
145    whose names are inconsistent.  */
146
147 #ifndef getenv
148 extern char *getenv ();
149 #endif
150
151 #endif /* not __GNU_LIBRARY__ */
152
153 #ifdef _LIBC
154 /* Stored original parameters.
155    XXX This is no good solution.  We should rather copy the args so
156    that we can compare them later.  But we must not use malloc(3).  */
157 extern int __libc_argc;
158 extern char **__libc_argv;
159
160 /* Bash 2.0 gives us an environment variable containing flags
161    indicating ARGV elements that should not be considered arguments.  */
162
163 # ifdef USE_NONOPTION_FLAGS
164 /* Defined in getopt_init.c  */
165 extern char *__getopt_nonoption_flags;
166 # endif
167
168 # ifdef USE_NONOPTION_FLAGS
169 #  define SWAP_FLAGS(ch1, ch2) \
170   if (d->__nonoption_flags_len > 0)                                           \
171     {                                                                         \
172       char __tmp = __getopt_nonoption_flags[ch1];                             \
173       __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2];          \
174       __getopt_nonoption_flags[ch2] = __tmp;                                  \
175     }
176 # else
177 #  define SWAP_FLAGS(ch1, ch2)
178 # endif
179 #else   /* !_LIBC */
180 # define SWAP_FLAGS(ch1, ch2)
181 #endif  /* _LIBC */
182
183 /* Exchange two adjacent subsequences of ARGV.
184    One subsequence is elements [first_nonopt,last_nonopt)
185    which contains all the non-options that have been skipped so far.
186    The other is elements [last_nonopt,optind), which contains all
187    the options processed since those non-options were skipped.
188
189    `first_nonopt' and `last_nonopt' are relocated so that they describe
190    the new indices of the non-options in ARGV after they are moved.  */
191
192 static void
193 exchange (char **argv, struct _getopt_data *d)
194 {
195   int bottom = d->__first_nonopt;
196   int middle = d->__last_nonopt;
197   int top = d->optind;
198   char *tem;
199
200   /* Exchange the shorter segment with the far end of the longer segment.
201      That puts the shorter segment into the right place.
202      It leaves the longer segment in the right place overall,
203      but it consists of two parts that need to be swapped next.  */
204
205 #if defined _LIBC && defined USE_NONOPTION_FLAGS
206   /* First make sure the handling of the `__getopt_nonoption_flags'
207      string can work normally.  Our top argument must be in the range
208      of the string.  */
209   if (d->__nonoption_flags_len > 0 && top >= d->__nonoption_flags_max_len)
210     {
211       /* We must extend the array.  The user plays games with us and
212          presents new arguments.  */
213       char *new_str = malloc (top + 1);
214       if (new_str == NULL)
215         d->__nonoption_flags_len = d->__nonoption_flags_max_len = 0;
216       else
217         {
218           memset (__mempcpy (new_str, __getopt_nonoption_flags,
219                              d->__nonoption_flags_max_len),
220                   '\0', top + 1 - d->__nonoption_flags_max_len);
221           d->__nonoption_flags_max_len = top + 1;
222           __getopt_nonoption_flags = new_str;
223         }
224     }
225 #endif
226
227   while (top > middle && middle > bottom)
228     {
229       if (top - middle > middle - bottom)
230         {
231           /* Bottom segment is the short one.  */
232           int len = middle - bottom;
233           register int i;
234
235           /* Swap it with the top part of the top segment.  */
236           for (i = 0; i < len; i++)
237             {
238               tem = argv[bottom + i];
239               argv[bottom + i] = argv[top - (middle - bottom) + i];
240               argv[top - (middle - bottom) + i] = tem;
241               SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
242             }
243           /* Exclude the moved bottom segment from further swapping.  */
244           top -= len;
245         }
246       else
247         {
248           /* Top segment is the short one.  */
249           int len = top - middle;
250           register int i;
251
252           /* Swap it with the bottom part of the bottom segment.  */
253           for (i = 0; i < len; i++)
254             {
255               tem = argv[bottom + i];
256               argv[bottom + i] = argv[middle + i];
257               argv[middle + i] = tem;
258               SWAP_FLAGS (bottom + i, middle + i);
259             }
260           /* Exclude the moved top segment from further swapping.  */
261           bottom += len;
262         }
263     }
264
265   /* Update records for the slots the non-options now occupy.  */
266
267   d->__first_nonopt += (d->optind - d->__last_nonopt);
268   d->__last_nonopt = d->optind;
269 }
270
271 /* Initialize the internal data when the first call is made.  */
272
273 static const char *
274 _getopt_initialize (int argc, char *const *argv, const char *optstring,
275                     struct _getopt_data *d, int posixly_correct)
276 {
277   /* Start processing options with ARGV-element 1 (since ARGV-element 0
278      is the program name); the sequence of previously skipped
279      non-option ARGV-elements is empty.  */
280
281   d->__first_nonopt = d->__last_nonopt = d->optind;
282
283   d->__nextchar = NULL;
284
285   d->__posixly_correct = posixly_correct | !!getenv ("POSIXLY_CORRECT");
286
287   /* Determine how to handle the ordering of options and nonoptions.  */
288
289   if (optstring[0] == '-')
290     {
291       d->__ordering = RETURN_IN_ORDER;
292       ++optstring;
293     }
294   else if (optstring[0] == '+')
295     {
296       d->__ordering = REQUIRE_ORDER;
297       ++optstring;
298     }
299   else if (d->__posixly_correct)
300     d->__ordering = REQUIRE_ORDER;
301   else
302     d->__ordering = PERMUTE;
303
304 #if defined _LIBC && defined USE_NONOPTION_FLAGS
305   if (!d->__posixly_correct
306       && argc == __libc_argc && argv == __libc_argv)
307     {
308       if (d->__nonoption_flags_max_len == 0)
309         {
310           if (__getopt_nonoption_flags == NULL
311               || __getopt_nonoption_flags[0] == '\0')
312             d->__nonoption_flags_max_len = -1;
313           else
314             {
315               const char *orig_str = __getopt_nonoption_flags;
316               int len = d->__nonoption_flags_max_len = strlen (orig_str);
317               if (d->__nonoption_flags_max_len < argc)
318                 d->__nonoption_flags_max_len = argc;
319               __getopt_nonoption_flags =
320                 (char *) malloc (d->__nonoption_flags_max_len);
321               if (__getopt_nonoption_flags == NULL)
322                 d->__nonoption_flags_max_len = -1;
323               else
324                 memset (__mempcpy (__getopt_nonoption_flags, orig_str, len),
325                         '\0', d->__nonoption_flags_max_len - len);
326             }
327         }
328       d->__nonoption_flags_len = d->__nonoption_flags_max_len;
329     }
330   else
331     d->__nonoption_flags_len = 0;
332 #endif
333
334   return optstring;
335 }
336
337 /* Scan elements of ARGV (whose length is ARGC) for option characters
338    given in OPTSTRING.
339
340    If an element of ARGV starts with '-', and is not exactly "-" or "--",
341    then it is an option element.  The characters of this element
342    (aside from the initial '-') are option characters.  If `getopt'
343    is called repeatedly, it returns successively each of the option characters
344    from each of the option elements.
345
346    If `getopt' finds another option character, it returns that character,
347    updating `optind' and `nextchar' so that the next call to `getopt' can
348    resume the scan with the following option character or ARGV-element.
349
350    If there are no more option characters, `getopt' returns -1.
351    Then `optind' is the index in ARGV of the first ARGV-element
352    that is not an option.  (The ARGV-elements have been permuted
353    so that those that are not options now come last.)
354
355    OPTSTRING is a string containing the legitimate option characters.
356    If an option character is seen that is not listed in OPTSTRING,
357    return '?' after printing an error message.  If you set `opterr' to
358    zero, the error message is suppressed but we still return '?'.
359
360    If a char in OPTSTRING is followed by a colon, that means it wants an arg,
361    so the following text in the same ARGV-element, or the text of the following
362    ARGV-element, is returned in `optarg'.  Two colons mean an option that
363    wants an optional arg; if there is text in the current ARGV-element,
364    it is returned in `optarg', otherwise `optarg' is set to zero.
365
366    If OPTSTRING starts with `-' or `+', it requests different methods of
367    handling the non-option ARGV-elements.
368    See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
369
370    Long-named options begin with `--' instead of `-'.
371    Their names may be abbreviated as long as the abbreviation is unique
372    or is an exact match for some defined option.  If they have an
373    argument, it follows the option name in the same ARGV-element, separated
374    from the option name by a `=', or else the in next ARGV-element.
375    When `getopt' finds a long-named option, it returns 0 if that option's
376    `flag' field is nonzero, the value of the option's `val' field
377    if the `flag' field is zero.
378
379    The elements of ARGV aren't really const, because we permute them.
380    But we pretend they're const in the prototype to be compatible
381    with other systems.
382
383    LONGOPTS is a vector of `struct option' terminated by an
384    element containing a name which is zero.
385
386    LONGIND returns the index in LONGOPT of the long-named option found.
387    It is only valid when a long-named option has been found by the most
388    recent call.
389
390    If LONG_ONLY is nonzero, '-' as well as '--' can introduce
391    long-named options.  */
392
393 int
394 _getopt_internal_r (int argc, char *const *argv, const char *optstring,
395                     const struct option *longopts, int *longind,
396                     int long_only, struct _getopt_data *d, int posixly_correct)
397 {
398   int print_errors = d->opterr;
399
400   if (argc < 1)
401     return -1;
402
403   d->optarg = NULL;
404
405   if (d->optind == 0 || !d->__initialized)
406     {
407       if (d->optind == 0)
408         d->optind = 1;  /* Don't scan ARGV[0], the program name.  */
409       optstring = _getopt_initialize (argc, argv, optstring, d,
410                                       posixly_correct);
411       d->__initialized = 1;
412     }
413   else if (optstring[0] == '-' || optstring[0] == '+')
414     optstring++;
415   if (optstring[0] == ':')
416     print_errors = 0;
417
418   /* Test whether ARGV[optind] points to a non-option argument.
419      Either it does not have option syntax, or there is an environment flag
420      from the shell indicating it is not an option.  The later information
421      is only used when the used in the GNU libc.  */
422 #if defined _LIBC && defined USE_NONOPTION_FLAGS
423 # define NONOPTION_P (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0' \
424                       || (d->optind < d->__nonoption_flags_len                \
425                           && __getopt_nonoption_flags[d->optind] == '1'))
426 #else
427 # define NONOPTION_P (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0')
428 #endif
429
430   if (d->__nextchar == NULL || *d->__nextchar == '\0')
431     {
432       /* Advance to the next ARGV-element.  */
433
434       /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
435          moved back by the user (who may also have changed the arguments).  */
436       if (d->__last_nonopt > d->optind)
437         d->__last_nonopt = d->optind;
438       if (d->__first_nonopt > d->optind)
439         d->__first_nonopt = d->optind;
440
441       if (d->__ordering == PERMUTE)
442         {
443           /* If we have just processed some options following some non-options,
444              exchange them so that the options come first.  */
445
446           if (d->__first_nonopt != d->__last_nonopt
447               && d->__last_nonopt != d->optind)
448             exchange ((char **) argv, d);
449           else if (d->__last_nonopt != d->optind)
450             d->__first_nonopt = d->optind;
451
452           /* Skip any additional non-options
453              and extend the range of non-options previously skipped.  */
454
455           while (d->optind < argc && NONOPTION_P)
456             d->optind++;
457           d->__last_nonopt = d->optind;
458         }
459
460       /* The special ARGV-element `--' means premature end of options.
461          Skip it like a null option,
462          then exchange with previous non-options as if it were an option,
463          then skip everything else like a non-option.  */
464
465       if (d->optind != argc && !strcmp (argv[d->optind], "--"))
466         {
467           d->optind++;
468
469           if (d->__first_nonopt != d->__last_nonopt
470               && d->__last_nonopt != d->optind)
471             exchange ((char **) argv, d);
472           else if (d->__first_nonopt == d->__last_nonopt)
473             d->__first_nonopt = d->optind;
474           d->__last_nonopt = argc;
475
476           d->optind = argc;
477         }
478
479       /* If we have done all the ARGV-elements, stop the scan
480          and back over any non-options that we skipped and permuted.  */
481
482       if (d->optind == argc)
483         {
484           /* Set the next-arg-index to point at the non-options
485              that we previously skipped, so the caller will digest them.  */
486           if (d->__first_nonopt != d->__last_nonopt)
487             d->optind = d->__first_nonopt;
488           return -1;
489         }
490
491       /* If we have come to a non-option and did not permute it,
492          either stop the scan or describe it to the caller and pass it by.  */
493
494       if (NONOPTION_P)
495         {
496           if (d->__ordering == REQUIRE_ORDER)
497             return -1;
498           d->optarg = argv[d->optind++];
499           return 1;
500         }
501
502       /* We have found another option-ARGV-element.
503          Skip the initial punctuation.  */
504
505       d->__nextchar = (argv[d->optind] + 1
506                   + (longopts != NULL && argv[d->optind][1] == '-'));
507     }
508
509   /* Decode the current option-ARGV-element.  */
510
511   /* Check whether the ARGV-element is a long option.
512
513      If long_only and the ARGV-element has the form "-f", where f is
514      a valid short option, don't consider it an abbreviated form of
515      a long option that starts with f.  Otherwise there would be no
516      way to give the -f short option.
517
518      On the other hand, if there's a long option "fubar" and
519      the ARGV-element is "-fu", do consider that an abbreviation of
520      the long option, just like "--fu", and not "-f" with arg "u".
521
522      This distinction seems to be the most useful approach.  */
523
524   if (longopts != NULL
525       && (argv[d->optind][1] == '-'
526           || (long_only && (argv[d->optind][2]
527                             || !strchr (optstring, argv[d->optind][1])))))
528     {
529       char *nameend;
530       size_t namelen;
531       const struct option *p;
532       const struct option *pfound = NULL;
533       struct option_list
534       {
535         const struct option *p;
536         struct option_list *next;
537       } *ambig_list = NULL;
538       int exact = 0;
539       int indfound = -1;
540       int option_index;
541
542       for (nameend = d->__nextchar; *nameend && *nameend != '='; nameend++)
543         /* Do nothing.  */ ;
544       namelen = nameend - d->__nextchar;
545
546       /* Test all long options for either exact match
547          or abbreviated matches.  */
548       for (p = longopts, option_index = 0; p->name; p++, option_index++)
549         if (!strncmp (p->name, d->__nextchar, namelen))
550           {
551             if (namelen == (unsigned int) strlen (p->name))
552               {
553                 /* Exact match found.  */
554                 pfound = p;
555                 indfound = option_index;
556                 exact = 1;
557                 break;
558               }
559             else if (pfound == NULL)
560               {
561                 /* First nonexact match found.  */
562                 pfound = p;
563                 indfound = option_index;
564               }
565             else if (long_only
566                      || pfound->has_arg != p->has_arg
567                      || pfound->flag != p->flag
568                      || pfound->val != p->val)
569               {
570                 /* Second or later nonexact match found.  */
571                 struct option_list *newp = alloca (sizeof (*newp));
572                 newp->p = p;
573                 newp->next = ambig_list;
574                 ambig_list = newp;
575               }
576           }
577
578       if (ambig_list != NULL && !exact)
579         {
580           if (print_errors)
581             {
582               struct option_list first;
583               first.p = pfound;
584               first.next = ambig_list;
585               ambig_list = &first;
586
587 #if defined _LIBC
588               char *buf = NULL;
589               size_t buflen = 0;
590
591               FILE *fp = open_memstream (&buf, &buflen);
592               if (fp != NULL)
593                 {
594                   fprintf (fp,
595                            _("%s: option '%s' is ambiguous; possibilities:"),
596                            argv[0], argv[d->optind]);
597
598                   do
599                     {
600                       fprintf (fp, " '--%s'", ambig_list->p->name);
601                       ambig_list = ambig_list->next;
602                     }
603                   while (ambig_list != NULL);
604
605                   fputc_unlocked ('\n', fp);
606
607                   if (__builtin_expect (fclose (fp) != EOF, 1))
608                     {
609                       _IO_flockfile (stderr);
610
611                       int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
612                       ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
613
614                       __fxprintf (NULL, "%s", buf);
615
616                       ((_IO_FILE *) stderr)->_flags2 = old_flags2;
617                       _IO_funlockfile (stderr);
618
619                       free (buf);
620                     }
621                 }
622 #else
623               fprintf (stderr,
624                        _("%s: option '%s' is ambiguous; possibilities:"),
625                        argv[0], argv[d->optind]);
626               do
627                 {
628                   fprintf (stderr, " '--%s'", ambig_list->p->name);
629                   ambig_list = ambig_list->next;
630                 }
631               while (ambig_list != NULL);
632
633               fputc ('\n', stderr);
634 #endif
635             }
636           d->__nextchar += strlen (d->__nextchar);
637           d->optind++;
638           d->optopt = 0;
639           return '?';
640         }
641
642       if (pfound != NULL)
643         {
644           option_index = indfound;
645           d->optind++;
646           if (*nameend)
647             {
648               /* Don't test has_arg with >, because some C compilers don't
649                  allow it to be used on enums.  */
650               if (pfound->has_arg)
651                 d->optarg = nameend + 1;
652               else
653                 {
654                   if (print_errors)
655                     {
656 #if defined _LIBC
657                       char *buf;
658                       int n;
659 #endif
660
661                       if (argv[d->optind - 1][1] == '-')
662                         {
663                           /* --option */
664 #if defined _LIBC
665                           n = __asprintf (&buf, _("\
666 %s: option '--%s' doesn't allow an argument\n"),
667                                           argv[0], pfound->name);
668 #else
669                           fprintf (stderr, _("\
670 %s: option '--%s' doesn't allow an argument\n"),
671                                    argv[0], pfound->name);
672 #endif
673                         }
674                       else
675                         {
676                           /* +option or -option */
677 #if defined _LIBC
678                           n = __asprintf (&buf, _("\
679 %s: option '%c%s' doesn't allow an argument\n"),
680                                           argv[0], argv[d->optind - 1][0],
681                                           pfound->name);
682 #else
683                           fprintf (stderr, _("\
684 %s: option '%c%s' doesn't allow an argument\n"),
685                                    argv[0], argv[d->optind - 1][0],
686                                    pfound->name);
687 #endif
688                         }
689
690 #if defined _LIBC
691                       if (n >= 0)
692                         {
693                           _IO_flockfile (stderr);
694
695                           int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
696                           ((_IO_FILE *) stderr)->_flags2
697                             |= _IO_FLAGS2_NOTCANCEL;
698
699                           __fxprintf (NULL, "%s", buf);
700
701                           ((_IO_FILE *) stderr)->_flags2 = old_flags2;
702                           _IO_funlockfile (stderr);
703
704                           free (buf);
705                         }
706 #endif
707                     }
708
709                   d->__nextchar += strlen (d->__nextchar);
710
711                   d->optopt = pfound->val;
712                   return '?';
713                 }
714             }
715           else if (pfound->has_arg == 1)
716             {
717               if (d->optind < argc)
718                 d->optarg = argv[d->optind++];
719               else
720                 {
721                   if (print_errors)
722                     {
723 #if defined _LIBC
724                       char *buf;
725
726                       if (__asprintf (&buf, _("\
727 %s: option '--%s' requires an argument\n"),
728                                       argv[0], pfound->name) >= 0)
729                         {
730                           _IO_flockfile (stderr);
731
732                           int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
733                           ((_IO_FILE *) stderr)->_flags2
734                             |= _IO_FLAGS2_NOTCANCEL;
735
736                           __fxprintf (NULL, "%s", buf);
737
738                           ((_IO_FILE *) stderr)->_flags2 = old_flags2;
739                           _IO_funlockfile (stderr);
740
741                           free (buf);
742                         }
743 #else
744                       fprintf (stderr,
745                                _("%s: option '--%s' requires an argument\n"),
746                                argv[0], pfound->name);
747 #endif
748                     }
749                   d->__nextchar += strlen (d->__nextchar);
750                   d->optopt = pfound->val;
751                   return optstring[0] == ':' ? ':' : '?';
752                 }
753             }
754           d->__nextchar += strlen (d->__nextchar);
755           if (longind != NULL)
756             *longind = option_index;
757           if (pfound->flag)
758             {
759               *(pfound->flag) = pfound->val;
760               return 0;
761             }
762           return pfound->val;
763         }
764
765       /* Can't find it as a long option.  If this is not getopt_long_only,
766          or the option starts with '--' or is not a valid short
767          option, then it's an error.
768          Otherwise interpret it as a short option.  */
769       if (!long_only || argv[d->optind][1] == '-'
770           || strchr (optstring, *d->__nextchar) == NULL)
771         {
772           if (print_errors)
773             {
774 #if defined _LIBC
775               char *buf;
776               int n;
777 #endif
778
779               if (argv[d->optind][1] == '-')
780                 {
781                   /* --option */
782 #if defined _LIBC
783                   n = __asprintf (&buf, _("%s: unrecognized option '--%s'\n"),
784                                   argv[0], d->__nextchar);
785 #else
786                   fprintf (stderr, _("%s: unrecognized option '--%s'\n"),
787                            argv[0], d->__nextchar);
788 #endif
789                 }
790               else
791                 {
792                   /* +option or -option */
793 #if defined _LIBC
794                   n = __asprintf (&buf, _("%s: unrecognized option '%c%s'\n"),
795                                   argv[0], argv[d->optind][0], d->__nextchar);
796 #else
797                   fprintf (stderr, _("%s: unrecognized option '%c%s'\n"),
798                            argv[0], argv[d->optind][0], d->__nextchar);
799 #endif
800                 }
801
802 #if defined _LIBC
803               if (n >= 0)
804                 {
805                   _IO_flockfile (stderr);
806
807                   int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
808                   ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
809
810                   __fxprintf (NULL, "%s", buf);
811
812                   ((_IO_FILE *) stderr)->_flags2 = old_flags2;
813                   _IO_funlockfile (stderr);
814
815                   free (buf);
816                 }
817 #endif
818             }
819           d->__nextchar = "";
820           d->optind++;
821           d->optopt = 0;
822           return '?';
823         }
824     }
825
826   /* Look at and handle the next short option-character.  */
827
828   {
829     char c = *d->__nextchar++;
830     char *temp = strchr (optstring, c);
831         char *nameend;
832         const struct option *p;
833         const struct option *pfound = NULL;
834         int exact = 0;
835         int ambig = 0;
836         int indfound = 0;
837         int option_index;
838
839     /* Increment `optind' when we start to process its last character.  */
840     if (*d->__nextchar == '\0')
841       ++d->optind;
842
843     if (temp == NULL || c == ':' || c == ';')
844       {
845         if (print_errors)
846           {
847 #if defined _LIBC
848             char *buf;
849             int n;
850 #endif
851
852 #if defined _LIBC
853             n = __asprintf (&buf, _("%s: invalid option -- '%c'\n"),
854                             argv[0], c);
855 #else
856             fprintf (stderr, _("%s: invalid option -- '%c'\n"), argv[0], c);
857 #endif
858
859 #if defined _LIBC
860             if (n >= 0)
861               {
862                 _IO_flockfile (stderr);
863
864                 int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
865                 ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
866
867                 __fxprintf (NULL, "%s", buf);
868
869                 ((_IO_FILE *) stderr)->_flags2 = old_flags2;
870                 _IO_funlockfile (stderr);
871
872                 free (buf);
873               }
874 #endif
875           }
876         d->optopt = c;
877         return '?';
878       }
879     /* Convenience. Treat POSIX -W foo same as long option --foo */
880     if (temp[0] == 'W' && temp[1] == ';')
881       {
882         if (longopts == NULL)
883           goto no_longs;
884
885
886         /* This is an option that requires an argument.  */
887         if (*d->__nextchar != '\0')
888           {
889             d->optarg = d->__nextchar;
890             /* If we end this ARGV-element by taking the rest as an arg,
891                we must advance to the next element now.  */
892             d->optind++;
893           }
894         else if (d->optind == argc)
895           {
896             if (print_errors)
897               {
898 #if defined _LIBC
899                 char *buf;
900
901                 if (__asprintf (&buf,
902                                 _("%s: option requires an argument -- '%c'\n"),
903                                 argv[0], c) >= 0)
904                   {
905                     _IO_flockfile (stderr);
906
907                     int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
908                     ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
909
910                     __fxprintf (NULL, "%s", buf);
911
912                     ((_IO_FILE *) stderr)->_flags2 = old_flags2;
913                     _IO_funlockfile (stderr);
914
915                     free (buf);
916                   }
917 #else
918                 fprintf (stderr,
919                          _("%s: option requires an argument -- '%c'\n"),
920                          argv[0], c);
921 #endif
922               }
923             d->optopt = c;
924             if (optstring[0] == ':')
925               c = ':';
926             else
927               c = '?';
928             return c;
929           }
930         else
931           /* We already incremented `d->optind' once;
932              increment it again when taking next ARGV-elt as argument.  */
933           d->optarg = argv[d->optind++];
934
935         /* optarg is now the argument, see if it's in the
936            table of longopts.  */
937
938         for (d->__nextchar = nameend = d->optarg; *nameend && *nameend != '=';
939              nameend++)
940           /* Do nothing.  */ ;
941
942         /* Test all long options for either exact match
943            or abbreviated matches.  */
944         for (p = longopts, option_index = 0; p->name; p++, option_index++)
945           if (!strncmp (p->name, d->__nextchar, nameend - d->__nextchar))
946             {
947               if ((unsigned int) (nameend - d->__nextchar) == strlen (p->name))
948                 {
949                   /* Exact match found.  */
950                   pfound = p;
951                   indfound = option_index;
952                   exact = 1;
953                   break;
954                 }
955               else if (pfound == NULL)
956                 {
957                   /* First nonexact match found.  */
958                   pfound = p;
959                   indfound = option_index;
960                 }
961               else if (long_only
962                        || pfound->has_arg != p->has_arg
963                        || pfound->flag != p->flag
964                        || pfound->val != p->val)
965                 /* Second or later nonexact match found.  */
966                 ambig = 1;
967             }
968         if (ambig && !exact)
969           {
970             if (print_errors)
971               {
972 #if defined _LIBC
973                 char *buf;
974
975                 if (__asprintf (&buf, _("%s: option '-W %s' is ambiguous\n"),
976                                 argv[0], d->optarg) >= 0)
977                   {
978                     _IO_flockfile (stderr);
979
980                     int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
981                     ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
982
983                     __fxprintf (NULL, "%s", buf);
984
985                     ((_IO_FILE *) stderr)->_flags2 = old_flags2;
986                     _IO_funlockfile (stderr);
987
988                     free (buf);
989                   }
990 #else
991                 fprintf (stderr, _("%s: option '-W %s' is ambiguous\n"),
992                          argv[0], d->optarg);
993 #endif
994               }
995             d->__nextchar += strlen (d->__nextchar);
996             d->optind++;
997             return '?';
998           }
999         if (pfound != NULL)
1000           {
1001             option_index = indfound;
1002             if (*nameend)
1003               {
1004                 /* Don't test has_arg with >, because some C compilers don't
1005                    allow it to be used on enums.  */
1006                 if (pfound->has_arg)
1007                   d->optarg = nameend + 1;
1008                 else
1009                   {
1010                     if (print_errors)
1011                       {
1012 #if defined _LIBC
1013                         char *buf;
1014
1015                         if (__asprintf (&buf, _("\
1016 %s: option '-W %s' doesn't allow an argument\n"),
1017                                         argv[0], pfound->name) >= 0)
1018                           {
1019                             _IO_flockfile (stderr);
1020
1021                             int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
1022                             ((_IO_FILE *) stderr)->_flags2
1023                               |= _IO_FLAGS2_NOTCANCEL;
1024
1025                             __fxprintf (NULL, "%s", buf);
1026
1027                             ((_IO_FILE *) stderr)->_flags2 = old_flags2;
1028                             _IO_funlockfile (stderr);
1029
1030                             free (buf);
1031                           }
1032 #else
1033                         fprintf (stderr, _("\
1034 %s: option '-W %s' doesn't allow an argument\n"),
1035                                  argv[0], pfound->name);
1036 #endif
1037                       }
1038
1039                     d->__nextchar += strlen (d->__nextchar);
1040                     return '?';
1041                   }
1042               }
1043             else if (pfound->has_arg == 1)
1044               {
1045                 if (d->optind < argc)
1046                   d->optarg = argv[d->optind++];
1047                 else
1048                   {
1049                     if (print_errors)
1050                       {
1051 #if defined _LIBC
1052                         char *buf;
1053
1054                         if (__asprintf (&buf, _("\
1055 %s: option '-W %s' requires an argument\n"),
1056                                         argv[0], pfound->name) >= 0)
1057                           {
1058                             _IO_flockfile (stderr);
1059
1060                             int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
1061                             ((_IO_FILE *) stderr)->_flags2
1062                               |= _IO_FLAGS2_NOTCANCEL;
1063
1064                             __fxprintf (NULL, "%s", buf);
1065
1066                             ((_IO_FILE *) stderr)->_flags2 = old_flags2;
1067                             _IO_funlockfile (stderr);
1068
1069                             free (buf);
1070                           }
1071 #else
1072                         fprintf (stderr, _("\
1073 %s: option '-W %s' requires an argument\n"),
1074                                  argv[0], pfound->name);
1075 #endif
1076                       }
1077                     d->__nextchar += strlen (d->__nextchar);
1078                     return optstring[0] == ':' ? ':' : '?';
1079                   }
1080               }
1081             else
1082               d->optarg = NULL;
1083             d->__nextchar += strlen (d->__nextchar);
1084             if (longind != NULL)
1085               *longind = option_index;
1086             if (pfound->flag)
1087               {
1088                 *(pfound->flag) = pfound->val;
1089                 return 0;
1090               }
1091             return pfound->val;
1092           }
1093
1094       no_longs:
1095         d->__nextchar = NULL;
1096         return 'W';     /* Let the application handle it.   */
1097       }
1098     if (temp[1] == ':')
1099       {
1100         if (temp[2] == ':')
1101           {
1102             /* This is an option that accepts an argument optionally.  */
1103             if (*d->__nextchar != '\0')
1104               {
1105                 d->optarg = d->__nextchar;
1106                 d->optind++;
1107               }
1108             else
1109               d->optarg = NULL;
1110             d->__nextchar = NULL;
1111           }
1112         else
1113           {
1114             /* This is an option that requires an argument.  */
1115             if (*d->__nextchar != '\0')
1116               {
1117                 d->optarg = d->__nextchar;
1118                 /* If we end this ARGV-element by taking the rest as an arg,
1119                    we must advance to the next element now.  */
1120                 d->optind++;
1121               }
1122             else if (d->optind == argc)
1123               {
1124                 if (print_errors)
1125                   {
1126 #if defined _LIBC
1127                     char *buf;
1128
1129                     if (__asprintf (&buf, _("\
1130 %s: option requires an argument -- '%c'\n"),
1131                                     argv[0], c) >= 0)
1132                       {
1133                         _IO_flockfile (stderr);
1134
1135                         int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
1136                         ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
1137
1138                         __fxprintf (NULL, "%s", buf);
1139
1140                         ((_IO_FILE *) stderr)->_flags2 = old_flags2;
1141                         _IO_funlockfile (stderr);
1142
1143                         free (buf);
1144                       }
1145 #else
1146                     fprintf (stderr,
1147                              _("%s: option requires an argument -- '%c'\n"),
1148                              argv[0], c);
1149 #endif
1150                   }
1151                 d->optopt = c;
1152                 if (optstring[0] == ':')
1153                   c = ':';
1154                 else
1155                   c = '?';
1156               }
1157             else
1158               /* We already incremented `optind' once;
1159                  increment it again when taking next ARGV-elt as argument.  */
1160               d->optarg = argv[d->optind++];
1161             d->__nextchar = NULL;
1162           }
1163       }
1164     return c;
1165   }
1166 }
1167
1168 int
1169 _getopt_internal (int argc, char *const *argv, const char *optstring,
1170                   const struct option *longopts, int *longind, int long_only,
1171                   int posixly_correct)
1172 {
1173   int result;
1174
1175   getopt_data.optind = optind;
1176   getopt_data.opterr = opterr;
1177
1178   result = _getopt_internal_r (argc, argv, optstring, longopts,
1179                                longind, long_only, &getopt_data,
1180                                posixly_correct);
1181
1182   optind = getopt_data.optind;
1183   optarg = getopt_data.optarg;
1184   optopt = getopt_data.optopt;
1185
1186   return result;
1187 }
1188
1189 int
1190 getopt (int argc, char *const *argv, const char *optstring)
1191 {
1192   return _getopt_internal (argc, argv, optstring,
1193                            (const struct option *) 0,
1194                            (int *) 0,
1195                            0, 0);
1196 }
1197
1198 /* getopt_long() was copied from posix/getopt1.c
1199    the rest of this file is a nearly identical copy of posix/getopt.c */
1200 int
1201 getopt_long (int argc, char *const *argv, const char *options,
1202               const struct option *long_options, int *opt_index)
1203 {
1204   return _getopt_internal (argc, argv, options, long_options,
1205                            opt_index, 0, 0);
1206 }
1207
1208
1209 #ifdef _LIBC
1210 int
1211 __posix_getopt (int argc, char *const *argv, const char *optstring)
1212 {
1213   return _getopt_internal (argc, argv, optstring,
1214                            (const struct option *) 0,
1215                            (int *) 0,
1216                            0, 1);
1217 }
1218 #endif
1219
1220 #endif  /* Not ELIDE_CODE.  */
1221
1222 #ifdef TEST
1223
1224 /* Compile with -DTEST to make an executable for use in testing
1225    the above definition of `getopt'.  */
1226
1227 int
1228 main (int argc, char **argv)
1229 {
1230   int c;
1231   int digit_optind = 0;
1232
1233   while (1)
1234     {
1235       int this_option_optind = optind ? optind : 1;
1236
1237       c = getopt (argc, argv, "abc:d:0123456789");
1238       if (c == -1)
1239         break;
1240
1241       switch (c)
1242         {
1243         case '0':
1244         case '1':
1245         case '2':
1246         case '3':
1247         case '4':
1248         case '5':
1249         case '6':
1250         case '7':
1251         case '8':
1252         case '9':
1253           if (digit_optind != 0 && digit_optind != this_option_optind)
1254             printf ("digits occur in two different argv-elements.\n");
1255           digit_optind = this_option_optind;
1256           printf ("option %c\n", c);
1257           break;
1258
1259         case 'a':
1260           printf ("option a\n");
1261           break;
1262
1263         case 'b':
1264           printf ("option b\n");
1265           break;
1266
1267         case 'c':
1268           printf ("option c with value '%s'\n", optarg);
1269           break;
1270
1271         case '?':
1272           break;
1273
1274         default:
1275           printf ("?? getopt returned character code 0%o ??\n", c);
1276         }
1277     }
1278
1279   if (optind < argc)
1280     {
1281       printf ("non-option ARGV-elements: ");
1282       while (optind < argc)
1283         printf ("%s ", argv[optind++]);
1284       printf ("\n");
1285     }
1286
1287   exit (0);
1288 }
1289
1290 #endif /* TEST */
1291
1292 /*
1293  * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
1294  *
1295  * Local Variables:
1296  * c-basic-offset: 2
1297  * tab-width: 8
1298  * indent-tabs-mode: nil
1299  * End:
1300  *
1301  * ex: set shiftwidth=2 tabstop=8 expandtab:
1302  * :indentSize=2:tabSize=8:noTabs=true:
1303  */