DN>> enum { T_end =-1, T_int, T_ptr, T_long };
 DN>> void foo(int f,...)
 DN>> {
 DN>> int t;
 DN>> va_list arg;
 DN>> Not great code, but it should provide a starting point.

 FA> It's good, this is the best idea i've had so far :-)
 FA> But as i thought there is no way of not supplying a specifier for the
 FA> variables.

Umm, isn't that what it did?  :-)

You might have thought there was some magic available which might tell you
what was on the stack. And no, of course there isn't. The caller's stack
just bytes of data which the programmer provides a means to interpret. For
a function with fixed args, the parameters to a function and their type are
a contract between the caller and callee - and are bound statically by the
compiler and linker, at compile time. Variable length functions, however,
are a runtime concern, and the protocol used is the programmer's choice.

To simplify the previous example, you could use a "magic string"
of some sort, such as that used by *printf(). Or make it simpler again, and
say that as many args are passed as there are characters in the char array
pointed to by the first argument, that an 'i' character means an int, a 'd'
character means a double, a 's' means a char* and so on. So you'd be
looking at something like:

void foo(char const *fmt, ...)
{
  va_arg arp;
  va_start(argp,fmt);
  while (*fmt)
  {
    switch (*fmt++)
    {
    case 'i':
        {
            int i = va_arg(argp,int);
            /* ... */
        }
        break;
    case 's':
    /* and so on... */
    }
    
  }
  va_end(argp);
}

Anyway, the possibilities and permutations are endless. You invent the
contract on a "as needed" basis.

Actually, I've usually had very little need to create variable length
functions, and when I have it is almost always as an interface to
v?printf(), to take advantage of its formatting capabilities for special
I/O purposes.


 FA> Actually i never did look at pointer's sizes before,and i always thought
 FA> that the size of the pointer would be an indicator to the type.

Nope. In fact, C does not provide very much about the size of any
particular pointer at all, and the only requirement is that a void* be
large enough to hold a pointer to any type (to allow it to be cast back and
forth). In most implementations, a pointer to any object is the same size
as a pointer to any other object, but code that relies on that is not
"strictly conforming".

--- MaltEd/2 1.0.b6