Debian Codegraph @

mygetopt.c

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