Section (1) getopt

Linux manual pages Section 1  


getopt — parse command options (enhanced)


getopt optstring parameters

getopt [options] [−−] optstring parameters

getopt [options] −o | −−options optstring [options] [−−] parameters


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.


−a, −−alternative

Allow long options to start with a single _zsingle_quotesz__zsingle_quotesz_.

−h, −−help

Display help text and exit. No other output is generated.

−l, −−longoptions longopts

The long (multi−character) options to be recognized. More than one option name may be specified at once, by separating the names with commas. This option may be given more than once, the longopts are cumulative. Each long option name in longopts may be followed by one colon to indicate it has a required argument, and by two colons to indicate it has an optional argument.

−n, −−name progname

The name that will be used by the getopt(3) routines when it reports errors. Note that errors of getopt(1) are still reported as coming from getopt.

−o, −−options shortopts

The short (one−character) options to be recognized. If this option is not found, the first parameter of getopt that does not start with a _zsingle_quotesz__zsingle_quotesz_ (and is not an option argument) is used as the short options string. Each short option character in shortopts may be followed by one colon to indicate it has a required argument, and by two colons to indicate it has an optional argument. The first character of shortopts may be _zsingle_quotesz_+_zsingle_quotesz_ or _zsingle_quotesz__zsingle_quotesz_ to influence the way options are parsed and output is generated (see section SCANNING MODES for details).

−q, −−quiet

Disable error reporting by getopt(3).

−Q, −−quiet−output

Do not generate normal output. Errors are still reported by getopt(3), unless you also use −q.

−s, −−shell shell

Set quoting conventions to those of shell. If the −s option is not given, the BASH conventions are used. Valid arguments are currently _zsingle_quotesz_sh_zsingle_quotesz_ _zsingle_quotesz_bash_zsingle_quotesz_, _zsingle_quotesz_csh_zsingle_quotesz_, and _zsingle_quotesz_tcsh_zsingle_quotesz_.

−T, −−test

Test if your getopt(1) is this enhanced version or an old version. This generates no output, and sets the error status to 4. Other implementations of getopt(1), and this version if the environment variable GETOPT_COMPATIBLE is set, will return _zsingle_quotesz_−−_zsingle_quotesz_ and error status 0.

−u, −−unquoted

Do not quote the output. Note that whitespace and special (shell-dependent) characters can cause havoc in this mode (like they do with other getopt(1) implementations).

−V, −−version

Display version information and exit. No other output is generated.


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 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).


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.


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.


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.


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.


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.



This environment variable is examined by the getopt(3) routines. If it is set, parsing stops as soon as a parameter is found that is not an option or an option argument. All remaining parameters are also interpreted as non−option parameters, regardless whether they start with a _zsingle_quotesz__zsingle_quotesz_.


Forces getopt to use the first calling format as specified in the SYNOPSIS.


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).


Frodo Looijaard


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


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

Section (3) getopt

Linux manual pages Section 3  


getopt, getopt_long, getopt_long_only, optarg, optind, opterr, optopt — Parse command-line options


#include <unistd.h>
int getopt( int argc,
  char * const argv[],
  const char *optstring);
extern char *optarg;
extern int optind, opterr, optopt;

#include <getopt.h>
int getopt_long( int argc,
  char * const argv[],
  const char *optstring,
  const struct option *longopts,
  int *longindex);
int getopt_long_only( int argc,
  char * const argv[],
  const char *optstring,
  const struct option *longopts,
  int *longindex);
[Note] Note
Feature Test Macro Requirements for glibc (see feature_test_macros(7)):
getopt_long(), getopt_long_only():


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:

  • By default, getopt() prints an error message on standard error, places the erroneous option character in optopt, and returns _zsingle_quotesz_?_zsingle_quotesz_ as the function result.

  • If the caller has set the global variable opterr to zero, then getopt() does not print an error message. The caller can determine that there was an error by testing whether the function return value is _zsingle_quotesz_?_zsingle_quotesz_. (By default, opterr has a nonzero value.)

  • If the first character (following any optional _zsingle_quotesz_+_zsingle_quotesz_ or _zsingle_quotesz_−_zsingle_quotesz_ described above) of optstring is a colon (_zsingle_quotesz_:_zsingle_quotesz_), then getopt() likewise does not print an error message. In addition, it returns _zsingle_quotesz_:_zsingle_quotesz_ instead of _zsingle_quotesz_?_zsingle_quotesz_ to indicate a missing option argument. This allows the caller to distinguish the two different types of errors.

getopt_long() and getopt_long_only()

The getopt_long() function works like getopt() except that it also accepts long options, started with two dashes. (If the program accepts only long options, then optstring should be specified as an empty string (), not NULL.) Long option names may be abbreviated if the abbreviation is unique or is an exact match for some defined option. A long option may take a parameter, of the form −−arg=param or −−arg param.

longopts is a pointer to the first element of an array of struct option declared in <getopt.h> as

struct option {
  const char * name;  
  int   has_arg;  
  int * flag;  
  int   val;  

The meanings of the different fields are:


is the name of the long option.


is: no_argument (or 0) if the option does not take an argument; required_argument (or 1) if the option requires an argument; or optional_argument (or 2) if the option takes an optional argument.


specifies how results are returned for a long option. If flag is NULL, then getopt_long() returns val. (For example, the calling program may set val to the equivalent short option character.) Otherwise, getopt_long() returns 0, and flag points to a variable which is set to val if the option is found, but left unchanged if the option is not found.


is the value to return, or to load into the variable pointed to by flag.

The last element of the array has to be filled with zeros.

If longindex is not NULL, it points to a variable which is set to the index of the long option relative to longopts.

getopt_long_only() is like getopt_long(), but _zsingle_quotesz_−_zsingle_quotesz_ as well as −− can indicate a long option. If an option that starts with _zsingle_quotesz_−_zsingle_quotesz_ (not −−) doesn_zsingle_quotesz_t match a long option, but does match a short option, it is parsed as a short option instead.


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.



If this is set, then option processing stops as soon as a nonoption argument is encountered.


This variable was used by bash(1) 2.0 to communicate to glibc which arguments are the results of wildcard expansion and so should not be considered as options. This behavior was removed in bash(1) version 2.01, but the support remains in glibc.


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

Interface Attribute Value
getopt(), getopt_long(), getopt_long_only() Thread safety MT-Unsafe race:getopt env



POSIX.1-2001, POSIX.1-2008, and POSIX.2, provided the environment variable POSIXLY_CORRECT is set. Otherwise, the elements of argv aren_zsingle_quotesz_t really const, because we permute them. We pretend they_zsingle_quotesz_re const in the prototype to be compatible with other systems.

The use of _zsingle_quotesz_+_zsingle_quotesz_ and _zsingle_quotesz_−_zsingle_quotesz_ in optstring is a GNU extension.

On some older implementations, getopt() was declared in <stdio.h> SUSv1 permitted the declaration to appear in either <unistd.h> or <stdio.h> POSIX.1-1996 marked the use of <stdio.h> for this purpose as LEGACY. POSIX.1-2001 does not require the declaration to appear in <stdio.h>

getopt_long() and getopt_long_only():

These functions are GNU extensions.


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.)



The following trivial example program uses getopt() to handle two program options: −n, with no associated value; and −t val, which expects an associated value.

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

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;
        case _zsingle_quotesz_t_zsingle_quotesz_:
            nsecs = atoi(optarg);
            tfnd = 1;
        default: /* _zsingle_quotesz_?_zsingle_quotesz_ */
            fprintf(stderr, Usage: %s [−t nsecs] [−n] name

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

    if (optind >= argc) {
        fprintf(stderr, Expected argument after options

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

    /* Other code omitted */



The following example program illustrates the use of getopt_long() with most of its features.

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

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)

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

        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);

        case _zsingle_quotesz_a_zsingle_quotesz_:
            printf(option a

        case _zsingle_quotesz_b_zsingle_quotesz_:
            printf(option b

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

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

        case _zsingle_quotesz_?_zsingle_quotesz_:

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

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



getopt(1), getsubopt(3)


This page is part of release 5.04 of the Linux man-pages project. A description of the project, information about reporting bugs, and the latest version of this page, can be found at−pages/.

  Copyright (c) 1993 by Thomas Koenig (

Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.

Permission is granted to copy and distribute modified versions of this
manual under the conditions for verbatim copying, provided that the
entire resulting derived work is distributed under the terms of a
permission notice identical to this one.

Since the Linux kernel and libraries are constantly changing, this
manual page may be incorrect or out-of-date.  The author(s) assume no
responsibility for errors or omissions, or for damages resulting from
the use of the information contained herein.  The author(s) may not
have taken the same level of care in the production of this manual,
which is licensed free of charge, as they might when working

Formatted or processed versions of this manual, if unaccompanied by
the source, must acknowledge the copyright and authors of this work.

Modified Sat Jul 24 19:27:50 1993 by Rik Faith (
Modified Mon Aug 30 22:02:34 1995 by Jim Van Zandt <>
 longindex is a pointer, has_arg can take 3 values, using consistent
 names for optstring and longindex,   in formats fixed.  Documenting
 opterr and getopt_long_only.  Clarified explanations (borrowing heavily
 from the source code).
Modified 8 May 1998 by Joseph S. Myers (
Modified 990715, aeb: changed `EOF_zsingle_quotesz_ into `-1_zsingle_quotesz_ since that is what POSIX
 says; moreover, EOF is not defined in <unistd.h>.
Modified 2002-02-16, joey: added information about nonexistent
 option character and colon as first option character
Modified 2004-07-28, Michael Kerrisk <>
Added text to explain how to order both _zsingle_quotesz_[-+]_zsingle_quotesz_ and _zsingle_quotesz_:_zsingle_quotesz_ at
the start of optstring
Modified 2006-12-15, mtk, Added getopt() example program.