Standard way to manipulate variadic arguments?

Question

This is a weird question, but is there a standard way to manipulate the contents of a va_list before passing it to another function? For instance, suppose I have two functions, sum and vsum:

int vsum(int n, va_list ap) { int total = 0; for (int i = 0; i < n; ++i) { total += va_arg(n, int); return total; } int sum(int n, ...) { va_list ap; va_start(ap, n); int total = vsum(n, ap); va_end(ap); return total; }

If I call sum as sum(4, 1, 2, 3, 4), I expect to get the result 10. Now let's suppose that instead of calling vsum directly, sum calls an intermediate function, vsum_stub which does the following:

int vsum_stub(int n, va_list ap) { va_list temp_ap; va_copy(temp_ap, ap); for (int i = 0; i < n; ++i) { int *arg = &va_arg(ap, int); *arg += 2; } va_end(temp_ap); return vsum(n, ap); }

Now when I call sum(4, 1, 2, 3, 4), I should get back the result 20, since vsum_stub increments all of the values in the va_list by 2. This doesn't compile of course since you can't take the address of the result of va_arg. Is there another way to do this though? I'm working in C99.

Background:

I'm working on a library that does some pointer translation so that data may be stored on the heap in a more efficient format. Programs are compiled with a custom transformation which converts calls to library functions like printf to my own stub functions (e.g., hc_printf). hc_printf needs to translate any pointer arguments (strings intended for %s) before passing the arguments to the real printf function.

Edit: Here's a code example. Let's say we have a string foo. foo is dynamically allocated with a modified version of malloc which returns a fake pointer. The compiler modifies the program so that it can deal with fake pointers. So this works:

char *foo = fake_malloc(4); fake_strcpy(foo, "foo");

I want to write a fake_vprintf function like this (in pseudocode):

int fake_vprintf(const char *format, va_list args) { for each pointer argument p in args translate p to q, a real pointer to contiguous memory replace p with q in args } return vprintf(format, args); }

The program would call fake_vprintf just like the original vprintf using the fake pointer. fake_vprintf translates the fake pointer to a real pointer that the real vprintf can use.

Shouldn't int *arg = &va_arg(ap, int); actually be int *arg = va_arg(ap, int *);? — dirkgently
– dirkgently, Commented Feb 5, 2010 at 21:06
@dirkgently, no, the actual parameter inside the argument list is an int. My intent in that example was to get a pointer to that int inside the list so I could change its value. — Jay Conrod
– Jay Conrod, Commented Feb 5, 2010 at 21:11
I'd assumed that the vsum_stub takes in a list of int *. Anyway do you think the code I posted is of any help? — dirkgently
– dirkgently, Commented Feb 5, 2010 at 21:14

dirkgently · Accepted Answer · 2010-02-05 21:58:22Z

Aha, as I understand, your problem is creating a new va_list argument to pass on to the standard vprintf functions. Which in turn, will require you to modify each member of the list. However, since there is no element wise fetch/edit/insert operation for such a list you are stuck.

I don't really see any way of doing this. Of course, you can create a vprintf apply the transformations in situ, one argument at a time. My suggestion will be: Reimplement all such standard library functions -- at any rate you are writing wrappers. This involves some work, but you are already doing a part of it with hc_printf etc, so why not go the whole distance (and guess what save on a function call!).

Reimplementing vprintf and friends is probably the most correct solution. I was hoping there was some way to modify values in the va_list with va_arg, but I guess such a thing is not possible. I'll probably have to decide whether it is better to reimplement vprintf and friends or to have some platform-specific solution for each platform.

tomlogic · Accepted Answer · 2010-02-05 22:01:00Z

You probably can't use va_list in a platform-agnostic way. You'll have to look at how your environment defines a va_list in stdarg.h, and then write your own tools to work with it.

For example, if a va_list is just a (char *), you can do all sorts of things with it.

// add 1000 to the integer stored on the stack and advance va_list *(int *)va_list += 1000; va_list += sizeof(int);

You're telling the compiler that you want it to consider va_list a pointer to an int (via the int * cast), then take the value (*) and add 1000 to it (+= 1000). Now advance the va_list pointer to the next argument on the stack.

This is what I'm currently using, so +1 for that. It works for x86-32 in Linux. However, I will eventually need to port this code to ARM and x86-64, and I believe both of those architectures pass arguments in registers, which may make this approach much more complicated.

Collectives™ on Stack Overflow

Standard way to manipulate variadic arguments?

2 Answers 2

1 Comment

1 Comment

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

1 Comment

Linked

Related