NAME    [Toc]    [Back]

       varargs,  va_arg,  va_start,  va_end  - Handle a variablelength
 parameter list

SYNOPSIS    [Toc]    [Back]

       #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 );

LIBRARY    [Toc]    [Back]

       Standard C Library (libc)

PARAMETERS    [Toc]    [Back]

       Specifies a variable that the varargs macros use  to  keep
       track  of  the  current location in the parameter list. Do
       not modify this variable.  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]

       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:  Initializes  argp  to
       point  to  the beginning of the list. 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().  Is used in the function
  header  to declare a variable argument list.  va_dcl
       is a declaration for va_dcl. Note that there is  no  semicolon
 after va_dcl.

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 <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)); }

SEE ALSO    [Toc]    [Back]

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



                                                       varargs(3)