NAME    [Toc]    [Back]

       stdarg - Handle a variable-length parameter list

SYNOPSIS    [Toc]    [Back]

       #include <stdarg.h>

       va_list

       void va_start(
               va_list argp,
               parmN ); type va_arg(
               va_list argp,
               type ); void va_end(
               va_list argp );

LIBRARY    [Toc]    [Back]

       Standard C Library (libc)

PARAMETERS    [Toc]    [Back]

       Specifies  a  variable that the stdarg macros  use to keep
       track of the current location in the parameter  list.   Do
       not modify this variable.  Specifies the last named parameter
 (the one just before the  "..." in the execl()  definition
  in  the  Example section).  There must be at least
       one named parameter.  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    [Toc]    [Back]

       The stdarg 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
       stdarg macros, are inherently nonportable because  different
  systems use  different parameter-passing conventions.

       The stdarg macros are as follows: Defines the type of  the
       variable  used  to traverse the list.  Initializes argp to
       point to the first unnamed argument.  The va_start() macro
       will  be  invoked  before any access  to the unnamed arguments.
  Returns the next parameter in the list pointed  to
       by argp.  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().

NOTES    [Toc]    [Back]

       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

EXAMPLE    [Toc]    [Back]

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

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

SEE ALSO    [Toc]    [Back]

       Functions: exec(2), printf(3), varargs(3), vprintf(3)



                                                        stdarg(3)