DESCRIPTION

getopt is used to break up (parse) options in command lines for easy parsing by shell procedures, and to check for valid options. It uses the GNU getopt(3) routines to do this.

The parameters getopt is called with can be divided into two parts: options which modify the way getopt will do the parsing (the options and the optstring in the SYNOPSIS), and the parameters which are to be parsed (parameters in the SYNOPSIS). The second part will start at the first non−option parameter that is not an option argument, or after the first occurrence of _zsingle_quotesz_−−_zsingle_quotesz_. If no _zsingle_quotesz_−o_zsingle_quotesz_ or _zsingle_quotesz_−−options_zsingle_quotesz_ option is found in the first part, the first parameter of the second part is used as the short options string.

If the environment variable GETOPT_COMPATIBLE is set, or if the first parameter is not an option (does not start with a _zsingle_quotesz_−_zsingle_quotesz_, the first format in the SYNOPSIS), getopt will generate output that is compatible with that of other versions of getopt(1). It will still do parameter shuffling and recognize optional arguments (see section COMPATIBILITY for more information).

Traditional implementations of getopt(1) are unable to cope with whitespace and other (shell-specific) special characters in arguments and non−option parameters. To solve this problem, this implementation can generate quoted output which must once again be interpreted by the shell (usually by using the eval command). This has the effect of preserving those characters, but you must call getopt in a way that is no longer compatible with other versions (the second or third format in the SYNOPSIS). To determine whether this enhanced version of getopt(1) is installed, a special test option (−T) can be used.

OPTIONS

PARSING

This section specifies the format of the second part of the parameters of getopt (the parameters in the SYNOPSIS). The next section (OUTPUT) describes the output that is generated. These parameters were typically the parameters a shell function was called with. Care must be taken that each parameter the shell function was called with corresponds to exactly one parameter in the parameter list of getopt (see the EXAMPLES). All parsing is done by the GNU getopt(3) routines.

The parameters are parsed from left to right. Each parameter is classified as a short option, a long option, an argument to an option, or a non−option parameter.

A simple short option is a _zsingle_quotesz_−_zsingle_quotesz_ followed by a short option character. If the option has a required argument, it may be written directly after the option character or as the next parameter (i.e., separated by whitespace on the command line). If the option has an optional argument, it must be written directly after the option character if present.

It is possible to specify several short options after one _zsingle_quotesz_−_zsingle_quotesz_, as long as all (except possibly the last) do not have required or optional arguments.

A long option normally begins with _zsingle_quotesz_−−_zsingle_quotesz_ followed by the long option name. If the option has a required argument, it may be written directly after the long option name, separated by _zsingle_quotesz_=_zsingle_quotesz_, or as the next argument (i.e., separated by whitespace on the command line). If the option has an optional argument, it must be written directly after the long option name, separated by _zsingle_quotesz_=_zsingle_quotesz_, if present (if you add the _zsingle_quotesz_=_zsingle_quotesz_ but nothing behind it, it is interpreted as if no argument was present; this is a slight bug, see the BUGS). Long options may be abbreviated, as long as the abbreviation is not ambiguous.

Each parameter not starting with a _zsingle_quotesz_−_zsingle_quotesz_, and not a required argument of a previous option, is a non−option parameter. Each parameter after a _zsingle_quotesz_−−_zsingle_quotesz_ parameter is always interpreted as a non−option parameter. If the environment variable POSIXLY_CORRECT is set, or if the short option string started with a _zsingle_quotesz_+_zsingle_quotesz_, all remaining parameters are interpreted as non−option parameters as soon as the first non−option parameter is found.

OUTPUT

Output is generated for each element described in the previous section. Output is done in the same order as the elements are specified in the input, except for non−option parameters. Output can be done in compatible (unquoted) mode, or in such way that whitespace and other special characters within arguments and non−option parameters are preserved (see QUOTING). When the output is processed in the shell script, it will seem to be composed of distinct elements that can be processed one by one (by using the shift command in most shell languages). This is imperfect in unquoted mode, as elements can be split at unexpected places if they contain whitespace or special characters.

If there are problems parsing the parameters, for example because a required argument is not found or an option is not recognized, an error will be reported on stderr, there will be no output for the offending element, and a non−zero error status is returned.

For a short option, a single _zsingle_quotesz_−_zsingle_quotesz_ and the option character are generated as one parameter. If the option has an argument, the next parameter will be the argument. If the option takes an optional argument, but none was found, the next parameter will be generated but be empty in quoting mode, but no second parameter will be generated in unquoted (compatible) mode. Note that many other getopt(1) implementations do not support optional arguments.

If several short options were specified after a single _zsingle_quotesz_−_zsingle_quotesz_, each will be present in the output as a separate parameter.

For a long option, _zsingle_quotesz_−−_zsingle_quotesz_ and the full option name are generated as one parameter. This is done regardless whether the option was abbreviated or specified with a single _zsingle_quotesz_−_zsingle_quotesz_ in the input. Arguments are handled as with short options.

Normally, no non−option parameters output is generated until all options and their arguments have been generated. Then _zsingle_quotesz_−−_zsingle_quotesz_ is generated as a single parameter, and after it the non−option parameters in the order they were found, each as a separate parameter. Only if the first character of the short options string was a _zsingle_quotesz_−_zsingle_quotesz_, non−option parameter output is generated at the place they are found in the input (this is not supported if the first format of the SYNOPSIS is used; in that case all preceding occurrences of _zsingle_quotesz_−_zsingle_quotesz_ and _zsingle_quotesz_+_zsingle_quotesz_ are ignored).

QUOTING

In compatible mode, whitespace or _zsingle_quotesz_special_zsingle_quotesz_ characters in arguments or non−option parameters are not handled correctly. As the output is fed to the shell script, the script does not know how it is supposed to break the output into separate parameters. To circumvent this problem, this implementation offers quoting. The idea is that output is generated with quotes around each parameter. When this output is once again fed to the shell (usually by a shell eval command), it is split correctly into separate parameters.

Quoting is not enabled if the environment variable GETOPT_COMPATIBLE is set, if the first form of the SYNOPSIS is used, or if the option _zsingle_quotesz_−u_zsingle_quotesz_ is found.

Different shells use different quoting conventions. You can use the _zsingle_quotesz_−s_zsingle_quotesz_ option to select the shell you are using. The following shells are currently supported: _zsingle_quotesz_sh_zsingle_quotesz_, _zsingle_quotesz_bash_zsingle_quotesz_, _zsingle_quotesz_csh_zsingle_quotesz_ and _zsingle_quotesz_tcsh_zsingle_quotesz_. Actually, only two _zsingle_quotesz_flavors_zsingle_quotesz_ are distinguished: sh−like quoting conventions and csh−like quoting conventions. Chances are that if you use another shell script language, one of these flavors can still be used.

SCANNING MODES

The first character of the short options string may be a _zsingle_quotesz_−_zsingle_quotesz_ or a _zsingle_quotesz_+_zsingle_quotesz_ to indicate a special scanning mode. If the first calling form in the SYNOPSIS is used they are ignored; the environment variable POSIXLY_CORRECT is still examined, though.

If the first character is _zsingle_quotesz_+_zsingle_quotesz_, or if the environment variable POSIXLY_CORRECT is set, parsing stops as soon as the first non−option parameter (i.e., a parameter that does not start with a _zsingle_quotesz_−_zsingle_quotesz_) is found that is not an option argument. The remaining parameters are all interpreted as non−option parameters.

If the first character is a _zsingle_quotesz_−_zsingle_quotesz_, non−option parameters are outputted at the place where they are found; in normal operation, they are all collected at the end of output after a _zsingle_quotesz_−−_zsingle_quotesz_ parameter has been generated. Note that this _zsingle_quotesz_−−_zsingle_quotesz_ parameter is still generated, but it will always be the last parameter in this mode.

COMPATIBILITY

This version of getopt(1) is written to be as compatible as possible to other versions. Usually you can just replace them with this version without any modifications, and with some advantages.

If the first character of the first parameter of getopt is not a _zsingle_quotesz_−_zsingle_quotesz_, getopt goes into compatibility mode. It will interpret its first parameter as the string of short options, and all other arguments will be parsed. It will still do parameter shuffling (i.e., all non−option parameters are output at the end), unless the environment variable POSIXLY_CORRECT is set.

The environment variable GETOPT_COMPATIBLE forces getopt into compatibility mode. Setting both this environment variable and POSIXLY_CORRECT offers 100% compatibility for _zsingle_quotesz_difficult_zsingle_quotesz_ programs. Usually, though, neither is needed.

In compatibility mode, leading _zsingle_quotesz_−_zsingle_quotesz_ and _zsingle_quotesz_+_zsingle_quotesz_ characters in the short options string are ignored.

RETURN CODES

getopt returns error code 0 for successful parsing, 1 if getopt(3) returns errors, 2 if it does not understand its own parameters, 3 if an internal error occurs like out−of−memory, and 4 if it is called with −T.

EXAMPLES

Example scripts for (ba)sh and (t)csh are provided with the getopt(1) distribution, and are optionally installed in /usr/share/getopt/ or /usr/share/doc/ in the util-linux subdirectory.

ENVIRONMENT

BUGS

getopt(3) can parse long options with optional arguments that are given an empty optional argument (but cannot do this for short options). This getopt(1) treats optional arguments that are empty as if they were not present.

The syntax if you do not want any short option variables at all is not very intuitive (you have to set them explicitly to the empty string).

AUTHOR

Frodo Looijaard

SEE ALSO

bash(1), tcsh(1), getopt(3)

AVAILABILITY

The getopt command is part of the util-linux package and is available from Linux Kernel Archive

DESCRIPTION

The getopt() function parses the command-line arguments. Its arguments argc and argv are the argument count and array as passed to the main() function on program invocation. An element of argv that starts with _zsingle_quotesz_−_zsingle_quotesz_ (and is not exactly − or −−) is an option element. The characters of this element (aside from the initial _zsingle_quotesz_−_zsingle_quotesz_) are option characters. If getopt() is called repeatedly, it returns successively each of the option characters from each of the option elements.

The variable optind is the index of the next element to be processed in argv. The system initializes this value to 1. The caller can reset it to 1 to restart scanning of the same argv, or when scanning a new argument vector.

If getopt() finds another option character, it returns that character, updating the external variable optind and a static variable nextchar so that the next call to getopt() can resume the scan with the following option character or argv-element.

If there are no more option characters, getopt() returns −1. Then optind is the index in argv of the first argv-element that is not an option.

optstring is a string containing the legitimate option characters. If such a character is followed by a colon, the option requires an argument, so getopt() places a pointer to the following text in the same argv-element, or the text of the following argv-element, in optarg. Two colons mean an option takes an optional arg; if there is text in the current argv-element (i.e., in the same word as the option name itself, for example, −oarg), then it is returned in optarg, otherwise optarg is set to zero. This is a GNU extension. If optstring contains W followed by a semicolon, then −W foo is treated as the long option −−foo. (The −W option is reserved by POSIX.2 for implementation extensions.) This behavior is a GNU extension, not available with libraries before glibc 2.

By default, getopt() permutes the contents of argv as it scans, so that eventually all the nonoptions are at the end. Two other modes are also implemented. If the first character of optstring is _zsingle_quotesz_+_zsingle_quotesz_ or the environment variable POSIXLY_CORRECT is set, then option processing stops as soon as a nonoption argument is encountered. If the first character of optstring is _zsingle_quotesz_−_zsingle_quotesz_, then each nonoption argv-element is handled as if it were the argument of an option with character code 1. (This is used by programs that were written to expect options and other argv-elements in any order and that care about the ordering of the two.) The special argument −− forces an end of option-scanning regardless of the scanning mode.

While processing the option list, getopt() can detect two kinds of errors: (1) an option character that was not specified in optstring and (2) a missing option argument (i.e., an option at the end of the command line without an expected argument). Such errors are handled and reported as follows:

RETURN VALUE

If an option was successfully found, then getopt() returns the option character. If all command-line options have been parsed, then getopt() returns −1. If getopt() encounters an option character that was not in optstring, then _zsingle_quotesz_?_zsingle_quotesz_ is returned. If getopt() encounters an option with a missing argument, then the return value depends on the first character in optstring: if it is _zsingle_quotesz_:_zsingle_quotesz_, then _zsingle_quotesz_:_zsingle_quotesz_ is returned; otherwise _zsingle_quotesz_?_zsingle_quotesz_ is returned.

getopt_long() and getopt_long_only() also return the option character when a short option is recognized. For a long option, they return val if flag is NULL, and 0 otherwise. Error and −1 returns are the same as for getopt(), plus _zsingle_quotesz_?_zsingle_quotesz_ for an ambiguous match or an extraneous parameter.

ENVIRONMENT

ATTRIBUTES

For an explanation of the terms used in this section, see attributes(7).

CONFORMING TO

NOTES

A program that scans multiple argument vectors, or rescans the same vector more than once, and wants to make use of GNU extensions such as _zsingle_quotesz_+_zsingle_quotesz_ and _zsingle_quotesz_−_zsingle_quotesz_ at the start of optstring, or changes the value of POSIXLY_CORRECT between scans, must reinitialize getopt() by resetting optind to 0, rather than the traditional value of 1. (Resetting to 0 forces the invocation of an internal initialization routine that rechecks POSIXLY_CORRECT and checks for GNU extensions in optstring.)

EXAMPLE

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>

int
main(int argc, char *argv[])
{
    int flags, opt;
    int nsecs, tfnd;

    nsecs = 0;
    tfnd = 0;
    flags = 0;
    while ((opt = getopt(argc, argv, nt:)) != −1) {
        switch (opt) {
        case _zsingle_quotesz_n_zsingle_quotesz_:
            flags = 1;
            break;
        case _zsingle_quotesz_t_zsingle_quotesz_:
            nsecs = atoi(optarg);
            tfnd = 1;
            break;
        default: /* _zsingle_quotesz_?_zsingle_quotesz_ */
            fprintf(stderr, Usage: %s [−t nsecs] [−n] name
,
                    argv[0]);
            exit(EXIT_FAILURE);
        }
    }

    printf(flags=%d; tfnd=%d; nsecs=%d; optind=%d
,
            flags, tfnd, nsecs, optind);

    if (optind >= argc) {
        fprintf(stderr, Expected argument after options
);
        exit(EXIT_FAILURE);
    }

    printf(name argument = %s
, argv[optind]);

    /* Other code omitted */

    exit(EXIT_SUCCESS);
}

#include <stdio.h>     /* for printf */
#include <stdlib.h>    /* for exit */
#include <getopt.h>

int
main(int argc, char **argv)
{
    int c;
    int digit_optind = 0;

    while (1) {
        int this_option_optind = optind ? optind : 1;
        int option_index = 0;
        static struct option long_options[] = {
            {add,     required_argument, 0,  0 },
            {append,  no_argument,       0,  0 },
            {delete,  required_argument, 0,  0 },
            {verbose, no_argument,       0,  0 },
            {create,  required_argument, 0, _zsingle_quotesz_c_zsingle_quotesz_},
            {file,    required_argument, 0,  0 },
            {0,         0,                 0,  0 }
        };

        c = getopt_long(argc, argv, abc:d:012,
                 long_options, &option_index);
        if (c == −1)
            break;

        switch (c) {
        case 0:
            printf(option %s, long_options[option_index].name);
            if (optarg)
                printf( with arg %s, optarg);
            printf(
);
            break;

        case _zsingle_quotesz_0_zsingle_quotesz_:
        case _zsingle_quotesz_1_zsingle_quotesz_:
        case _zsingle_quotesz_2_zsingle_quotesz_:
            if (digit_optind != 0 && digit_optind != this_option_optind)
              printf(digits occur in two different argv−elements.
);
            digit_optind = this_option_optind;
            printf(option %c
, c);
            break;

        case _zsingle_quotesz_a_zsingle_quotesz_:
            printf(option a
);
            break;

        case _zsingle_quotesz_b_zsingle_quotesz_:
            printf(option b
);
            break;

        case _zsingle_quotesz_c_zsingle_quotesz_:
            printf(option c with value _zsingle_quotesz_%s_zsingle_quotesz_
, optarg);
            break;

        case _zsingle_quotesz_d_zsingle_quotesz_:
            printf(option d with value _zsingle_quotesz_%s_zsingle_quotesz_
, optarg);
            break;

        case _zsingle_quotesz_?_zsingle_quotesz_:
            break;

        default:
            printf(?? getopt returned character code 0%o ??
, c);
        }
    }

    if (optind < argc) {
        printf(non−option ARGV−elements: );
        while (optind < argc)
            printf(%s , argv[optind++]);
        printf(
);
    }

    exit(EXIT_SUCCESS);
}

SEE ALSO

getopt(1), getsubopt(3)