实现自己的LUA绑定器-一个模板编程挑战

Preface

    当LUA脚本调用我们注册的C函数时，我们需要逐个地从LUA栈里取出调用参数，当函数返回时，又需要一个一个地往LUA

栈压入返回值，并且我们注册的函数只能是int()(lua_State*)类型。这很不方便，对于上层程序员来说更不方便。

    因此我们要做的是，实现一个绑定器，可以把任意prototype的函数绑定到LUA脚本当中，并且封装取参数和压返回值时

的诸多细节。

    确实，世界上已经有很多库做了这件事情。但是，我们这里的需求很简单，我们只需要绑定函数，而不需要绑定C++类之

类的东西，自己实现的才是轻量级的。

What we usually do

    先看下我们平时是怎么做这些事的。首先注册函数很简单：


    lua_pushcfunction( L, to_string );


    lua_setglobal( L, "tostr" );



    然后是func的具体处理：


    /**
假设to_string在脚本中的原型是: string ()( number ) */


    static int to_string(
lua_State *L )


    {


        static char buf[512];


        /* 从LUA栈中取参数 */


        int n = (int)lua_tonumber(
L, -1 );


        sprintf( buf, "%d", n );


        /* 压入返回值 */


        lua_pushstring( L, buf );


        return 1;


    }



    这是个简单的例子，目的是展示我之前说的局限性，以及，恩，丑陋性。

How

    要让事情变得优美，我们就得隐藏丑陋。

    首先，我们看看如何改进to_string的处理，使其看起来干净。最直接也是最通用的做法是，我们自己做一个粘合层，

充当LUA与应用层之间的粘合剂。也就是说，LUA直接回调的不再直接是应用层的函数，而是我们实现的这一层中的函数，

我们的函数整理调用参数，然后回调到上层函数，上层返回后，我们收集上层的返回值，然后整理给LUA，最后返回。

    这就是思路，具体实现时更为有趣。

Implementing...

    直觉告诉我，我需要使用C++模板来实现。模板和宏都是个好东西，因为它们是泛性的，它们给程序员带来自动性。

    另一个直觉告诉我，尽量不要让上层保存任何东西。通过模板的实例化，编译器已经为我们添加了很多东西，我也不

想让上层理会我太多。

    因为，我们至少需要保存上层的函数指针（我们暂时只考虑C式的函数），我们至少还需要一个粘合层函数用以被LUA

直接回调，所以，我得到了以下类模板：


    template <typename Prototype>


    class lua_binder


    {


    public:


        typedef Prototype func_type;


    public:


        static int adapter( lua_State *L
)


        {


            return 0;


        } 




    public:


        static func_type _func;


    };


    template <typename Prototype> typename lua_binder<Prototype>::func_type lua_binder<Prototype>::_func = 0;



    这样，泛化了Prototype后，lua_binder可以保存任意原型的函数指针。例如：

 


 typedef lua_binder<const char*(int)> binder_type;



   

    借助于模板技术，即使上层只是这样一个简单的看似不会产生任何代码的typedef，实际上也会产生出一个static的

函数指针变量：_func。

    这个时候，我们也该考虑下注册函数部分了。注意，事实上我们总共需要干两件事：封装粘合层函数、封装注册函数

部分。同样，我们得到一个最直观的注册函数模板：

 


    template <typename binder_type>


    void lua_bind( lua_State *L, typename binder_type::func_type
func, const char *name )


    {


        binder_type::_func = func;


        lua_pushcfunction( L, binder_type::adapter );


        lua_setgloabl( L, name );


    }

    为什么模板参数是binder_type而不是Prototype？（最直接的想法可能会想到Prototype）因为我们需要获取func_type

以及最重要的：设置_func的值！综合起来，lua_bind函数主要作用就是接受用户层函数指针，并相应的将粘合层函数注册

到LUA中。注意，lua_pushcfunction注册的是binder_type::adapter函数。

    那么，理论上，我们现在可以这样注册一个函数：


    typedef lua_binder<const char*(_cdecl*)(int)> binder_type;


    lua_bind<binder_type>( L, to_string, "tostr" ); 



    （这个时候to_string为：const char* to_string( int ) )

处理函数参数的个数

    事情远没有我们想象的那么简单。adapter函数中毫无实现，重要的是，该如何去实现？我们面对的首个问题是：上层

函
141e6
数参数个数不一样，那么我们的adapter该调用多少次lua_to*去从LUA栈中获取参数？

    解决该问题的办法是，恩，很笨，但是这可以工作：为不同参数个数的函数都实现一个对应的adapter。没有参数的函数对

应一个adapter，一个参数的函数对应另一个adapter，依次类推。

    （穿插一下：ttl(tiny template library)库中使用了一个很强大的宏技术，可以自动生成这些代码，但是具体原理

我不懂。所以只能使用这个笨办法了。）

    这样，我们就需要区分不同参数个数的函数原型。很显然，我们需要改进lua_binder。行之有效的技术是：模板偏特化。

改进后的lua_binder类似于：


    template <typename Prototype>


    class lua_binder; 




    template <typename R, typename P1>


    class lua_binder<R ( P1 )>


    {


    public:


        typedef R result_type;


        typedef P1 p1_type;


        typedef result_type (*func_type)( P1 );


    public:


        static int adapter( lua_State *L
)


        {


            return 0;


        }


    public:


        static func_type _func;


    };


    template <typename R, typename P1> 


    typename lua_binder<R( P1 )>::func_type lua_binder<R( P1 )>::_func = 0; 




    //






    lua_binder主体已经是一个单纯的声明而已，它的诸多特化版本将分别对应0个参数，1个参数，2个参数等。例如以上

列举的就是一个参数的偏特化版本。

Now, we can try ??

    那么，我们现在是否可以写下诸多的lua_to*函数去获取参数了？你觉得可以吗？假设现在要获取栈顶第一个参数，你

该调用lua_tonumber还是lua_tostring？

    问题就在于，我们并不知道该调用哪个函数。

    解决办法是：根据不同的参数类型，调用对应的lua_to*函数。

    不同的类型拥有不同的行为，这一点让你想起什么？那就是模板世界里的type traits，类型萃取。我想，完成本文的

绑定器，更多的是对你模板编程能力的考验。

    lua_to*系列函数是有限的，因此我们也只需要实现几个类型的行为即可。我们这个时候的目的就是，根据不同的类型，

调用对应的lua_to*函数。例如，对于number(int, long, double, float, char等等)，我们就调用lua_tonumber。

    于是得到：


    template <typename _Tp>


    struct param_traits


    {


        static _Tp get_param( lua_State *L, int index
)


        {


            return static_cast<_Tp>( lua_tonumber( L, index ) );


        }


    }; 




    template <>


    struct param_traits<const char*>


    {


        static const char *get_param(
lua_State *L, int index )


        {


            return lua_tostring( L, index );


        }


    };


    //

others





    param_traits主体处理所有的number(因为number类型太多，也许concept可以解决这个问题)，其他特化版本处理其他

类型。这样，在adapter里，就可以根据参数类型获取到相应的参数了，例如：

    P1 p1 = param_traits<P1>::get_param( L, -1);

    到这个时候，我们的adapter函数变为：（以一个参数的函数举例）


    static int adapter( lua_State *L
)


    {


        p1_type p1 = param_traits<p1_type>::get_param( L, -1 );


        _func( p1 ); 




        return 0;


    } 





And how about the result ??

    是的，我们还需要处理函数返回值。我们暂时假设所有的函数都只有一个返回值。这里面对的问题同取参数一样，我

们需要根据不同的返回值类型，调用对应的lua_push*函数压入返回值。

    同样的type traits技术，你应该自己写得出来，例如：


    template <typename _Tp>


    struct return_traits


    {


        static void set_result( lua_State *L,
lua_Number r )


        {


            lua_pushnumber( L, r );                


        }


    };


    template <>


    struct return_traits<const char*>


    {


        static void set_result( lua_State *L, const char *r
)


        {


            lua_pushstring( L, r );


        }


    }; 



    到这个时候，我们的adapter函数基本成型了：


    static int adapter( lua_State *L
)


    {


        p1_type p1 = param_traits<p1_type>::get_param( L, -1 );


        result_type r = _func( p1 );


        return_traits<result_type>::set_result( L, r );


        return 0;


    } 




The last 'return' ???

    最碍眼的，是adapter最后一行的return。LUA手册上告诉我们，lua_CFunction必须返回函数返回值的个数。我们已经

假设我们只支持一个返回值，那么，很好，直接返回1吧。

    关键在于，C/C++的世界里还有个关键字：void。是的，它表示没有返回值。在用户层函数返回值为void类型时（原谅

这矛盾的说法），我们这里需要返回0。

    你意识到了什么？是的，我们需要根据返回值类型是否是void来设置这个return的值：1或者0。又是个type traits的

小技术。我想你现在很熟悉了：


    template <typename _Tp>


    struct return_number_traits


    {


        enum


        {


            count = 1


        };


    };


    template <>


    struct return_number_traits<void>


    {


        enum


        {


            count = 0


        };


    };



    于是，我们的adapter变为：


    static int adapter( lua_State *L
)


    {


        p1_type p1 = param_traits<p1_type>::get_param( L, -1 );


        result_type r = _func( p1 );


        return_traits<result_type>::set_result( L, r );


        return return_number_traits<result_type>::count;


    }









Is everything OK?

    我很高兴我能流畅地写到这里，同样我希望我不仅向你展示了某个应用的实现，而是展示了模板编程的思想。

    但是，问题在于，当你要注册一个返回值为void的函数时：


    typedef lua_binder<void(int)> binder_type;


    lua_bind<binder_type>( L, my_fn, "fn" );



    你可能会被编译器告知：非法使用void类型。

    是的，好好省视下你的代码，当你的binder_type::result_type为void时，在adapter函数中，你基本上也就写下了

void r = something 的代码。这是个语法错误。

    同样的问题还有：当返回值是void时，我们也没有必要调用return_traits的set_result函数。

    我想你觉察出来，又一个type traits技术。我们将根据result_type决定不同的处理方式。于是，我写了一个caller：


    template <typename _Tp>


    struct caller


    {


        static void call( lua_State *L, p1_type &p1
)


        {


            result_type r = _func( p1 );


            return_traits<result_type>::set_result( L, r );


        }


    }; 




    template <>


    struct caller<void>


    {


        static void call( lua_State *L, p1_type &p1
)


        {


            _func( p1 );


        }


    }; 





    caller将根据不同的返回值类型决定如何去回调_func。比较遗憾的是，我们需要为每一个lua_binder编写这么一个

caller，因为caller要调用_func，并且_func的参数个数不同。

    那么现在，我们的adapter函数变为：


    static int adapter( lua_State *L
)


    {


        P1 p1 = lua::param_traits<P1>::get_param( L, -1);


        caller<result_type>::call( L, p1 );


        return return_number_traits<result_type>::count;


    }



END

    最后一段的标题不带问号，所以这就结束了。下载看看我的代码吧，为了给不同参数个数的函数写binder，始终需要

粘贴复制的手工劳动。

    值得注意的是，在最终的代码里，我使用了以前实现的functor，将函数类型泛化。这样，lua_binder就可以绑定类

成员函数，当然，还有operator()。