1N/A NOTE: getopt is now part of the C library, so if you don't know what 1N/A "Keep this file name-space clean" means, talk to drepper@gnu.org 1N/A Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98 1N/A Free Software Foundation, Inc. 1N/A NOTE: The canonical source of this file is maintained with the GNU C Library. 1N/A Bugs can be reported to bug-glibc@gnu.org. 1N/A This program is free software; you can redistribute it and/or modify it 1N/A under the terms of the GNU General Public License as published by the 1N/A Free Software Foundation; either version 2, or (at your option) any 1N/A This program is distributed in the hope that it will be useful, 1N/A but WITHOUT ANY WARRANTY; without even the implied warranty of 1N/A MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 1N/A GNU General Public License for more details. 1N/A You should have received a copy of the GNU General Public License 1N/A along with this program; if not, write to the Free Software 1N/A Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 1N/A/* This tells Alpha OSF/1 not to define a getopt prototype in <stdio.h>. 1N/A/* This is a separate conditional since some stdc systems 1N/A reject `defined (const)'. */ 1N/A/* Comment out all this code if we are using the GNU C Library, and are not 1N/A actually compiling the library itself. This code is part of the GNU C 1N/A Library, but also included in many other GNU distributions. Compiling 1N/A and linking in this code is a waste when using the GNU C library 1N/A (especially if it is a shared library). Rather than having every GNU 1N/A program understand `configure --with-gnu-libc' and omit the object files, 1N/A it is simpler to just do this in the source for each such file. */ 1N/A/* This needs to come after some library #include 1N/A to get __GNU_LIBRARY__ defined. */ 1N/A/* Don't include stdlib.h for non-GNU C libraries because some of them 1N/A contain conflicting prototypes for getopt. */ 1N/A#
endif /* GNU C library. */ 1N/A/* This is for other GNU distributions with internationalized messages. 1N/A When compiling libc, the _ macro is predefined. */ 1N/A/* This version of `getopt' appears to the caller like standard Unix `getopt' 1N/A but it behaves differently for the user, since it allows the user 1N/A to intersperse the options with the other arguments. 1N/A As `getopt' works, it permutes the elements of ARGV so that, 1N/A when it is done, all the options precede everything else. Thus 1N/A all application programs are extended to handle flexible argument order. 1N/A Setting the environment variable POSIXLY_CORRECT disables permutation. 1N/A Then the behavior is completely standard. 1N/A GNU application programs can use a third alternative mode in which 1N/A they can distinguish the relative order of options and other arguments. */ 1N/A/* For communication from `getopt' to the caller. 1N/A When `getopt' finds an option that takes an argument, 1N/A the argument value is returned here. 1N/A Also, when `ordering' is RETURN_IN_ORDER, 1N/A each non-option ARGV-element is returned here. */ 1N/A/* Index in ARGV of the next element to be scanned. 1N/A This is used for communication to and from the caller 1N/A and for communication between successive calls to `getopt'. 1N/A On entry to `getopt', zero means this is the first call; initialize. 1N/A When `getopt' returns -1, this is the index of the first of the 1N/A non-option elements that the caller should itself scan. 1N/A Otherwise, `optind' communicates from one call to the next 1N/A how much of ARGV has been scanned so far. */ 1N/A/* 1003.2 says this must be 1 before any call. */ 1N/A/* Formerly, initialization of getopt depended on optind==0, which 1N/A causes problems with re-calling getopt as programs generally don't 1N/A/* The next char to be scanned in the option-element 1N/A in which the last option character we returned was found. 1N/A This allows us to pick up the scan where we left off. 1N/A If this is zero, or a null string, it means resume the scan 1N/A by advancing to the next ARGV-element. */ 1N/A/* Callers store zero here to inhibit the error message 1N/A for unrecognized options. */ 1N/A/* Set to an option character which was unrecognized. 1N/A This must be initialized on some systems to avoid linking in the 1N/A system's own getopt implementation. */ 1N/A/* Describe how to deal with options that follow non-option ARGV-elements. 1N/A If the caller did not specify anything, 1N/A the default is REQUIRE_ORDER if the environment variable 1N/A POSIXLY_CORRECT is defined, PERMUTE otherwise. 1N/A REQUIRE_ORDER means don't recognize them as options; 1N/A stop option processing when the first non-option is seen. 1N/A This is what Unix does. 1N/A This mode of operation is selected by either setting the environment 1N/A variable POSIXLY_CORRECT, or using `+' as the first character 1N/A of the list of option characters. 1N/A PERMUTE is the default. We permute the contents of ARGV as we scan, 1N/A so that eventually all the non-options are at the end. This allows options 1N/A to be given in any order, even with programs that were not written to 1N/A RETURN_IN_ORDER is an option available to programs that were written 1N/A to expect options and other ARGV-elements in any order and that care about 1N/A the ordering of the two. We describe each non-option ARGV-element 1N/A as if it were the argument of an option with character code 1. 1N/A Using `-' as the first character of the list of option characters 1N/A selects this mode of operation. 1N/A The special argument `--' forces an end of option-scanning regardless 1N/A of the value of `ordering'. In the case of RETURN_IN_ORDER, only 1N/A `--' can cause `getopt' to return -1 with `optind' != ARGC. */ 1N/A/* Value of POSIXLY_CORRECT environment variable. */ 1N/A/* We want to avoid inclusion of string.h with non-GNU libraries 1N/A because there are many ways it can cause trouble. 1N/A On some systems, it contains special magic macros that don't work 1N/A/* Avoid depending on library functions or files 1N/A whose names are inconsistent. */ 1N/A/* If using GCC, we can safely declare strlen this way. 1N/A If not using GCC, it is ok not to declare it. */ 1N/A/* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h. 1N/A That was relevant to code that was here before. */ 1N/A/* gcc with -traditional declares the built-in strlen to return int, 1N/A and has done so at least since version 2.4.5. -- rms. */ 1N/A#
endif /* not __STDC__ */ 1N/A#
endif /* __GNUC__ */ 1N/A#
endif /* not __GNU_LIBRARY__ */ 1N/A/* Handle permutation of arguments. */ 1N/A/* Describe the part of ARGV that contains non-options that have 1N/A been skipped. `first_nonopt' is the index in ARGV of the first of them; 1N/A `last_nonopt' is the index after the last of them. */ 1N/A/* Bash 2.0 gives us an environment variable containing flags 1N/A indicating ARGV elements that should not be considered arguments. */ 1N/A/* Make sure the environment variable bash 2.0 puts in the environment 1N/A is valid for the getopt call we must make sure that the ARGV passed 1N/A to getopt is that one passed to the process. */ 1N/A /* XXX This is no good solution. We should rather copy the args so 1N/A that we can compare them later. But we must not use malloc(3). */ 1N/A#
endif /* text_set_element */ 1N/A/* Exchange two adjacent subsequences of ARGV. 1N/A One subsequence is elements [first_nonopt,last_nonopt) 1N/A which contains all the non-options that have been skipped so far. 1N/A The other is elements [last_nonopt,optind), which contains all 1N/A the options processed since those non-options were skipped. 1N/A `first_nonopt' and `last_nonopt' are relocated so that they describe 1N/A the new indices of the non-options in ARGV after they are moved. */ 1N/A /* Exchange the shorter segment with the far end of the longer segment. 1N/A That puts the shorter segment into the right place. 1N/A It leaves the longer segment in the right place overall, 1N/A but it consists of two parts that need to be swapped next. */ 1N/A /* First make sure the handling of the `__getopt_nonoption_flags' 1N/A string can work normally. Our top argument must be in the range 1N/A /* We must extend the array. The user plays games with us and 1N/A presents new arguments. */ 1N/A /* Bottom segment is the short one. */ 1N/A /* Swap it with the top part of the top segment. */ 1N/A /* Exclude the moved bottom segment from further swapping. */ 1N/A /* Top segment is the short one. */ 1N/A /* Swap it with the bottom part of the bottom segment. */ 1N/A /* Exclude the moved top segment from further swapping. */ 1N/A /* Update records for the slots the non-options now occupy. */ 1N/A/* Initialize the internal data when the first call is made. */ 1N/A /* Start processing options with ARGV-element 1 (since ARGV-element 0 1N/A is the program name); the sequence of previously skipped 1N/A non-option ARGV-elements is empty. */ 1N/A /* Determine how to handle the ordering of options and nonoptions. */ 1N/A/* Scan elements of ARGV (whose length is ARGC) for option characters 1N/A If an element of ARGV starts with '-', and is not exactly "-" or "--", 1N/A then it is an option element. The characters of this element 1N/A (aside from the initial '-') are option characters. If `getopt' 1N/A is called repeatedly, it returns successively each of the option characters 1N/A from each of the option elements. 1N/A If `getopt' finds another option character, it returns that character, 1N/A updating `optind' and `nextchar' so that the next call to `getopt' can 1N/A resume the scan with the following option character or ARGV-element. 1N/A If there are no more option characters, `getopt' returns -1. 1N/A Then `optind' is the index in ARGV of the first ARGV-element 1N/A that is not an option. (The ARGV-elements have been permuted 1N/A so that those that are not options now come last.) 1N/A OPTSTRING is a string containing the legitimate option characters. 1N/A If an option character is seen that is not listed in OPTSTRING, 1N/A return '?' after printing an error message. If you set `opterr' to 1N/A zero, the error message is suppressed but we still return '?'. 1N/A If a char in OPTSTRING is followed by a colon, that means it wants an arg, 1N/A so the following text in the same ARGV-element, or the text of the following 1N/A ARGV-element, is returned in `optarg'. Two colons mean an option that 1N/A wants an optional arg; if there is text in the current ARGV-element, 1N/A it is returned in `optarg', otherwise `optarg' is set to zero. 1N/A If OPTSTRING starts with `-' or `+', it requests different methods of 1N/A handling the non-option ARGV-elements. 1N/A See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above. 1N/A Long-named options begin with `--' instead of `-'. 1N/A Their names may be abbreviated as long as the abbreviation is unique 1N/A or is an exact match for some defined option. If they have an 1N/A argument, it follows the option name in the same ARGV-element, separated 1N/A from the option name by a `=', or else the in next ARGV-element. 1N/A When `getopt' finds a long-named option, it returns 0 if that option's 1N/A `flag' field is nonzero, the value of the option's `val' field 1N/A if the `flag' field is zero. 1N/A The elements of ARGV aren't really const, because we permute them. 1N/A But we pretend they're const in the prototype to be compatible 1N/A LONGOPTS is a vector of `struct option' terminated by an 1N/A element containing a name which is zero. 1N/A LONGIND returns the index in LONGOPT of the long-named option found. 1N/A It is only valid when a long-named option has been found by the most 1N/A If LONG_ONLY is nonzero, '-' as well as '--' can introduce 1N/A long-named options. */ 1N/A optind =
1;
/* Don't scan ARGV[0], the program name. */ 1N/A /* Test whether ARGV[optind] points to a non-option argument. 1N/A Either it does not have option syntax, or there is an environment flag 1N/A from the shell indicating it is not an option. The later information 1N/A is only used when the used in the GNU libc. */ 1N/A /* Advance to the next ARGV-element. */ 1N/A /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been 1N/A moved back by the user (who may also have changed the arguments). */ 1N/A /* If we have just processed some options following some non-options, 1N/A exchange them so that the options come first. */ 1N/A /* Skip any additional non-options 1N/A and extend the range of non-options previously skipped. */ 1N/A /* The special ARGV-element `--' means premature end of options. 1N/A Skip it like a null option, 1N/A then exchange with previous non-options as if it were an option, 1N/A then skip everything else like a non-option. */ 1N/A /* If we have done all the ARGV-elements, stop the scan 1N/A and back over any non-options that we skipped and permuted. */ 1N/A /* Set the next-arg-index to point at the non-options 1N/A that we previously skipped, so the caller will digest them. */ 1N/A /* If we have come to a non-option and did not permute it, 1N/A either stop the scan or describe it to the caller and pass it by. */ 1N/A /* We have found another option-ARGV-element. 1N/A Skip the initial punctuation. */ 1N/A /* Decode the current option-ARGV-element. */ 1N/A /* Check whether the ARGV-element is a long option. 1N/A If long_only and the ARGV-element has the form "-f", where f is 1N/A a valid short option, don't consider it an abbreviated form of 1N/A a long option that starts with f. Otherwise there would be no 1N/A way to give the -f short option. 1N/A On the other hand, if there's a long option "fubar" and 1N/A the ARGV-element is "-fu", do consider that an abbreviation of 1N/A the long option, just like "--fu", and not "-f" with arg "u". 1N/A This distinction seems to be the most useful approach. */ 1N/A /* Test all long options for either exact match 1N/A or abbreviated matches. */ 1N/A /* Exact match found. */ 1N/A /* First nonexact match found. */ 1N/A /* Second or later nonexact match found. */ 1N/A /* Don't test has_arg with >, because some C compilers don't 1N/A allow it to be used on enums. */ 1N/A _(
"%s: option `--%s' doesn't allow an argument\n"),
1N/A /* +option or -option */ 1N/A _(
"%s: option `%c%s' doesn't allow an argument\n"),
1N/A _(
"%s: option `%s' requires an argument\n"),
1N/A /* Can't find it as a long option. If this is not getopt_long_only, 1N/A or the option starts with '--' or is not a valid short 1N/A option, then it's an error. 1N/A Otherwise interpret it as a short option. */ 1N/A /* +option or -option */ 1N/A /* Look at and handle the next short option-character. */ 1N/A /* Increment `optind' when we start to process its last character. */ 1N/A /* 1003.2 specifies the format of this message. */ 1N/A /* Convenience. Treat POSIX -W foo same as long option --foo */ 1N/A /* This is an option that requires an argument. */ 1N/A /* If we end this ARGV-element by taking the rest as an arg, 1N/A we must advance to the next element now. */ 1N/A /* 1003.2 specifies the format of this message. */ 1N/A /* We already incremented `optind' once; 1N/A increment it again when taking next ARGV-elt as argument. */ 1N/A /* optarg is now the argument, see if it's in the 1N/A table of longopts. */ 1N/A /* Test all long options for either exact match 1N/A or abbreviated matches. */ 1N/A /* Exact match found. */ 1N/A /* First nonexact match found. */ 1N/A /* Second or later nonexact match found. */ 1N/A /* Don't test has_arg with >, because some C compilers don't 1N/A allow it to be used on enums. */ 1N/A%s: option `-W %s' doesn't allow an argument\n"),
1N/A _(
"%s: option `%s' requires an argument\n"),
1N/A return 'W';
/* Let the application handle it. */ 1N/A /* This is an option that accepts an argument optionally. */ 1N/A /* This is an option that requires an argument. */ 1N/A /* If we end this ARGV-element by taking the rest as an arg, 1N/A we must advance to the next element now. */ 1N/A /* 1003.2 specifies the format of this message. */ 1N/A _(
"%s: option requires an argument -- %c\n"),
1N/A /* We already incremented `optind' once; 1N/A increment it again when taking next ARGV-elt as argument. */ 1N/A#
endif /* Not ELIDE_CODE. */ 1N/A/* Compile with -DTEST to make an executable for use in testing 1N/A the above definition of `getopt'. */ 1N/A printf (
"digits occur in two different argv-elements.\n");
1N/A printf (
"?? getopt returned character code 0%o ??\n", c);