Section (1) getopt
Name
getopt — parse command options (enhanced)
Synopsis
getopt
optstring
parameters
getopt
[options]
[−−
] optstring
parameters
getopt
[options]
−o
| −−options
optstring [options]
[−−
] parameters
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
−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 inlongopts
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.
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
POSIXLY_CORRECT
-
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_.
GETOPT_COMPATIBLE
-
Forces getopt to use the first calling format as specified in the
SYNOPSIS
.
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).
AVAILABILITY
The getopt command is part of the util-linux package and is available from Linux Kernel Archive
|
Section (3) getopt
Name
getopt, getopt_long, getopt_long_only, optarg, optind, opterr, optopt — Parse command-line options
Synopsis
#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 | ||||
---|---|---|---|---|---|
|
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:
-
By default,
getopt
() prints an error message on standard error, places the erroneous option character inoptopt
, and returns _zsingle_quotesz_?_zsingle_quotesz_ as the function result. -
If the caller has set the global variable
opterr
to zero, thengetopt
() 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_), thengetopt
() 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:
name
-
is the name of the long option.
has_arg
-
is:
no_argument
(or 0) if the option does not take an argument;required_argument
(or 1) if the option requires an argument; oroptional_argument
(or 2) if the option takes an optional argument. flag
-
specifies how results are returned for a long option. If
flag
is NULL, thengetopt_long
() returnsval
. (For example, the calling program may setval
to the equivalent short option character.) Otherwise,getopt_long
() returns 0, andflag
points to a variable which is set toval
if the option is found, but left unchanged if the option is not found. val
-
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.
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
POSIXLY_CORRECT
-
If this is set, then option processing stops as soon as a nonoption argument is encountered.
- _<PID>_GNU_nonoption_argv_flags_
-
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.
ATTRIBUTES
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 |
CONFORMING TO
getopt
():-
POSIX.1-2001, POSIX.1-2008, and POSIX.2, provided the environment variable
POSIXLY_CORRECT
is set. Otherwise, the elements ofargv
aren_zsingle_quotesz_t reallyconst
, because we permute them. We pretend they_zsingle_quotesz_reconst
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.
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
getopt()
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> 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); }
getopt_long()
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> 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); }
COLOPHON
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
https://www.kernel.org/doc/man−pages/.
Copyright (c) 1993 by Thomas Koenig (ig25rz.uni-karlsruhe.de) %%%LICENSE_START(VERBATIM) 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 professionally. Formatted or processed versions of this manual, if unaccompanied by the source, must acknowledge the copyright and authors of this work. %%%LICENSE_END Modified Sat Jul 24 19:27:50 1993 by Rik Faith (faithcs.unc.edu) Modified Mon Aug 30 22:02:34 1995 by Jim Van Zandt <jrvvanzandt.mv.com> 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 (jsm28cam.ac.uk) 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 <mtk.manpagesgmail.com> 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. |