I think the short answer is no. As far as I know, there is no way in C to dynamically control the call stack. You may need to build your own argument list into a structure that can be dynamically composed by the caller and decomposed by the callee. Then, to all your "dynamic" functions, you pass the structure as a single argument.

The only way to use var-args, IMO, would be to know ahead of time the set of argument lists that you can support. You would have to limit the number of items in the set to something manageable by a switch statement. So, for example, if you have 40 procedures and the unique set of argument lists is [ (string), (string, int), (int, int), (string, string, string) ] then you have four different argument lists in the set and you can use a single four item switch statement to make the call after selecting the right function pointer.

However, if you can't limit the number of different argument lists, and you need a generic caller, then things get hairy quickly. No matter what, you have to at least limit the number of types and argument counts you can support. But, the combinations of types and counts quickly increases the number of items in the set that must be supported by the switch statement.

In fact, in the case where you allow (string, int, long) in either 1, 2, or 3 arguments you can have 3+9+27 = 39 different possible argument lists in the set. Make it 1, 2, 3, or 4 arguments it goes up to 120. Make it four different types and four lengths and you will have such a large set you won't want to write the switch statement to manage it; it'll have 4+16+64+256 = 340 switch cases.

As you can see, to make a generic caller in the above cases would get cumbersome.

Quickly, back to the "generic thrower" comment. You must realize that when a function is compiled (in this case your generic thrower function) the compiler configures a stack frame that is large enough to store arguments for the functions called by the "generic thrower". While you could manipulate that stack frame (in an architecture specific way) during runtime to call a function with any arguments you want, the compiler is still in control of the size of the stack frame. Too many, or too large, arguments and you'll overrun the frame and corrupt memory. If you could force the compiler to create a larger than normal stack frame so you'll "never" overrun it then you may be able to read up on how your architecture composes its stack frames to place the arguments into the frame and make a call (with no arguments) to the function and hope what you tweaked into the stack frame sticks around for the function to pick up. But, this won't be pretty code, and it won't be guaranteed to be compatible across different systems.

On more note, I'm not sure all architectures store the arguments for the called function in the frame of the caller. However, I know AIX does. If yours does not, then you're in even bigger trouble because then you need to figure out how to allocate a stack frame yourself, put all the arguments in it, and fire off the call. All of this is, also, architecture specific. And to code it, you're probably looking at dipping into ASM.