Lua bind 和 conf 实现

OStack程序员社区-中国程序员成长平台 › 门户 › 编程› LUA›LUA教程

原作者: [db:作者] 来自: [db:来源] 收藏邀请

Lua ，语法简单（极像javascript), 移植性好(纯C实现), 启动速度快，空间占用小，真不愧是潜入式脚本语言之王。

本人想拿它来做配置文件(conf)，也想加一点IoC, 就是配置脚本可以调用主程序的函数。

实现如下：

repeat_macro.h

#ifndef __REPEAT_MACRO_H__
#define __REPEAT_MACRO_H__

// concatenation
#define CAT(a, b) PRIMITIVE_CAT(a, b)
#define PRIMITIVE_CAT(a, b) a ## b

// binary intermediate split
#define SPLIT(i, im) PRIMITIVE_CAT(SPLIT_, i)(im)
#define SPLIT_0(a, b) a
#define SPLIT_1(a, b) b

// saturating increment and decrement
#define DEC(x) SPLIT(0, PRIMITIVE_CAT(DEC_, x))
#define INC(x) SPLIT(1, PRIMITIVE_CAT(DEC_, x))

#define DEC_0 0, 1
#define DEC_1 0, 2
#define DEC_2 1, 3
#define DEC_3 2, 4
#define DEC_4 3, 5
#define DEC_5 4, 6
#define DEC_6 5, 7
#define DEC_7 6, 8
#define DEC_8 7, 9
#define DEC_9 8, 10
#define DEC_10 9, 11
#define DEC_11 10, 12
#define DEC_12 11, 13
#define DEC_13 12, 14
#define DEC_14 13, 15
#define DEC_15 14, 15

// bit complement
#define COMPL(bit) PRIMITIVE_CAT(COMPL_, bit)
#define COMPL_0 1
#define COMPL_1 0

// nullary parentheses detection
#define IS_NULLARY(x) SPLIT(0, CAT(IS_NULLARY_R_, IS_NULLARY_C x))
#define IS_NULLARY_C() 1
#define IS_NULLARY_R_1 1, ~
#define IS_NULLARY_R_IS_NULLARY_C 0, ~

// boolean conversion
#define BOOL(x) COMPL(IS_NULLARY(PRIMITIVE_CAT(BOOL_, x)))
#define BOOL_0 ()

// recursion backend
#define EXPR(s) PRIMITIVE_CAT(EXPR_, s)
#define EXPR_0(x) x
#define EXPR_1(x) x
#define EXPR_2(x) x
#define EXPR_3(x) x
#define EXPR_4(x) x
#define EXPR_5(x) x
#define EXPR_6(x) x
#define EXPR_7(x) x
#define EXPR_8(x) x
#define EXPR_9(x) x
#define EXPR_10(x) x
#define EXPR_11(x) x
#define EXPR_12(x) x
#define EXPR_13(x) x
#define EXPR_14(x) x
#define EXPR_15(x) x

// bit-oriented if control structure
#define IIF(bit) PRIMITIVE_CAT(IIF_, bit)
#define IIF_0(t, f) f
#define IIF_1(t, f) t

// number-oriented if control structure
#define IF(cond) IIF(BOOL(cond))

// emptiness abstraction
#define EMPTY()

// 1x and 2x deferral macros
#define DEFER(macro) macro EMPTY()
#define OBSTRUCT() DEFER(EMPTY)()

// argument list eater
#define EAT(size) PRIMITIVE_CAT(EAT_, size)
#define EAT_0()
#define EAT_1(a)
#define EAT_2(a, b)
#define EAT_3(a, b, c)
#define EAT_4(a, b, c, d)
#define EAT_5(a, b, c, d, e)
#define EAT_6(a, b, c, d, e, f)
#define EAT_7(a, b, c, d, e, f, g)
#define EAT_8(a, b, c, d, e, f, g, h)
#define EAT_9(a, b, c, d, e, f, g, h, i)
#define EAT_10(a, b, c, d, e, f, g, h, i, j)
#define EAT_11(a, b, c, d, e, f, g, h, i, j, k)

// comma abstractions
#define COMMA() ,
#define COMMA_IF(n) IF(n)(COMMA, EMPTY)()

// repetition construct
#define REPEAT(s, count, macro, data) \
EXPR(s)(REPEAT_I(INC(s), INC(s), count, macro, data)) \
/**/
#define REPEAT_INDIRECT() REPEAT_I
#define REPEAT_I(s, o, count, macro, data) \
IF(count)(REPEAT_II, EAT(6))(OBSTRUCT(), s, o, DEC(count), macro, data) \
/**/
#define REPEAT_II(_, s, o, count, macro, data) \
EXPR(s) _(REPEAT_INDIRECT _()( \
INC(s), o, count, macro, data \
)) \
EXPR OBSTRUCT()(o)(macro OBSTRUCT()(o, count, data)) \
/**/

#endif //__REPEAT_MACRO_H__

lua_bind.h

#ifndef __LUA_BIND_H__
#define __LUA_BIND_H__

extern "C"
{
    #include <lua.h>
}

#include <string>

#ifndef LOG

#define ENABLE_LUA_BIND_H_LOG
#include <stdio.h>
#define LOG(level, format, ...) \
    fprintf(stderr, "[%s][%s][%d]: " format "\n", #level, __FILE__, int(__LINE__), ##__VA_ARGS__)

#endif //LOG

template<typename T>
T lua_get_param(lua_State *state, int index)
{
    LOG(ERROR, "parement type unsupport type");
    return T();
}

template <>
int lua_get_param<int>(lua_State *state, int index)
{
    if (!lua_isnumber(state, index)) {
        LOG(ERROR, "lua argument should be a number\n");
        return 0;
    }

    return (int)lua_tonumber(state, index);
}

template <>
bool lua_get_param<bool>(lua_State *state, int index)
{
    if (!lua_isboolean(state, index)){
        LOG(ERROR, "lua argument should be a boolean\n");
        return 0;
    }

    return (bool)lua_toboolean(state, index);
}

template <>
double lua_get_param<double>(lua_State *state, int index)
{
    if (!lua_isnumber(state, index)) {
        LOG(ERROR, "lua argument should be a number\n");
        return 0;
    }

    return lua_tonumber(state, index);
}

template <>
char const * lua_get_param<char const*>(lua_State *state, int index)
{
    if (!lua_isstring(state, index)){
        LOG(ERROR, "lua argument should be a string\n");
        return "";
    }

    return lua_tostring(state, index);
}

template <>
std::string lua_get_param<std::string >(lua_State *state, int index)
{
    if (!lua_isstring(state, index)){
        LOG(ERROR, "lua argument should be a string\n");
        return std::string();
    }

    return std::string(lua_tostring(state, index));
}

template<typename T>
int lua_set_result(lua_State *state, T value)
{
    LOG(ERROR, "parement type unsupport type");
    return 0;
}

template <>
int lua_set_result<int>(lua_State *state, int value)
{
    lua_pushnumber(state, double(value));
    return 1;
}

template <>
int lua_set_result<bool>(lua_State *state, bool value)
{
    lua_pushboolean(state, value);
    return 1;
}

template <>
int lua_set_result<double>(lua_State *state, double value)
{
    lua_pushnumber(state, value);
    return 1;
}

template <>
int lua_set_result<char const *>(lua_State *state, char const * value)
{
    if(value) {
        lua_pushstring(state, value);
    } else {
        lua_pushstring(state, "");
    }
    return 1;
}

template <>
int lua_set_result<std::string>(lua_State *state, std::string value)
{
    lua_pushstring(state, value.c_str());
    return 1;
}

#include "repeat_macro.h"

template<typename T>
class function_type_info
{
    public:
        typedef T result_type;
};

#define TEMPLATE_PARAM_TYPE(s, v, arg) COMMA_IF(v) typename CAT(arg, v)
#define TEMPLATE_PARAM_TYPE_LIST(num) EXPR(0)(REPEAT(0, num, TEMPLATE_PARAM_TYPE, arg))

#define DEF_FUN_PARAM_TYPE(s, v, arg) typedef CAT(arg, v) CAT(CAT(arg, v), _type) ;
#define ALL_DEF_FUN_PARAM_TYPE(num) EXPR(0)(REPEAT(0, num, DEF_FUN_PARAM_TYPE, arg))

#define GET_FUN_PARAM_TYPE(s, v, arg) COMMA_IF(v) CAT(arg, INC(v))
#define GET_FUN_PARAM_TYPE_LIST(num) EXPR(0) (REPEAT(0, num, GET_FUN_PARAM_TYPE, arg))

#define DEF_FUNCTION_TYPE_INFO(_, num, arg) \
template< TEMPLATE_PARAM_TYPE_LIST(INC(num)) > \
class function_type_info< arg0 (*)( GET_FUN_PARAM_TYPE_LIST(num) ) > \
{\
    public:\
    ALL_DEF_FUN_PARAM_TYPE(INC(num))\
    typedef arg0 result_type;\
};

DEF_FUNCTION_TYPE_INFO(_, 0, arg)
DEF_FUNCTION_TYPE_INFO(_, 1, arg)
DEF_FUNCTION_TYPE_INFO(_, 2, arg)
DEF_FUNCTION_TYPE_INFO(_, 3, arg)
DEF_FUNCTION_TYPE_INFO(_, 4, arg)
DEF_FUNCTION_TYPE_INFO(_, 5, arg)
DEF_FUNCTION_TYPE_INFO(_, 6, arg)
DEF_FUNCTION_TYPE_INFO(_, 7, arg)
DEF_FUNCTION_TYPE_INFO(_, 8, arg)
DEF_FUNCTION_TYPE_INFO(_, 9, arg)
DEF_FUNCTION_TYPE_INFO(_, 10, arg)
DEF_FUNCTION_TYPE_INFO(_, 11, arg)
DEF_FUNCTION_TYPE_INFO(_, 12, arg)
DEF_FUNCTION_TYPE_INFO(_, 13, arg)
DEF_FUNCTION_TYPE_INFO(_, 14, arg)

#define LUA_PARAM_TYPE(functor,n) CAT(CAT(functor::arg, n),_type)
#define GET_PARAM_IN(s, v, functor) LUA_PARAM_TYPE(functor, v) CAT(arg, v) = lua_get_param< LUA_PARAM_TYPE(functor, v) >(state, v);
#define GET_PARAM_FUN(n, functor) EXPR(0)(REPEAT(1, INC(n), GET_PARAM_IN, functor))

#define LUA_CALL_ARG_IN(s, v, arg) COMMA_IF(v) CAT(arg, INC(v))
#define LUA_CALL_FUN_ARG(n, arg) EXPR(0)(REPEAT(0, n, LUA_CALL_ARG_IN, arg))

#define LUA_BIND_NAME(fun, num) CAT(CAT(__lua_bind_, fun), num)
#define DEF_LUA_BIND(fun, num)\
    int LUA_BIND_NAME(fun, num) (lua_State *state){ \
        typedef function_type_info<typeof(&fun)> functor_info_type; \
        GET_PARAM_FUN(num, functor_info_type) \
        typeof(fun(LUA_CALL_FUN_ARG(num, arg))) result = fun(LUA_CALL_FUN_ARG(num, arg));\
        int ret = lua_set_result(state, result); \
        return ret;\
    }

#define DEF_LUA_BIND_VOID(fun, num)\
    int LUA_BIND_NAME(fun, num) (lua_State *state){ \
        typedef function_type_info<typeof(&fun)> functor_info_type; \
        GET_PARAM_FUN(num, functor_info_type) \
        fun(LUA_CALL_FUN_ARG(num, arg));\
        return 0;\
    }

#ifdef ENABLE_LUA_BIND_H_LOG
#undef LOG
#undef ENABLE_LUA_BIND_H_LOG
#endif //ENABLE_LUA_BIND_H_LOG

#endif //__LUA_BIND_H__

lua_conf.hpp

#ifndef __LUA_CONF_H__
#define __LUA_CONF_H__

extern "C"
{
    #include <lua.h>
    #include <lauxlib.h>
    #include <lualib.h>
}

#include "lua_bind.h"

#include <sstream>
#include <string>
#include <assert.h>

#ifndef LOG

#define ENABLE_LUA_CONF_H_LOG
#include <stdio.h>
#define LOG(level, format, ...) \
    fprintf(stderr, "[%s][%s][%d]: " format "\n", #level, __FILE__, int(__LINE__), ##__VA_ARGS__)

#endif //LOG

namespace lua
{

class LuaBase
{
public:
    bool open(char const *filename) {
        if(NULL == filename) return false;
        file_name_ = filename;

        state_ = lua_open();
        luaopen_base(state_);
        //luaopen_io(state_);
        //luaopen_string(state_);
        //luaopen_math(state_);
        if (luaL_loadfile(state_, file_name_.c_str())) {
            LOG(ERROR, "cannot load configuration file: %s", file_name_.c_str());
            close();
            return false;
        }
        return true;
    }

    typedef int bind_type(lua_State *);

    bool registry(char const *name, bind_type fun) {
        if(NULL==name || NULL == state_) return false;
        lua_pushcfunction(state_, fun);
        lua_setglobal(state_, name);
        return true;
    }

    bool load()
    {
      if(NULL == state_) return false;
      if(lua_pcall(state_, 0, 0, 0)){
         LOG(ERROR, "cannot run configuration file: %s", file_name_.c_str());
         close();
         return false;
      }
      return true;
    }

    void close() {
        if(state_) lua_close(state_);
        state_ = NULL;
    }

    lua_State *state_;
    std::string file_name_;
};

class LuaConf: public LuaBase
{
public:
    template <typename T>
    T get(char const* name){
        if(NULL==name || NULL == state_) return T();
        lua_getglobal(state_, name);
        if (!lua_isstring(state_, -1)){
            LOG(ERROR, "should be a string\n");
            return T();
        }

        std::string value = lua_tostring(state_, -1);
        lua_pop(state_, -1);
        std::istringstream in(value, std::istringstream::in);
        T ret;
        in>>ret;
        return ret;
    }

};

    template <>
    int LuaConf::get<int>(char const* name){
        if(NULL==name || NULL == state_) return 0;
        lua_getglobal(state_, name);
        if (!lua_isnumber(state_, -1)) {
            LOG(ERROR, "should be a number\n");
            return 0;
        }

        int result = (int)lua_tonumber(state_, -1);
        lua_pop(state_, -1);
        return result;
    }

    template <>
    double LuaConf::get<double>(char const* name) {
        if(NULL==name || NULL == state_) return 0;
        lua_getglobal(state_, name);
        if (!lua_isnumber(state_, -1)) {
            LOG(ERROR, "should be a number\n");
            return 0;
        }

        double result = lua_tonumber(state_, -1);
        lua_pop(state_, -1);
        return result;
    }

    template <>
    std::string LuaConf::get<std::string>(char const* name) {
        if(NULL==name || NULL == state_) return std::string();
        lua_getglobal(state_, name);
        if (!lua_isstring(state_, -1)) {
            LOG(ERROR, "should be a string\n");
            return std::string();
        }

        std::string result = lua_tostring(state_, -1);
        lua_pop(state_, -1);
        return result;
    }

};

#ifdef ENABLE_LUA_CONF_H_LOG
#undef LOG
#undef ENABLE_LUA_CONF_H_LOG
#endif //ENABLE_LUA_CONF_H_LOG

#endif //__LUA_CONF_H__

lua_conf.test.cpp

#include "lua_conf.hpp"
#include <stdio.h>
#include <string>

int say(char const *name) {
    printf("i say %s", name);
    return 1;
}

DEF_LUA_BIND(say, 1)

int main()
{
    lua::LuaConf conf;
    conf.open("1.lua");
    conf.registry("say", LUA_BIND_NAME(say, 1));
    conf.load();
    int a = conf.get<int>("a");
    printf("a=%d\n", a);
    std::string b = conf.get<std::string>("b");
    printf("b=%s\n", b.c_str());
    return 0;
}