GETOPT(3) manual page

Table of Contents

#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 *shortopts, const struct option *longopts, int longind);

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. optstring is a list of available option characters. If such a character is followed by a colon, the option takes an argument, which is placed in optarg.

The external variable optind is the index of the next array element of argv[] to be processed; it communicates from one call of getopt() to the next which element to process.

The getopt_long() function works like getopt() except that it also accepts long options, started out by two dashes. If these take values, it is either in the form --arg=value or --arg value. It takes the additional arguments longopts which 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 meaning of the different fields are:

name: is the name of the long option.
has_arg: is a boolean value which should be set to nonzero if the long option takes a value.
flag: determines the return value if getopt_long() returns a value for a long option; if it is non-zero, zero is returned as a function value, otherwise val.
val: determines the value to return if flag is zero.

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

The option_index points to the index of the long option relative to longopts.

RETURN VALUE

The getopt() function returns the option character if the option was found successfully, ':' if there was a missing parameter for one of the options, '?' for an unknown option character and -1 for the end of the option list.

EXAMPLE

The following example program, from the source code, illustrates the use of getopt_long() with most of its features.
#include <stdio.h>

int
main (argc, argv)
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", 1, 0, 0},
{"append", 0, 0, 0},
{"delete", 1, 0, 0},
{"verbose", 0, 0, 0},
{"create", 1, 0, 'c'},
{"file", 1, 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 ("n");
break;

case '0':
case '1':
case '2':
if (digit_optind != 0 && digit_optind != this_option_optind)
printf ("digits occur in two different argv-elements.n");
digit_optind = this_option_optind;
printf ("option %cn", c);
break;