getopt

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()
              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)

            {
            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.

CONFORMS TO

       getopt() :
              POSIX.1