getopt - Get option letters from the argument vector
#include <unistd.h>
int getopt(
int argc,
char * const argv [],
const char *optstring );
extern char *optarg; extern int optind; extern int opterr;
extern int optopt;
Standard C Library (libc)
Interfaces documented on this reference page conform to
industry standards as follows:
getopt(): XSH5.0
Refer to the standards(5) reference page for more information
about industry standards and associated tags.
Specifies the number of parameters passed to the routine.
Points to an array of argc pointers to argument strings.
Specifies a string of recognized option characters. If a
character is followed by a : (colon), the option is
expected to take a parameter that may or may not be separated
from it by white space.
The getopt() function parses argument lists. It returns
the next option character in the argv parameter list that
matches a character in the optstring parameter. If that
option takes an argument, the getopt() function has the
optarg variable point to the option argument according to
the following rules: If the option is the last character
pointed to by an argv element, optarg will contain argv's
next element, and optind is incremented by 2. The getopt()
function returns an error if the resulting optind is
greater than or equal to argc. If the option is not the
last character, then the optarg variable points to the
string after the option character in the associated element
of argv. The optind variable is incremented by 1.
The optarg external variable is set to point to the start
of the option's parameter on return from the getopt()
function.
The getopt() function places the argv index of the next
argument to be processed in optind. The optind variable is
externally initialized to 1 before the first call to
getopt() so that argv[0] is not processed. Error messages
can be suppressed by providing a value of 0 (zero) as the
opterr parameter.
[Tru64 UNIX] The external int optopt variable is set to
the real option found in the argv parameter. This is true
whether the option is in the optstring parameter or not.
Upon successful completion, the getopt() function returns
the option character that was detected. If the function
encounters a option that is not included in the optstring
parameter, or if the : (colon) character is used incorrectly,
the getopt() function prints an error message on
stderr and returns a ? (question mark). If there is a
missing option, the getopt() function returns a : (colon)
if optstring's first character is a : (colon), and a ?
(question mark) otherwise. In addition, the getopt() function
sets the optopt variable to the option character that
caused one of these errors.
The getopt() function also displays a diagnostic message
if the application did not set the opterr variable to 0
(zero), and optstring's first character is not a :
(colon).
When all options have been processed (that is, up to the
first nonoption argument), the getopt() function returns a
value of -1. The special option -- (dash dash) can be
used to delimit the end of the options; -1 is returned,
and the -- (dash dash) string is skipped.
The getopt() function does not change optind, and also
returns a value of -1, if one of the following occurs: The
argv[optind] result is NULL. The *argv[optind] result is
not the special - (dash) option. The argv[optind] result
points to the - (dash) string.
The getopt() function does increment optind if the result
of argv[optind] points to the -- (dash dash) string.
The following example shows a suggested way to use the
getopt() function.
#include <unistd.h> main(argc, argv) int argc; char
*argv[];
#define ARGS "r:w:f:s"
{
int c, errflg = 0;
int readers = 1, writers = 1;
int freeBufs = 1;
int doStats = FALSE;
optarg = NULL;
while (!errflg && ((c = getopt(argc, argv, ARGS))
!= -1))
switch (c) {
case 'r' :
readers = atoi(optarg);
break;
case 'w' :
writers = atoi(optarg);
break;
case 'f' :
freeBufs = atoi(optarg);
break;
case 's' :
doStats = TRUE;
break;
default :
errflg++;
}
Commands: getopt(1)
Standards: standards(5)
getopt(3)
[ Back ] | 