VARARGS(5)							    VARARGS(5)

NAME    [Toc]    [Back]

     varargs - variable	argument list

SYNOPSIS    [Toc]    [Back]

     #include <varargs.h>

     function(va_alist)
     va_dcl
     va_list pvar;
     va_start(pvar);
     f = va_arg(pvar, type);
     va_end(pvar);

DESCRIPTION    [Toc]    [Back]

     This set of macros	provides a means of writing portable procedures	that
     accept variable argument lists.  Routines having variable argument	lists
     (such as printf(3)) that do not use varargs are inherently	nonportable,
     since different machines use different argument passing conventions.

     PLEASE NOTE: varargs is being supplanted by stdarg(5). Users should
     reference that man	page for the recommended method	of passing variable
     argument lists.

     va_alist is used in a function header to declare a	variable argument
     list.

     va_dcl is a declaration for va_alist.  Note that there is no semicolon
     after va_dcl.

     va_list is	a type which can be used for the variable pvar,	which is used
     to	traverse the list.  One	such variable must always be declared.

     va_start(pvar) is called to initialize pvar to the	beginning of the list.

     va_arg(pvar, type)	will return the	next argument in the list pointed to
     by	pvar.  Type is the type	to which the expected argument will be
     converted when passed as an argument.  In standard	C, arguments that are
     char or short should be accessed as int, unsigned char or unsigned	short
     are converted to unsigned int, and	float arguments	are converted to
     double.  Different	types can be mixed, but	it is up to the	routine	to
     know what type of argument	is expected, since it cannot be	determined at
     runtime.

     va_end(pvar) is used to finish up.

     Multiple traversals, each bracketed by va_start ...  va_end, are
     possible.

EXAMPLE    [Toc]    [Back]

	  #include <varargs.h>
	  execl(va_alist)
	  va_dcl



									Page 1






VARARGS(5)							    VARARGS(5)



	 {
	       va_list ap;
	       char *file;
	       char *args[100];
	       int argno = 0;

	       va_start(ap);
	       file = va_arg(ap, char *);
	       while (args[argno++] = va_arg(ap, char *))
		    ;
	       va_end(ap);
	       return execv(file, args);
	  }

SEE ALSO    [Toc]    [Back]

     stdarg(5)

BUGS    [Toc]    [Back]

     It	is up to the calling routine to	determine how many arguments there
     are, since	it is not possible to determine	this from the stack frame.
     For example, execl	passes a 0 to signal the end of	the list.  Printf can
     tell how many arguments are supposed to be	there by the format.

     The macros	va_start and va_end may	be arbitrarily complex;	for example,
     va_start might contain an opening brace, which is closed by a matching
     brace in va_end.  Thus, they should only be used where they could be
     placed within a single complex statement.


									PPPPaaaaggggeeee 2222