Click above to get retro games delivered to your door ever month!

 va_arg()                Access Variable Number of Arguments, ANSI C Style

 #include   <stdarg.h>                   Required for compatibility with ANSI
                                         C standard

 void       va_start(arg_ptr,prev_param); Set 'arg_ptr' to beginning of list
 va_list    arg_ptr;                      Pointer to list of arguments
 type       prev_param;                   Parameter preceding first optional
                                          argument

 type       va_arg(arg_ptr,type);        Retrieve current argument from list
 va_list    arg_ptr;                     Pointer to list of arguments
 type                                    Type of argument to be retrieved

 void       va_end(arg_ptr);             Reset 'arg_ptr'
 va_list    arg_ptr;                     Pointer to list of arguments

    va_start(), va_arg(), and va_end() are macros that, when used
    together, provide a way to access the arguments to a function when
    the number of arguments is variable.  These macros work by setting a
    pointer to the beginning of the optional argument list, retrieving
    the arguments from the list, and resetting the pointer when the
    arguments have been processed.

    If the function takes a fixed number of arguments, those are declared
    as parameters and accessed through the parameter names. The last, or
    only, parameter to the function represents the list of optional
    arguments.

  va_start()    va_start() must be used before va_arg() is used for the
                first time.  Within the function, va_start() sets the
                pointer 'arg_ptr' to the beginning of the variable
                argument list.  ('arg_ptr' must be of type 'va_list'.)
                'prev_param' is the name of the required parameter that
                appears immediately before the first optional argument.

    va_arg()    retrieves a value of given 'type' from the location given
                by 'arg_ptr' and increments 'arg_ptr' to the next
                argument in the list.  It uses the size of 'type' to
                determine where the next argument begins.  va_arg() can
                be called as many times as necessary to retrieve all the
                values in the list.

    va_end()    resets the pointer to the list of arguments to NULL. It
                is called after va_arg() has retrieved all the values.
                va_end() is used to provide a normal return from the
                function and to avoid possible undefined behavior.

    Returns:    va_arg() returns the current argument.  va_start() and
                va_end() do not return values.

      Notes:    There is another version of the va_...() macros.  Those
                macros are defined in <varargs.h> and are compatible with
                UNIX V.

   -------------------------------- Example ---------------------------------

    The following statements add variable lists of integers.

           #include <stdarg.h>
           #include <stdio.h>

           int totl, totltoo;

           main()
           {
               totl = sum(50,100,25,200,1000,0);
               printf("subtotal: %d\n",totl);
               totltoo = sum(totl,75,15,0);
               printf("total: %d\n",totltoo);
           }

           sum(first);
           int first;
           {
              va_list arg_ptr;
              int x, subt;

              subt = first;
              va_start(arg_ptr,first);
              while ((x = va_arg(arg_ptr,int)) > 0)
                   subt += x;
              va_end(arc_ptr);
              return(subt);
           }