运行时动态函数调用(Runtime Dynamic Invoke)

nicolas.shen

window版没人气，发到这里吧，思想都是一样的，不过没有linux下的实现，有兴趣的试试看吧。
这阵子对动态解析比较感兴趣，对于动态解释型语言来说，这毫无研究的必要，但对于编译型的语言(主要讨论C/C++),凭着本人目前的水平，还无法想出办法。想法是很简单的，例如，类似这样的win32函数 BOOL Beep(int dwFreq,int dwDuration),静态调用就不说了，动态调用的话，先是加载函数库，然后取得Beep函数的地址，然后去invoke,但是，在编译期,必须显式地给出Beep的函数指针原型才能通过编译，因此，如果想偷懒, 不想给出原型以期达到广泛应用的话，至少现在微软提供的工具是没办法让你编译过的，那么怎么办呢?  比如我就想通过输入 函数名,参数1,参数1类型,参数2,参数2类型...这样的字符串，然后我就优哉游哉的让程序自己去调用我想调用的函数，那怎么办呢？
我们可以思考下微软自己是怎么实现动态链接和加载的呢,首先是加载库，然后取得函数地址，既然我们能得到函数的地址了，那我们就直接call呗，嗯还得传参，这够麻烦的了，如果不传参的话，就没这么难了。没关系，我们看看函数的调用规则吧，压栈基址指针，基址指向栈顶，参数进栈，调用，保存返回值，栈顶指向基址，出栈基址指针。那么，我们自己不也可以模拟下这个过程么？嗯，那就试试看吧
源码如下（win32下的console程序,vs2008下,vc++9.0 编译运行）
#include <stdio.h>
#include <Windows.h>
int main()
{
//加载函数库
HMODULE hMod = LoadLibraryA("Kernel32.dll");
//取得函数地址
FARPROC pfAddr = GetProcAddress(hMod,"Beep");
DWORD nRet ;//返回值
DWORD dwFreq = 750; //频率
DWORD dwDuration = 300;//持续时间
__asm
{
  //注意调用方式，这是stdcall
  push dwDuration//参数压栈,持续时间300毫秒
  push dwFreq //继续压,频率
  //...直到参数全部入栈
  call pfAddr //开始调用   
  mov nRet,eax //取得回值  
}
printf("%d",nRet);//输出返回值
//释放函数库
FreeLibrary(hMod);
return 0;
}
凭着"半拉可及"(俺们东北话)的知识,这个程序居然跑起来了，还不错，嗯，不过还得继续，因为我们忽略了我们想达到的目的中的一些细节，例如传参也要动态的，不光是函数名，还有类型，不能光是int吧？不过这是个好的开端，因为内嵌的汇编可以做循环嘛，可以实现循环的压栈(根据参数个数), 也可以根据参数类型选择相应的操作指令

langue

能直接描述你的问题么

maxxfire

有了函数指针，还怕不能动态调用么？

syncpk99

可以看看这个网站，有完整的解决方案。
http://www.dyncall.org/

nicolas.shen

原帖由 syncpk99 于 2009-9-7 09:37 发表
可以看看这个网站，有完整的解决方案。
http://www.dyncall.org/

嗯，多谢各位，我看了一下，很好，的确是我想要的

blairzhong

原帖由 syncpk99 于 2009-9-7 09:37 发表
可以看看这个网站，有完整的解决方案。
http://www.dyncall.org/

谢谢，这个网站不错，比起我们必须事先获得参数好多了

OwnWaterloo

这库够牛叉的……


要动态（编译后）解析一个运行时得到（比如字符串格式）的函数调用，如：
f(a1,a2, ... an);

比较难处理的是如何传递"数量未知"的参数。

详细一点的说， 假设， 解释器实现了：

1. 从脚本中得到一个表示调用的字符串

1. 
   
2. const char* call_string = script_get_a_call_at_runtime();
   

复制代码

2. 从该字符串中得到函数名、函数返回类型、各个参数、以及它们的类型：

1. 
   
2. void* f           = script_parse_function_name(call_string);
   
3. 
   
4. typedef struct value
   
5. {
   
6.     int t;
   
7.     union {
   
8.         char   c;
   
9.         int    i;
   
10.         double d;
    
11.         /* more */
    
12.     } v;
    
13. } value;
    
14. 
    
15. value return_value;
    
16. 
    
17. return_value.t = script_parse_function_return_type(call_string);
    
18. 
    
19. int count   = 0;
    
20. value* args = script_parse_arguments(call_string,&count);
    

复制代码

如何将args[0], args[1], ... args[count-1], 传递给f？

stdarg.h 帮不上忙的。 它只能取出"数量未知"的参数， 而不是传入。
传入参数的时候， 数量依然在编译时就被固定， 如：
printf("%s %s\n","hello","world"); /* 2个，编译后固定 */


dyncall的处理方式：
1. 抽象出一个参数列表模型， 它被dyncall称为DCCallVM。称为VM有点过头了……

1. 
   
2. DCCallVM* vm = dcNewCallVM(4096);
   

复制代码

2. 每次只传入1个参数：

1. 
   
2. dcArgXXX(vm, arg); /* XXX代表传入参数类型 */
   

复制代码

这是一个重点。 每次只压入1个参数， 就可以组合出传递多个参数 —— 只要重复调用压入参数的函数即可， 如：

1. 
   
2. for (int i = 0; i< count; ++i ) {
   
3.     switch (args[ i ].t) {
   
4.     case TYPE_DOUBLE: dcArgDouble(vm, args[ i ].v.d); break;
   
5.     case TYPE_INT   : dcArgInt   (vm, args[ i ].v.i); break;
   
6.     /* more */
   
7.     }
   
8. }
   

复制代码

3. 抽象出一个调用模型， 它在dyncall中是dcCallXXX（XXX代表返回类型）。
重点之一： dcCallXXX 现在是拥有固定数目参数的函数(VM、function)。 数目未知的参数已被VM代替。

1. 
   
2. switch( return_value.t. ) {
   
3. case TYPE_INT   : return_value.v.i = dcCallInt(vm,(DCpointer)f); break;
   
4. case TYPE_DOUBLE: return_value.v.d = dcCallDouble(vm,(DCpointer)f); break;
   
5. /* more */
   
6. }
   

复制代码

现在， 已经可以使用"编译时数目实际参数固定的函数调用"， 表达数目未知的函数调用了。


重点之二： 也是该库牛逼的地方……
它直接使用了native assembly code来实现这个调用模型……
将vm中的参数们依次提取， 并合理（依平台、调用约定而定）的传递， 然后调用。

这样做比较麻烦的地方就是移植性。 该库好像也仅支持x86和ppc， 还要兼顾OS和编译器组合。
体力活啊……

这样做的优势在于：
只要写好解释器与dyncall交互的代码， 就可以"直接"调用任意函数（dyncall还提供了load模块，这不是重点，实现不难）了。
说任意函数， 依然有一些限制 —— 参数只能是buildin-type， 不能是aggregates (structures, unions and classes)。
dyncall是可以支持指针参数的。 指针参数的麻烦之处不在dyncall上， 而在解释器如何实现。


说它直接， 是相对于另外一种方式 —— 一种可移植的方式， 但被调用的函数需要包装一下。
比如lua， 就是采用的这种方式。




要在lua中调用一个C函数， 前面的步骤都是类似的：

1. lua抽象出一个参数模型。（lua具体是怎么做的忘了， 所以下面伪得不能再伪的代码）
lua的参数模型不仅仅包括参数、还包括返回值。被称为一个stack。

2. 向stack传入和取出参数的API， 都只有固定个参数， 这样在编译时才能写出这个API调用。

1. 
   
2. LuaStack* stack = luaStack_new();
   
3. for (int i = 0;i < count; ++i )
   
4.     luaStack_set(stack, args[ i ] ); /* 并不是一个严格的栈 */
   

复制代码

3. lua的调用模型， 是使用C实现的。 所以它必须是一个参数数目固定的API —— 至少调用时，参数个数是固定的。

1. 
   
2. luaCall( f, stack );  /* [b]可以编译[/b] */
   
3. [code]
   
4. 
   
5. btw: lua解释器中， 函数调用完毕时， 还可以从stack中取出（多个）返回值。
   
6. 
   
7. 所以， 这个f绝对不能是Beep， 需要包装一次。
   
8. 这一次包装， 就把[b]参数列表的解析的工作留给了用户[/b]。[b] lua就不用写不可移植的代码[/b]。
   
9. 
   
10. 用户就必须为每一个需要在lua中调用的函数， 实现一个参数数目固定的包装函数。
    
11. 这函数签名我还记得 —— typedef int (*lua_CFunction)(lua_State* );
    
12. 
    
13. [code]
    
14. int BeepWrapper(lua_State* lua) {
    
15. /*
    
16.     从lua_State中取得参数（上面说的stack包含在lua_State中）。
    
17.     这样就将数目未知的参数，通过lua_State一个参数表达出来。 这里需要取2个。
    
18.     然后， 调用真正的Beep。
    
19.     以及， 将返回值放回stack。 返回返回值的个数。
    
20. */
    
21. }
    

复制代码

还需要向lua注册这个BeepWrapper， 使得解释器可以找到f， 也就是上面的伪代码：

1. 
   
2. lua_CFunction f = script_parse_function_name(call_string);
   

复制代码

综上：
它们都是抽象出一个参数列表模型， 来将数目未知的参数转换为数目固定的参数。
实现调用时， dyncall直接使用native assembly code， 无须包装、注册； 但需要为不同平台编写不同代码。
而lua将实现调用的工作， 转交给用户。 每一个要在lua中调用的C函数都需要实现一个包装函数，并注册。
但lua、以及用户代码中就不容易出现平台相关代码。

[ 本帖最后由 OwnWaterloo 于 2009-9-8 01:52 编辑 ]

syncpk99

楼上也够牛X的，找到这个库N久了，就是一眼也没看过啊

nicolas.shen

嗯的确有不少体力活，真是佩服啊

群雄逐鹿

好像想到个用纯C++实现的办法
验证一下再来回复