VARARGS(3)                                                          VARARGS(3)



NAME
       varargs - variable argument list

SYNOPSIS
       #include <varargs.h>

       _f_u_n_c_t_i_o_n(va_alist)
       va_dcl
       va_list _p_v_a_r;
       va_start(_p_v_a_r);
       f = va_arg(_p_v_a_r, _t_y_p_e);
       va_end(_p_v_a_r);

DESCRIPTION
       This set of macros provides a means of writing portable procedures that
       accept variable argument  lists.   Routines  having  variable  argument
       lists  (such  as _p_r_i_n_t_f(3)) that do not use varargs are inherently non‐
       portable, since different machines use different argument passing  con‐
       ventions.

       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 _p_v_a_r, which is
       used to traverse the list.  One such variable must always be  declared.

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

       va_arg(_p_v_a_r, _t_y_p_e) will return the next argument in the list pointed to
       by  _p_v_a_r.  _T_y_p_e is the type to which the expected argument will be con‐
       verted 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  deter‐
       mined at runtime.

       va_end(_p_v_a_r) is used to finish up.

       Multiple traversals, each bracketed by va_start ...  va_end, are possi‐
       ble.

EXAMPLE
            #include <varargs.h>
            execl(va_alist)
            va_dcl
            {
                 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);
            }

BUGS
       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, _e_x_e_c_l passes a 0 to signal the end of  the  list.   _P_r_i_n_t_f
       can tell how many arguments are supposed to be there by the format.

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



7th Edition                      May 15, 1986                       VARARGS(3)