chiark / gitweb /
Python encoding declaration
[secnet.git] / getopt.c
1 /* Getopt for GNU.
2    NOTE: getopt is now part of the C library, so if you don't know what
3    "Keep this file name-space clean" means, talk to roland@gnu.ai.mit.edu
4    before changing it!
5
6    Copyright (C) 1987, 88, 89, 90, 91, 92, 1993
7         Free Software Foundation, Inc.
8
9    This program is free software; you can redistribute it and/or modify it
10    under the terms of the GNU General Public License as published by the
11    Free Software Foundation; either version 2, or (at your option) any
12    later version.
13
14    This program 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
17    GNU General Public License for more details.
18
19    You should have received a copy of the GNU General Public License
20    along with this program; if not, write to the Free Software
21    Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
22 \f
23 #ifdef HAVE_CONFIG_H
24 #include "config.h"
25 #endif
26
27 #if !__STDC__ && !defined(const) && IN_GCC
28 #define const
29 #endif
30
31 /* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>.  */
32 #ifndef _NO_PROTO
33 #define _NO_PROTO
34 #endif
35
36 #include <stdio.h>
37
38 /* Comment out all this code if we are using the GNU C Library, and are not
39    actually compiling the library itself.  This code is part of the GNU C
40    Library, but also included in many other GNU distributions.  Compiling
41    and linking in this code is a waste when using the GNU C library
42    (especially if it is a shared library).  Rather than having every GNU
43    program understand `configure --with-gnu-libc' and omit the object files,
44    it is simpler to just do this in the source for each such file.  */
45
46 #if defined (_LIBC) || !defined (__GNU_LIBRARY__)
47
48
49 /* This needs to come after some library #include
50    to get __GNU_LIBRARY__ defined.  */
51 #ifdef  __GNU_LIBRARY__
52 /* Don't include stdlib.h for non-GNU C libraries because some of them
53    contain conflicting prototypes for getopt.  */
54 #include <stdlib.h>
55 #endif  /* GNU C library.  */
56
57 /* If GETOPT_COMPAT is defined, `+' as well as `--' can introduce a
58    long-named option.  Because this is not POSIX.2 compliant, it is
59    being phased out.  */
60 /* #define GETOPT_COMPAT */
61
62 /* This version of `getopt' appears to the caller like standard Unix `getopt'
63    but it behaves differently for the user, since it allows the user
64    to intersperse the options with the other arguments.
65
66    As `getopt' works, it permutes the elements of ARGV so that,
67    when it is done, all the options precede everything else.  Thus
68    all application programs are extended to handle flexible argument order.
69
70    Setting the environment variable POSIXLY_CORRECT disables permutation.
71    Then the behavior is completely standard.
72
73    GNU application programs can use a third alternative mode in which
74    they can distinguish the relative order of options and other arguments.  */
75
76 #include "getopt.h"
77
78 /* For communication from `getopt' to the caller.
79    When `getopt' finds an option that takes an argument,
80    the argument value is returned here.
81    Also, when `ordering' is RETURN_IN_ORDER,
82    each non-option ARGV-element is returned here.  */
83
84 char *optarg = 0;
85
86 /* Index in ARGV of the next element to be scanned.
87    This is used for communication to and from the caller
88    and for communication between successive calls to `getopt'.
89
90    On entry to `getopt', zero means this is the first call; initialize.
91
92    When `getopt' returns EOF, this is the index of the first of the
93    non-option elements that the caller should itself scan.
94
95    Otherwise, `optind' communicates from one call to the next
96    how much of ARGV has been scanned so far.  */
97
98 /* XXX 1003.2 says this must be 1 before any call.  */
99 int optind = 0;
100
101 /* The next char to be scanned in the option-element
102    in which the last option character we returned was found.
103    This allows us to pick up the scan where we left off.
104
105    If this is zero, or a null string, it means resume the scan
106    by advancing to the next ARGV-element.  */
107
108 static char *nextchar;
109
110 /* Callers store zero here to inhibit the error message
111    for unrecognized options.  */
112
113 int opterr = 1;
114
115 /* Set to an option character which was unrecognized.
116    This must be initialized on some systems to avoid linking in the
117    system's own getopt implementation.  */
118
119 int optopt = '?';
120
121 /* Describe how to deal with options that follow non-option ARGV-elements.
122
123    If the caller did not specify anything,
124    the default is REQUIRE_ORDER if the environment variable
125    POSIXLY_CORRECT is defined, PERMUTE otherwise.
126
127    REQUIRE_ORDER means don't recognize them as options;
128    stop option processing when the first non-option is seen.
129    This is what Unix does.
130    This mode of operation is selected by either setting the environment
131    variable POSIXLY_CORRECT, or using `+' as the first character
132    of the list of option characters.
133
134    PERMUTE is the default.  We permute the contents of ARGV as we scan,
135    so that eventually all the non-options are at the end.  This allows options
136    to be given in any order, even with programs that were not written to
137    expect this.
138
139    RETURN_IN_ORDER is an option available to programs that were written
140    to expect options and other ARGV-elements in any order and that care about
141    the ordering of the two.  We describe each non-option ARGV-element
142    as if it were the argument of an option with character code 1.
143    Using `-' as the first character of the list of option characters
144    selects this mode of operation.
145
146    The special argument `--' forces an end of option-scanning regardless
147    of the value of `ordering'.  In the case of RETURN_IN_ORDER, only
148    `--' can cause `getopt' to return EOF with `optind' != ARGC.  */
149
150 static enum
151 {
152   REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
153 } ordering;
154 \f
155 #ifdef  __GNU_LIBRARY__
156 /* We want to avoid inclusion of string.h with non-GNU libraries
157    because there are many ways it can cause trouble.
158    On some systems, it contains special magic macros that don't work
159    in GCC.  */
160 #include <string.h>
161 #define my_index        strchr
162 #define my_bcopy(src, dst, n)   memcpy ((dst), (src), (n))
163 #else
164
165 /* Avoid depending on library functions or files
166    whose names are inconsistent.  */
167
168 char *getenv ();
169
170 static char *
171 my_index (str, chr)
172      const char *str;
173      int chr;
174 {
175   while (*str)
176     {
177       if (*str == chr)
178         return (char *) str;
179       str++;
180     }
181   return 0;
182 }
183
184 static void
185 my_bcopy (from, to, size)
186      const char *from;
187      char *to;
188      int size;
189 {
190   int i;
191   for (i = 0; i < size; i++)
192     to[i] = from[i];
193 }
194 #endif                          /* GNU C library.  */
195 \f
196 /* Handle permutation of arguments.  */
197
198 /* Describe the part of ARGV that contains non-options that have
199    been skipped.  `first_nonopt' is the index in ARGV of the first of them;
200    `last_nonopt' is the index after the last of them.  */
201
202 static int first_nonopt;
203 static int last_nonopt;
204
205 /* Exchange two adjacent subsequences of ARGV.
206    One subsequence is elements [first_nonopt,last_nonopt)
207    which contains all the non-options that have been skipped so far.
208    The other is elements [last_nonopt,optind), which contains all
209    the options processed since those non-options were skipped.
210
211    `first_nonopt' and `last_nonopt' are relocated so that they describe
212    the new indices of the non-options in ARGV after they are moved.  */
213
214 static void
215 exchange (argv)
216      char **argv;
217 {
218   int nonopts_size = (last_nonopt - first_nonopt) * sizeof (char *);
219   char **temp = (char **) safe_malloc (nonopts_size, "getopt");
220
221   /* Interchange the two blocks of data in ARGV.  */
222
223   my_bcopy ((char *) &argv[first_nonopt], (char *) temp, nonopts_size);
224   my_bcopy ((char *) &argv[last_nonopt], (char *) &argv[first_nonopt],
225             (optind - last_nonopt) * sizeof (char *));
226   my_bcopy ((char *) temp,
227             (char *) &argv[first_nonopt + optind - last_nonopt],
228             nonopts_size);
229
230   /* Update records for the slots the non-options now occupy.  */
231
232   first_nonopt += (optind - last_nonopt);
233   last_nonopt = optind;
234   free(temp);
235 }
236 \f
237 /* Scan elements of ARGV (whose length is ARGC) for option characters
238    given in OPTSTRING.
239
240    If an element of ARGV starts with '-', and is not exactly "-" or "--",
241    then it is an option element.  The characters of this element
242    (aside from the initial '-') are option characters.  If `getopt'
243    is called repeatedly, it returns successively each of the option characters
244    from each of the option elements.
245
246    If `getopt' finds another option character, it returns that character,
247    updating `optind' and `nextchar' so that the next call to `getopt' can
248    resume the scan with the following option character or ARGV-element.
249
250    If there are no more option characters, `getopt' returns `EOF'.
251    Then `optind' is the index in ARGV of the first ARGV-element
252    that is not an option.  (The ARGV-elements have been permuted
253    so that those that are not options now come last.)
254
255    OPTSTRING is a string containing the legitimate option characters.
256    If an option character is seen that is not listed in OPTSTRING,
257    return '?' after printing an error message.  If you set `opterr' to
258    zero, the error message is suppressed but we still return '?'.
259
260    If a char in OPTSTRING is followed by a colon, that means it wants an arg,
261    so the following text in the same ARGV-element, or the text of the following
262    ARGV-element, is returned in `optarg'.  Two colons mean an option that
263    wants an optional arg; if there is text in the current ARGV-element,
264    it is returned in `optarg', otherwise `optarg' is set to zero.
265
266    If OPTSTRING starts with `-' or `+', it requests different methods of
267    handling the non-option ARGV-elements.
268    See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
269
270    Long-named options begin with `--' instead of `-'.
271    Their names may be abbreviated as long as the abbreviation is unique
272    or is an exact match for some defined option.  If they have an
273    argument, it follows the option name in the same ARGV-element, separated
274    from the option name by a `=', or else the in next ARGV-element.
275    When `getopt' finds a long-named option, it returns 0 if that option's
276    `flag' field is nonzero, the value of the option's `val' field
277    if the `flag' field is zero.
278
279    The elements of ARGV aren't really const, because we permute them.
280    But we pretend they're const in the prototype to be compatible
281    with other systems.
282
283    LONGOPTS is a vector of `struct option' terminated by an
284    element containing a name which is zero.
285
286    LONGIND returns the index in LONGOPT of the long-named option found.
287    It is only valid when a long-named option has been found by the most
288    recent call.
289
290    If LONG_ONLY is nonzero, '-' as well as '--' can introduce
291    long-named options.  */
292
293 int
294 _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
295      int argc;
296      char *const *argv;
297      const char *optstring;
298      const struct option *longopts;
299      int *longind;
300      int long_only;
301 {
302   int option_index;
303
304   optarg = 0;
305
306   /* Initialize the internal data when the first call is made.
307      Start processing options with ARGV-element 1 (since ARGV-element 0
308      is the program name); the sequence of previously skipped
309      non-option ARGV-elements is empty.  */
310
311   if (optind == 0)
312     {
313       first_nonopt = last_nonopt = optind = 1;
314
315       nextchar = NULL;
316
317       /* Determine how to handle the ordering of options and nonoptions.  */
318
319       if (optstring[0] == '-')
320         {
321           ordering = RETURN_IN_ORDER;
322           ++optstring;
323         }
324       else if (optstring[0] == '+')
325         {
326           ordering = REQUIRE_ORDER;
327           ++optstring;
328         }
329       else if (getenv ("POSIXLY_CORRECT") != NULL)
330         ordering = REQUIRE_ORDER;
331       else
332         ordering = PERMUTE;
333     }
334
335   if (nextchar == NULL || *nextchar == '\0')
336     {
337       if (ordering == PERMUTE)
338         {
339           /* If we have just processed some options following some non-options,
340              exchange them so that the options come first.  */
341
342           if (first_nonopt != last_nonopt && last_nonopt != optind)
343             exchange ((char **) argv);
344           else if (last_nonopt != optind)
345             first_nonopt = optind;
346
347           /* Now skip any additional non-options
348              and extend the range of non-options previously skipped.  */
349
350           while (optind < argc
351                  && (argv[optind][0] != '-' || argv[optind][1] == '\0')
352 #ifdef GETOPT_COMPAT
353                  && (longopts == NULL
354                      || argv[optind][0] != '+' || argv[optind][1] == '\0')
355 #endif                          /* GETOPT_COMPAT */
356                  )
357             optind++;
358           last_nonopt = optind;
359         }
360
361       /* Special ARGV-element `--' means premature end of options.
362          Skip it like a null option,
363          then exchange with previous non-options as if it were an option,
364          then skip everything else like a non-option.  */
365
366       if (optind != argc && !strcmp (argv[optind], "--"))
367         {
368           optind++;
369
370           if (first_nonopt != last_nonopt && last_nonopt != optind)
371             exchange ((char **) argv);
372           else if (first_nonopt == last_nonopt)
373             first_nonopt = optind;
374           last_nonopt = argc;
375
376           optind = argc;
377         }
378
379       /* If we have done all the ARGV-elements, stop the scan
380          and back over any non-options that we skipped and permuted.  */
381
382       if (optind == argc)
383         {
384           /* Set the next-arg-index to point at the non-options
385              that we previously skipped, so the caller will digest them.  */
386           if (first_nonopt != last_nonopt)
387             optind = first_nonopt;
388           return EOF;
389         }
390
391       /* If we have come to a non-option and did not permute it,
392          either stop the scan or describe it to the caller and pass it by.  */
393
394       if ((argv[optind][0] != '-' || argv[optind][1] == '\0')
395 #ifdef GETOPT_COMPAT
396           && (longopts == NULL
397               || argv[optind][0] != '+' || argv[optind][1] == '\0')
398 #endif                          /* GETOPT_COMPAT */
399           )
400         {
401           if (ordering == REQUIRE_ORDER)
402             return EOF;
403           optarg = argv[optind++];
404           return 1;
405         }
406
407       /* We have found another option-ARGV-element.
408          Start decoding its characters.  */
409
410       nextchar = (argv[optind] + 1
411                   + (longopts != NULL && argv[optind][1] == '-'));
412     }
413
414   if (longopts != NULL
415       && ((argv[optind][0] == '-'
416            && (argv[optind][1] == '-' || long_only))
417 #ifdef GETOPT_COMPAT
418           || argv[optind][0] == '+'
419 #endif                          /* GETOPT_COMPAT */
420           ))
421     {
422       const struct option *p;
423       char *s = nextchar;
424       int exact = 0;
425       int ambig = 0;
426       const struct option *pfound = NULL;
427       int indfound;
428
429       while (*s && *s != '=')
430         s++;
431
432       /* Test all options for either exact match or abbreviated matches.  */
433       for (p = longopts, option_index = 0; p->name;
434            p++, option_index++)
435         if (!strncmp (p->name, nextchar, s - nextchar))
436           {
437             if (s - nextchar == strlen (p->name))
438               {
439                 /* Exact match found.  */
440                 pfound = p;
441                 indfound = option_index;
442                 exact = 1;
443                 break;
444               }
445             else if (pfound == NULL)
446               {
447                 /* First nonexact match found.  */
448                 pfound = p;
449                 indfound = option_index;
450               }
451             else
452               /* Second nonexact match found.  */
453               ambig = 1;
454           }
455
456       if (ambig && !exact)
457         {
458           if (opterr)
459             fprintf (stderr, "%s: option `%s' is ambiguous\n",
460                      argv[0], argv[optind]);
461           nextchar += strlen (nextchar);
462           optind++;
463           return '?';
464         }
465
466       if (pfound != NULL)
467         {
468           option_index = indfound;
469           optind++;
470           if (*s)
471             {
472               /* Don't test has_arg with >, because some C compilers don't
473                  allow it to be used on enums.  */
474               if (pfound->has_arg)
475                 optarg = s + 1;
476               else
477                 {
478                   if (opterr)
479                     {
480                       if (argv[optind - 1][1] == '-')
481                         /* --option */
482                         fprintf (stderr,
483                                  "%s: option `--%s' doesn't allow an argument\n",
484                                  argv[0], pfound->name);
485                       else
486                         /* +option or -option */
487                         fprintf (stderr,
488                              "%s: option `%c%s' doesn't allow an argument\n",
489                              argv[0], argv[optind - 1][0], pfound->name);
490                     }
491                   nextchar += strlen (nextchar);
492                   return '?';
493                 }
494             }
495           else if (pfound->has_arg == 1)
496             {
497               if (optind < argc)
498                 optarg = argv[optind++];
499               else
500                 {
501                   if (opterr)
502                     fprintf (stderr, "%s: option `%s' requires an argument\n",
503                              argv[0], argv[optind - 1]);
504                   nextchar += strlen (nextchar);
505                   return optstring[0] == ':' ? ':' : '?';
506                 }
507             }
508           nextchar += strlen (nextchar);
509           if (longind != NULL)
510             *longind = option_index;
511           if (pfound->flag)
512             {
513               *(pfound->flag) = pfound->val;
514               return 0;
515             }
516           return pfound->val;
517         }
518       /* Can't find it as a long option.  If this is not getopt_long_only,
519          or the option starts with '--' or is not a valid short
520          option, then it's an error.
521          Otherwise interpret it as a short option.  */
522       if (!long_only || argv[optind][1] == '-'
523 #ifdef GETOPT_COMPAT
524           || argv[optind][0] == '+'
525 #endif                          /* GETOPT_COMPAT */
526           || my_index (optstring, *nextchar) == NULL)
527         {
528           if (opterr)
529             {
530               if (argv[optind][1] == '-')
531                 /* --option */
532                 fprintf (stderr, "%s: unrecognized option `--%s'\n",
533                          argv[0], nextchar);
534               else
535                 /* +option or -option */
536                 fprintf (stderr, "%s: unrecognized option `%c%s'\n",
537                          argv[0], argv[optind][0], nextchar);
538             }
539           nextchar = (char *) "";
540           optind++;
541           return '?';
542         }
543     }
544
545   /* Look at and handle the next option-character.  */
546
547   {
548     char c = *nextchar++;
549     char *temp = my_index (optstring, c);
550
551     /* Increment `optind' when we start to process its last character.  */
552     if (*nextchar == '\0')
553       ++optind;
554
555     if (temp == NULL || c == ':')
556       {
557         if (opterr)
558           {
559 #if 0
560             if (c < 040 || c >= 0177)
561               fprintf (stderr, "%s: unrecognized option, character code 0%o\n",
562                        argv[0], c);
563             else
564               fprintf (stderr, "%s: unrecognized option `-%c'\n", argv[0], c);
565 #else
566             /* 1003.2 specifies the format of this message.  */
567             fprintf (stderr, "%s: illegal option -- %c\n", argv[0], c);
568 #endif
569           }
570         optopt = c;
571         return '?';
572       }
573     if (temp[1] == ':')
574       {
575         if (temp[2] == ':')
576           {
577             /* This is an option that accepts an argument optionally.  */
578             if (*nextchar != '\0')
579               {
580                 optarg = nextchar;
581                 optind++;
582               }
583             else
584               optarg = 0;
585             nextchar = NULL;
586           }
587         else
588           {
589             /* This is an option that requires an argument.  */
590             if (*nextchar != '\0')
591               {
592                 optarg = nextchar;
593                 /* If we end this ARGV-element by taking the rest as an arg,
594                    we must advance to the next element now.  */
595                 optind++;
596               }
597             else if (optind == argc)
598               {
599                 if (opterr)
600                   {
601 #if 0
602                     fprintf (stderr, "%s: option `-%c' requires an argument\n",
603                              argv[0], c);
604 #else
605                     /* 1003.2 specifies the format of this message.  */
606                     fprintf (stderr, "%s: option requires an argument -- %c\n",
607                              argv[0], c);
608 #endif
609                   }
610                 optopt = c;
611                 if (optstring[0] == ':')
612                   c = ':';
613                 else
614                   c = '?';
615               }
616             else
617               /* We already incremented `optind' once;
618                  increment it again when taking next ARGV-elt as argument.  */
619               optarg = argv[optind++];
620             nextchar = NULL;
621           }
622       }
623     return c;
624   }
625 }
626
627 int
628 getopt (argc, argv, optstring)
629      int argc;
630      char *const *argv;
631      const char *optstring;
632 {
633   return _getopt_internal (argc, argv, optstring,
634                            (const struct option *) 0,
635                            (int *) 0,
636                            0);
637 }
638
639 #endif  /* _LIBC or not __GNU_LIBRARY__.  */
640 \f
641 #ifdef TEST
642
643 /* Compile with -DTEST to make an executable for use in testing
644    the above definition of `getopt'.  */
645
646 int
647 main (argc, argv)
648      int argc;
649      char **argv;
650 {
651   int c;
652   int digit_optind = 0;
653
654   while (1)
655     {
656       int this_option_optind = optind ? optind : 1;
657
658       c = getopt (argc, argv, "abc:d:0123456789");
659       if (c == EOF)
660         break;
661
662       switch (c)
663         {
664         case '0':
665         case '1':
666         case '2':
667         case '3':
668         case '4':
669         case '5':
670         case '6':
671         case '7':
672         case '8':
673         case '9':
674           if (digit_optind != 0 && digit_optind != this_option_optind)
675             printf ("digits occur in two different argv-elements.\n");
676           digit_optind = this_option_optind;
677           printf ("option %c\n", c);
678           break;
679
680         case 'a':
681           printf ("option a\n");
682           break;
683
684         case 'b':
685           printf ("option b\n");
686           break;
687
688         case 'c':
689           printf ("option c with value `%s'\n", optarg);
690           break;
691
692         case '?':
693           break;
694
695         default:
696           printf ("?? getopt returned character code 0%o ??\n", c);
697         }
698     }
699
700   if (optind < argc)
701     {
702       printf ("non-option ARGV-elements: ");
703       while (optind < argc)
704         printf ("%s ", argv[optind++]);
705       printf ("\n");
706     }
707
708   exit (0);
709 }
710
711 #endif /* TEST */