Index for Section 3

Alphabetical listing for V

Bottom of page

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 routine 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
  variable-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
       arguments.

  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)

Index for Section 3

Alphabetical listing for V

Top of page