The set of functions and macros defined and declared in the
  <varargs.h> and the <stdarg.h> header files provide a method of
  accessing variable-length argument lists.  (Note that the
  <stdarg.h> functions are defined by the ANSI C standard and are,
  therefore, portable as compared with those defined in <varargs.h>.)

  The VSI C RTL functions such as printf and execl, for example, use
  variable-length argument lists.  User-defined functions with
  variable-length argument lists that do not use <varargs.h> or
  <stdarg.h> are not portable due to the different argument-passing
  conventions of various machines.

  To use these functions and macros in <stdarg.h>, you must include
  the <stdarg.h> header file with the following preprocessor
  directive:

       #include <stdarg.h>

  The <stdarg.h> header file declares a type (va_list) and three
  macros (va_start, va_arg, and va_end) for advancing through a list
  of function arguments of varying number and type.  The macros have
  the following syntax:

       void va_start(va_list ap, parmN);

       type va_arg(va_list ap, type);

       void va_end(va_list ap);

  The va_start macro initializes the object ap of type va_list for
  subsequent use by va_arg and va_end.  The va_start macro must be
  invoked before any access to the unnamed arguments.  The parameter
  parmN is the identifier of the rightmost parameter in the variable
  parameter list of the function definition.  If parmN is declared
  with the register storage class, with a function or array type, or
  with a type that is not compatible with the type that results after
  application of the default arguments promotions, the behavior is
  undefined.  The va_start macro returns no value.

  The va_arg macro expands to an expresion that has the type and
  value of the next argument in the call.  The parameter ap is the
  same as the one initialized by va_start.  Each invocation of va_arg
  modifies ap so that the values of successive arguments are returned
  in turn.  The parameter "type" is a type name specified such that
  the type of a pointer to an object that has the specified type can
  be obtained by postfixing an asterisk (*) to "type".  If there is
  no actual next argument, or if type is not compatible with the type
  of the next actual argument (as promoted according to the default
  argument promotions), the behavior is undefined.  The first
  invocation of va_arg after that of va_start returns the value of
  the argument after that specified by parmN.  Successive invocations
  return the values of the remaining arguments in turn.

  The va_end macro facilitates a normal return from the function
  whose variable argument list was referred to by the expansion of
  va_start that initialized the va_list ap object.  The va_end macro
  can modify ap) so that it can no longer be used (without an
  intervening invocation of va_start).  If there is no corresponding
  invocation of va_start or if va_end is not invoked before the
  return, the behavior is undefined.  The va_end macro returns no
  value.