FA> Is it at all possible to send  variable type and number of args to a
 FA> function, and determine the types and number of them at runtime ?

Sure, even if it means passing an arg with a counter, putting a NULL or
some other magic value at the end - whatever method you want to use to do
it, you can.

 FA> eg. void foo(char*,...);

 FA> foo("hello",10,5.6,'o');
 FA> foo(10.7,90,"Hello",'i',90,80);

 FA> This may not make any sense, but i'm curious if there
 FA> is a way of doing it.

#include 

void foo(char * fmt,...)
{
    va_list arg;

    va_start(arg, fmt);
    // .. your code, you can use va_arg(arg,) to retrieve
    // the next arg from the stack of type 
    va_end(arg);
}


 FA> If there is, how would i then check for the type ?

You have to work out a method of doing that yourself.

With the printf() family, the type is embedded into the %?'s included in
the format string.  An alternative might be to define an enumerator, and
preceed each arg with a description of its type, for example:

/* Warning: untested, unchecked code follows :-) */

#include 
#include 

enum { T_end =-1, T_int, T_ptr, T_long };

void foo(int f,...)
{
    int t;
    va_list arg;

    va_start(arg, f);
    for (t = f; t != T_end; t = va_arg(arg,int))
    {
        switch (t)
        {
            case T_int:
                {
                    int d = va_arg(arg,int);
                    printf("arg was the integer %d\n", d);
                }
                break;
            case T_long:
                {
                    long l = va_arg(arg,long);
                    printf("arg was the long %ld\n", l);
                }
                break;
            case T_ptr:
                {
                    void * p = va_arg(arg,void *);
                    printf("arg was the pointer %p\n", p);
                }
                break;
        }
    }
    va_end(arg);
}

int main()
{
    foo(T_int, 5, T_long, 3984756L, T_ptr, main, T_end);
    foo(T_long, 983985L, T_ptr, (void*)NULL, T_end);
    return 0;
}

(note the cast on NULL is just a precaution and not necessary - except, of
course, for portability - if either your compiler #define's NULL to be
(void*)0, or #define'd as 0 and sizeof(int)==sizeof(void*)).

Not great code, but it should provide a starting point.

--- MaltEd/2 1.0.b6