Calling a C++ function using function pointer

Hi Mizan Rahman,
I remembered one of my friend is working exactly on the same problem.That time we used asm code to call functions with vc compiler.Though it is working fine for vc, it is not portable.After searching we found a library called libffi.This worked well for us.Take a look into that library.download the library,check the examples in .\testsuite\libffi.call folder.

BTW,the following is asm code we tried.

int fun(int a, int b, int c)
{
    int x;
    x = a + b + c;
    return 0;
}
int main()
{
    int x = 9;
    int y = 10;
    int z = 11;
    _asm
    {
        mov         eax,dword ptr [z]
        push        eax
        mov         eax,dword ptr [y]
        push        eax
        mov         eax,dword ptr [x]
        push        eax
        call        fun     //call fun(x,y,z);
        add         esp,12 //12 size of total arguments in byte
    }
    return 0;
}

If you have any doubts give reply.

-venkatanarayana

In ANSI C, it is not legal to cast between a function pointer and a data pointer.

A function pointer conveys the whole function signature with it, so passing the function pointer as a void* is just hopeless, the compiler won't be able to reconstruct an appropriate stack frame.

You'd better pass a function index (your program defines a fixed number of relevant functions) and write explicit calls, passing the corresponding parsed argument values.

Probably you should mimic (at least a subset of ) COM IDispatch functionality. The simplest solution I can imagine is

void CallFunction( void (* pFun)(Par p[], int count), std::string xmlParDef)
{
  // parse xml parameters, build the p array
   
  // call the pFun function passing p
}

where Par is a union similar to the VARIANT one.

"Should I use _asm for this? "

yes, you can see the c & asm mixed programming, following the below steps:
1. parse xml and get a parameters array (c++)
2. push the parameters (asm, c language order)
3. call the function address (asm)
4. get the return value (asm)

The asm code is based on OS environment.

Just few notes. I feel the solution of this problem is possible, but it's very hard or maybe not possible to do it in a portable way. If you use inline Assembly, it will be quite complex Assembly code, even in the case of inline Assembly where you can call any helper functions written in C++ from within Assembly code.

At this moment, I cannot imagine how it can be possible to do without Assembly, but using Assembly language will make a solution non-portable.

It hardly can be solved in few minutes or hours; in my estimate, it could take days.

This is what in terms if .NET is called System.Reflection.Emit.

First of all, you need to know XML schema in full, and the interpretation of all of the keywords: all allowed types and parameter passing methods. You also need to know calling model (C, stdcall, etc.).

You will need some internal hash table which identify each type keyword and find the reference to some class/stucture which hold the description of each type: it's size and the method of the creation of the instance of this type by its value found in XML.

The code should get all parameters one by one, find the type property, create and initialize the instance (creating references/pointers as required by the parameter passing type) and put them on stack. Where you emit a call depends on calling model. Most likely, you will need separate implementations, at list the implementation for C calling model should be separate from others.

(For a record: I really doubt this architecture of RPC (in a way, what you describe can be considered as a kind of Remote Procedure Call) is good. It's hard to implements and can incur heavy reliability and portability problems. I think even the bloated and limited SOAP-based model is better. (I would say the good one is WCF.)

However, I can imagine this is something like a stroke of a genius which I simply did not understand. :-))

—SA