Very Computer

Hi,

I have a function which has a variable number of arguments. So I use
stdarg.h and va_start, va_arg and va_end to access the arguments. This works
fine. The problem is that I need a wrapper around this function. So this
function also makes use of va_start, va_arg and va_end.

So now comes the hard part (for me), I need to pass all the arguments to the
function call of the original function. In my enthousiasm I wirst did it
like this:

wrapper(int ref, ...)
{
  va_list ap;
  va_start(ap, ref);

  orig_function(ref, &va_arg(ap));

  va_end(ap);

Quote:}

of course this doesn't work because I then pass the address of the first
argument to the wrapper as an argument to the original function. But the
original function expects the data itself. So my problem is how do I get the
actual data to be copied to the right way. I was thinking of memcpy some
stuff, but I don't know what I should memcpy, and I think it will not be
portable at all. And it would be nice if there is a portable solution for
this.

I could use an array as an argument which contains the data in stead of
using variable arguments, but that is not what I want. It is very anoying to
put all your arguments in an array before you can call your function.

Does anybody has a solution for this?

Thanks,
  Mark

Yes, don't use the orig_function, but rather the v variant
of the function. So if the orig_function was sprintf, you
should instead use vsprintf. If there is not implemented a
v variant of the orig_function, then you have a problem.
You might be able to use a gcc extension instead in that
case, but I'm not sure how well it is going to work. Check
the gcc info pages under C Extensions Constructing Calls.

--
Kasper Dupont -- der bruger for meget tid p? usenet.

for(_=52;_;(_%5)||(_/=5),(_%5)&&(_-=2))putchar(_);

 - Built-in Function: void * __builtin_apply (void (*FUNCTION)(), void
          *ARGUMENTS, size_t SIZE)
     This built-in function invokes FUNCTION with a copy of the
     parameters described by ARGUMENTS and SIZE.

     The value of ARGUMENTS should be the value returned by
     `__builtin_apply_args'.  The argument SIZE specifies the size of
     the stack argument data, in bytes.

     This function returns a pointer to data describing how to return
     whatever value was returned by FUNCTION.  The data is saved in a
     block of memory allocated on the stack.

     It is not always simple to compute the proper value for SIZE.  The
     value is used by `__builtin_apply' to compute the amount of data
     that should be pushed on the stack and copied from the incoming
     argument area.

This last paragraph indicates some trouble.  I also wonder how this
works with machines (e.g. Alpha) where arguments are passed in
registers.

Anyhow, I made a little test program.

---CUT---
#include <stdio.h>

int
wrap_printf(char *fmt, ...)
{
    void *args, *ret;

    args = __builtin_apply_args();
    ret = __builtin_apply(printf, args, 12);
    __builtin_return(ret);

Quote:}

int main(int argc, char **argv)
{
    wrap_printf("%s %i\n", "foo", 17);
    return 0;

Quote:}

---CUT---

It looks like the size argument to __builtin_apply should be
4+4*(#-of-args) for ia32 machines.  This seems sensible.

--
M?ns Rullg?rd