Table of Contents
The
function incrementally parses a command line argument list and returns
the next option character. An option character is if it has been specified
in the string of accepted option characters, The option string may contain
the following elements: individual characters, and characters followed
by a colon to indicate an option argument is to follow. For example, an
option string recognizes an option and an option string recognizes an
option and argument It does not matter to if a following argument has
leading white space. On return from points to an option argument, if
it is anticipated, and the variable contains the index to the next argument
for a subsequent call to The variable saves the last option character
returned by The variable and are both initialized to 1. The variable
may be set to another value before a set of calls to in order to skip
over more or less argv entries. In order to use to evaluate multiple sets
of arguments, or to evaluate a single set of arguments multiple times,
the variable must be set to 1 before the second and each additional set
of calls to and the variable must be reinitialized. The function returns
-1 when the argument list is exhausted, or a non-recognized option is encountered.
The interpretation of options in the argument list may be cancelled by
the option (double dash) which causes to signal the end of argument processing
and returns -1. When all options have been processed (i.e., up to the first
non-option argument), returns -1.
If the function encounters
a character not found in the string or detects a missing option argument
it writes an error message and returns to the Setting to a zero will
disable these error messages. If has a leading then a missing option
argument causes a to be returned in addition to suppressing any error
messages. Option arguments are allowed to begin with this is reasonable
but reduces the amount of error checking possible.
The variable
was added to make it possible to call the function multiple times. This
is an extension to the specification.
extern char *optarg; extern
int optind; int bflag, ch, fd;
bflag = 0; while ((ch = getopt(argc, argv,
"bf:")) != -1) switch(ch) {
case ’b’:
bflag = 1;
break;
case ’f’:
if ((fd = open(optarg, O_RDONLY, 0)) < 0) {
(void)fprintf(stderr,
"myname: %s: %s\n", optarg, strerror(errno));
exit(1)
;
}
break;
case ’?’:
default:
usage();
} argc -= optind; argv += optind;
The function appeared
The
function was once specified to return instead of -1. This was changed by
to decouple from A single dash may be specified as an character
in however it should have an argument associated with it. This allows
to be used with programs that expect as an option flag. This practice
is wrong, and should not be used in any current development. It is provided
for backward compatibility By default, a single dash causes to return
-1. This is, we believe, compatible with System V. It is also possible to
handle digits as option letters. This allows to be used with programs that
expect a number as an option. This practice is wrong, and should not be
used in any current development. It is provided for backward compatibility
The following code fragment works in most cases. int length; char *p;
while ((c = getopt(argc, argv, "0123456789")) != -1) switch (c) {
case ’0’: case ’1’: case ’2’: case ’3’: case ’4’:
case ’5’: case ’6’: case ’7’: case ’8’: case ’9’:
p = argv[optind - 1];
if (p[0] == ’-’ && p[1] == ch && !p[2])
length = atoi(++p);
else
length = atoi(argv[optind] + 1);
break;
}
}
Table of Contents