/[public]/getopt/trunk/gnu/getopt.c
ViewVC logotype

Annotation of /getopt/trunk/gnu/getopt.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 259 - (hide annotations)
Mon Nov 7 22:09:10 2005 UTC (18 years, 4 months ago) by frodo
File MIME type: text/plain
File size: 30131 byte(s)
Imported sources

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

frodo@frodo.looijaard.name
ViewVC Help
Powered by ViewVC 1.1.26