Unix/Linux Go Back    

BSD 2.11 - man page for getopt (bsd section 3)

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:   man
Select Man Page Set:       apropos Keyword Search (sections above)

GETOPT(3)										GETOPT(3)

       getopt - get option character from command line argument list

       #include <stdlib.h>

       extern char *optarg;
       extern int optind;
       extern int optopt;
       extern int opterr;
       extern int optreset;

       getopt(argc, argv, optstring)
       int argc;
       char **argv;
       char *optstring;

       The  getopt()  function incrementally parses a command line argument list argv and returns
       the next known option character.  An option character is known if it has been specified in
       the string of accepted option characters, optstring.

       The option string optstring 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 """x"" recognizes an option ``-x'', and an option string """x:"" recog-
       nizes an option and argument ``-x argument''.  It does not matter to getopt() if a follow-
       ing argument has leading white space.

       On  return  from  getopt(), optarg points to an option argument, if it is anticipated, and
       the variable optind contains the index to the next argv argument for a subsequent call  to
       getopt().  The variable optopt saves the last known option character returned by getopt().

       The  variable opterr and optind are both initialized to 1.  The optind variable may be set
       to another value before a set of calls to getopt() in order to skip over more or less argv

       In  order  to use getopt() to evaluate multiple sets of arguments, or to evaluate a single
       set of arguments multiple times, the variable optreset must be set to 1 before the  second
       and  each  additional set of calls to getopt(), and the variable optind must be reinitial-

       The getopt() function returns an EOF when the argument list is exhausted, or a  non-recog-
       nized  option  is  encountered.	The interpretation of options in the argument list may be
       cancelled by the option `--' (double dash) which causes getopt()  to  signal  the  end  of
       argument  processing and return an EOF.	When all options have been processed (i.e., up to
       the first non-option argument), getopt() returns EOF.

       If the getopt() function encounters a character not found in the string optarg or  detects
       a missing option argument it writes an error message and returns `?'  to the stderr.  Set-
       ting opterr to a zero will disable these error messages.  If optstring 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 optreset variable was added to make it possible to call the getopt() function multiple
       times.  This is an extension to the IEEE Std1003.2 (``POSIX'') specification.

       extern char *optarg;
       extern int optind;
       int bflag, ch, fd;

       bflag = 0;
       while ((ch = getopt(argc, argv, "bf:")) != EOF)
	    switch(ch) {
	    case 'b':
		 bflag = 1;
	    case 'f':
		 if ((fd = open(optarg, O_RDONLY, 0)) < 0) {
			  "myname: %s: %s\n", optarg, strerror(errno));
	    case '?':
       argc -= optind;
       argv += optind;

       The getopt() function appeared 4.3BSD.

       A single dash ``-'' may be specified as an character in	optstring  ,  however  it  should
       never  have an argument associated with it.  This allows getopt() 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 only .  By default, a
       single dash causes getopt() to return EOF.  This is, we believe, compatible with System V.

       It is also possible to handle digits as option letters.	This allows getopt() to  be  used
       with  programs  that  expect  a number (``-3'') as an option.  This practice is wrong, and
       should not be used in any current development.  It is provided for backward  compatibility
       only.  The following code fragment works in most cases.

       int length;
       char *p;

       while ((c = getopt(argc, argv, "0123456789")) != EOF)
	    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);
		      length = atoi(argv[optind] + 1);

4.3 Berkeley Distribution		 January 12, 1996				GETOPT(3)
Unix & Linux Commands & Man Pages : ©2000 - 2018 Unix and Linux Forums

All times are GMT -4. The time now is 03:14 AM.