calling a function without knowing the number of parameters in advance

Question

Suppose I have a dll with 2 functions.name of dll="dll1" f1(int a, int b, int c);

f2(int a);

My program would take the function name ,the dll name and a "list" of parameters as input. how would i call the appropriate function with its appropriate parameters. i.e, if input is dll1 f1 list(5,8,9)

this would require me to call f1 with 3 parameters if input was dll1 f2 list(8) it would require me to call f2 with one parameter how would i call the function without knowing the number of parameters in advance.

further clarification: how do I write code that will call any function with all its arguments by building the argument list dynamically using some other source of information

Answer 1

Since the generated code differs based on the number of parameters, you have two choices: you can write some code in assembly language to do the job (basically walk through the parameter list and push each on the stack before calling the function), or you can create something like an array of pointers to functions, one for each number of parameters you care about (e.g., 0 through 10). Most people find the latter a lot simpler to deal with (if only because it avoids using assembly language at all).

Answer 2

To solve the problem in general you need to know:

1. The calling conventions (those stdcall, cdecl, fastcall, thiscall (btw, the latter two can be combined in MSVC++), etc things) that govern how the functions receive their parameters (e.g. in special registers, on the stack, both), how they return values (same) and what they are allowed to trash (e.g. some registers).
2. Exact function prototypes.

You can find all this only in the symbol/debug information produced by the compiler and (likely to a lesser extent) the header file containing the prototypes for the functions in the DLL. There's one problem with the header file. If it doesn't specify the calling convention and the functions have been compiled with non-default calling conventions (via a compiler option), you have ambiguity to deal with. In either case you'll need to parse something.

If you don't have this information, the only option left is reverse engineering of the DLL and/or its user(s).

In order to correctly invoke an arbitrary function only knowing its prototype and calling convention at run time you need to construct code analogous to that produced by the compiler when calling this function when it's known at compile time. If you're solving the general problem, you'll need some assembly code here, not necessarily hand-written, run-time generated machine code is a good option.

Last but not least, you need some code to generate parameter values. This is most trivial with numeric types (ints, floats and the like) and arrays of them and most difficult with structures, unions and classes. Creating the latter on the fly may be at least as difficult as properly invoking functions. Don't forget that they may refer to other objects using pointers and references.

The general problem is solvable, but not cheaply. It's far easier to solve a few simple specific cases and maybe avoid the entire problem altogether by rewriting the functions to have less-variable parameters and only one calling convention OR by writing wrapper functions to do that.

Answer 3

If your clients know at compile-time, then can wrap it this way:

template<class Args...>
void CallFunctionPointer(void* pf, Args&&... args)
{
    typedef void(*FunctionType)(Args...);
    FunctionType* pf2 = (FunctionType*) pf;
    (*pf2)(forward<Args>(args)...);
}

Note, if you pass the wrong number of paramters or the wrong type(s) of parameters behaviour is undefined.

Background:

In C/C++ you can cast a function pointer to any signature you want, however if you get it wrong behavior is undefined.

In your case there are two signatures you have mentioned:

void (*)(int)

and

void (*)(int, int, int)

When you load the function from the DLL it is your responsibility to make sure you cast it to the correct signature, with the correct number and types of parameters before you call it.

If you have control over the design of these functions, I would modify them to take a variable number of arguments. It the base type is always int, than just change the signature of all the functions to:

void (*)(int* begin, size_t n);
// begin points to an array of int of n elements

so that you can safely bind any of the functions to any number of arguments.

Answer 4

You might want to check out the Named Parameter Idiom.

It uses method chaining to basically accomplish what you want.

It solves the problem where you know what a default set of arguments look like, but you only need to customize a few of them and not necessarily in the order they are declared.