varargs(3)						     Library Functions Manual							varargs(3)

NAME

       varargs, va_arg, va_start, va_end - Handles a variable-length parameter list

LIBRARY

       Standard C Library (libc.a)

SYNOPSIS

       #include <varargs.h>

       va_alist va_dcl void va_start (	    va_alist argp ); type va_arg (	va_alist argp,	    type ); void va_end (      va_alist argp );

PARAMETERS

       argp   Specifies  a  variable  that the varargs macros use to keep track of the current location in the parameter list.	Do not modify this
	      variable.

       type   Specifies the type to which the expected argument will be converted when passed as an argument.  Unsigned char  or  short  arguments
	      are  converted  to unsigned int, and float arguments are converted to double. Different types can be mixed, but it is up to the rou-
	      tine to know what type of argument is expected because the type cannot be determined at run time.

DESCRIPTION

       NOTE:  When writing new code, it is recommended that you use stdarg instead of varargs.	They both perform the same function, but stdarg is
       standards-compliant and varargs complies only with BSD conventions.

       The  varargs  set of macros allows you to write portable functions that accept a variable number of parameters. Subroutines that have vari-
       able-length parameter lists (such as the  printf() function), but that do not use the varargs macros, are  inherently  nonportable  because
       different systems use different parameter-passing conventions.

       The varargs macros are as follows:

       va_alist()
	      Defines the type of the variable used to traverse the list.

       va_start()
	      Initializes argp to point to the beginning of the list.  The va_start() macro will be invoked before any access to the unnamed argu-
	      ments.

       va_arg()
	      Returns the next parameter in the list pointed to by argp.

       va_end()
	      Cleans up at the end.

       Your function can traverse, or scan, the parameter list more than once. Start each traversal with a call to  va_start()	and  end  it  with
       va_end().

EXAMPLE

       The following example is a possible implementation of the execl() function:

       #include <varargs.h>
       #define MAXargS 100
       /*
       **  execl is called by
       **  execl(file, arg1, arg2, . . . , (char *) 0);
       */
       execl(va_alist)
	  va_dcl
       {  va_list ap;
	  char *file;
	  char *args[MAXargS];
	  int argno = 0;
	  va_start(ap);
	  file = va_arg(ap, char *);
	  while ((args[argno++] = va_arg(ap, char *)) != (char *) 0)
	     ;	 /* Empty loop body */
	  va_end(ap);
	  return (execv(file, args));
       }

NOTES

       The  calling  routine  is  responsible for specifying the number of parameters because it is not always possible to determine this from the
       stack frame. For example, the execl() function is passed a null pointer to signal the end of the list. The printf() function determines the
       number of parameters from its fmt parameter.

       AES Support Level: Temporary use

RELATED INFORMATION

       Functions: exec(2), printf(3), stdarg(3), vprintf(3) delim off

																	varargs(3)