GETOPT(3)

NAME
getopt - Read 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 *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 (");
	  break;
	case '0':
	case '1':
	case '2':
	  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 'a':
	  printf ("option a);
	  break;
	case 'b':
	  printf ("option b);
	  break;
	case 'c':
	  printf ("option c with value `%s', optarg);
	  break;
	case 'd':
	  printf ("option d with value `%s', optarg);
	  break;
	case '?':
	  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 (0);
}

BUGS
This manpage is confusing.

CONFORMS TO

getopt() :
    POSIX.1