GETOPT(3)           Linux Programmer's Manual           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 invoca-
       tion.  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  lon-
       gopts  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()
GNU                       April 25, 1993                        1
GETOPT(3)           Linux Programmer's Manual           GETOPT(3)
              returns a value for a long option; if  it  is  non-
              zero,  zero is returned as a function value, other-
              wise 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 fea-
       tures.
       #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)
GNU                       April 25, 1993                        2
GETOPT(3)           Linux Programmer's Manual           GETOPT(3)
            {
            case 0:
              printf ("option %s", long_options[option_index].name);
              if (optarg)
                printf (" with arg %s", optarg);
              printf ("0);
              break;
            case '0':
            case '1':
            case '2':
              if (digit_optind != 0 && digit_optind != this_option_optind)
                printf ("digits occur in two different argv-elements.0);
              digit_optind = this_option_optind;
              printf ("option %c0, c);
              break;
            case 'a':
              printf ("option a0);
              break;
            case 'b':
              printf ("option b0);
              break;
            case 'c':
              printf ("option c with value `%s'0, optarg);
              break;
            case 'd':
              printf ("option d with value `%s'0, optarg);
              break;
            case '?':
              break;
            default:
              printf ("?? getopt returned character code 0%o ??0, c);
            }
           }
         if (optind < argc)
           {
             printf ("non-option ARGV-elements: ");
             while (optind < argc)
            printf ("%s ", argv[optind++]);
             printf ("0);
           }
         exit (0);
       }
BUGS
       This manpage is confusing.
GNU                       April 25, 1993                        3
GETOPT(3)           Linux Programmer's Manual           GETOPT(3)
CONFORMS TO
       getopt() :
              POSIX.1
GNU                       April 25, 1993                        4
This manual page was brought to you by mjl_man V-2.0