optionprocess(3) [debian man page]

optionProcess(3)						Programmer's Manual						  optionProcess(3)

NAME

       optionProcess - this is the main option processing routine

SYNOPSIS

       #include <your-opts.h>
       cc [...] -o outfile infile.c -lopts [...]

       int optionProcess(tOptions* pOpts, int argc, char** argv);

DESCRIPTION

       This  is  the main entry point for processing options.  It is intended that this procedure be called once at the beginning of the execution
       of a program.  Depending on options selected earlier, it is sometimes necessary to stop and restart option processing, or  to  select  com-
       pletely different sets of options.  This can be done easily, but you generally do not want to do this.

       The number of arguments processed always includes the program name.  If one of the arguments is "--", then it is counted and the processing
       stops.  If an error was encountered and errors are to be tolerated, then the returned value is the index of the argument causing the error.
       A  hyphen  by itself ("-") will also cause processing to stop and will not be counted among the processed arguments.  A hyphen by itself is
       treated as an operand.  Encountering an operand stops option processing.

       pOpts  program options descriptor

       argc   program arg count

       argv   program arg vector

RETURN VALUE

       the count of the arguments processed

ERRORS

       Errors will cause diagnostics to be printed.  exit(3) may or may not be called.	It depends upon whether or not the options were  generated
       with the "allow-errors" attribute, or if the ERRSKIP_OPTERR or ERRSTOP_OPTERR macros were invoked.

SEE ALSO

       The info documentation for the -lopts library.
       ao_string_tokenize(3),  configFileLoad(3), optionFileLoad(3), optionFindNextValue(3), optionFindValue(3), optionFree(3), optionGetValue(3),
       optionLoadLine(3), optionNextValue(3), optionOnlyUsage(3), optionRestore(3), optionSaveFile(3), optionSaveState(3),  optionUnloadNested(3),
       optionVersion(3), pathfind(3), strequate(3), streqvcmp(3), streqvmap(3), strneqvcmp(3), strtransform(3),

								    2011-07-10							  optionProcess(3)

ARG(2)								System Calls Manual							    ARG(2)

NAME

       ARGBEGIN, ARGEND, ARGC, ARGF, arginit, argopt - process option letters from argv

SYNOPSIS

       #include <u.h>
       #include <libc.h>

       ARGBEGIN {
       char *ARGF();
       Rune ARGC();
       } ARGEND

       extern char *argv0;

       /* Alef only */

       Arg  *arginit(int argc, byte **argv);

       Rune argopt(Arg *arg);

       byte *argf(Arg *arg);

DESCRIPTION

       These  macros  assume the names argc and argv are in scope; see exec(2).  ARGBEGIN and ARGEND surround code for processing program options.
       The code should be the cases of a C switch on option characters; it is executed once for each option character.	Options end after an argu-
       ment --, before an argument -, or before an argument that doesn't begin with -.

       ARGC() returns the current option character.

       ARGF()  returns	the current option argument: a pointer to the rest of the option string if not empty, or the next argument in argv if any,
       or 0.  ARGF must be called just once for each option that takes an argument.

       After ARGBEGIN, argv0 is a copy of argv[0] (conventionally the name of the program).

       After ARGEND, argv points at a zero-terminated list of the remaining argc arguments.

   Alef
       The Alef argument processing routines are unrelated.  Instead, an aggr called Arg is initialized by a call to arginit.  Successive calls to
       argopt  return  successive  option  characters,	or  zero at the end of the options.  After a call to argopt, argf will return any argument
       string associated with the option.

EXAMPLES

       This C program can take option b and option f, which requires an argument.

	      #include <u.h>
	      #include <libc.h>
	      void
	      main(int argc, char *argv[])
	      {
		      char *f;
		      print("%s", argv[0]);
		      ARGBEGIN {
		      case 'b':
			      print(" -b");
			      break;
		      case 'f':
			      print(" -f(%s)", (f=ARGF())? f: "no arg");
			      break;
		      default:
			      print(" badflag('%c')", ARGC());
		      } ARGEND
		      print(" %d args:", argc);
		      while(*argv)
			      print(" '%s'", *argv++);
		      print("
");
		      exits(0);
	      }

       Here is the output for the run prog -bffile1 -r -f file2 arg1 arg2

	      prog -b -f(file1) badflag('r') -f(file2) 2 args: 'arg1' 'arg2'

       This Alef program accepts options b and, with an attached file name, f.

	      #include <alef.h>
	      void
	      main(int argc, byte **argv)
	      {
		      int a, ac, bflag;
		      byte *file;
		      Arg *arg;

		      arg = arginit(argc, argv);
		      while(ac = argopt(arg)) switch(ac){
		      case 'b':
			      bflag = 1;
			      break;
		      case 'f':
			      file = argf(arg);
			      break;
		      }
		      for(a=0; a<arg->ac; a++)
			      print("argument %s
", arg->av[a]);
	      }

SOURCE

       /sys/include/libc.h

																	    ARG(2)