LuaDispatcher

UserPreferences

1. 개요
2. 소스
1. LuaDispatcher.h
2. LuaDispatcher.cpp
3. LuaAPI.h
4. LuaAPI.cpp
3. 사용법
4. TODO

1 개요

루아 쪽에서 C/C++ 쪽의 함수를 호출하는 것은 비교적 간단하나(그렇지도 않나...), 반대로 C/C++ 쪽에서 루아 쪽의 함수를 호출하는 것은 상당히 귀찮은 편이다. 예를 들어, 2개의 숫자인수를 받아 그 합을 반환하는 함수가 루아 쪽에 있다고 하자.


function add(lhs, rhs)
    assert(type(lhs) == "number")
    assert(type(rhs) == "number")
    return lhs + rhs
end

이 함수를 C/C++ 쪽에서 호출하고자 한다면 대략 다음과 같은 코드를 만들어야 한다.


int call_add(lua_State* L, int lhs, int rhs)
{
    // 함수를 가져와 스택에다 푸시한다.
    lua_getglobal(L, "add");
    luaL_checktype(L, -1, LUA_TFUNCTION);

    // 디버그를 위해 트레이스 함수를 가져와 집어넣는다.
    int errorfunc = lua_gettop(L);
    lua_getglobal(L, "_TRACEBACK");
    luaL_checktype(L, -1, LUA_TFUNCTION);
    lua_insert(L, errorfunc);

    // 인자를 푸쉬한다.
    lua_pushnumber(L, lhs);
    lua_pushnumber(L, rhs);

    // 2개의 인자를 가지고 1개의 반환값을 가지는 함수를 호출한다.
    if (lua_pcall(L, 2, 1, errorfunc) != 0)
    {
        // 에러가 발생했다. 처리를 해준다.
        cerr << "ERROR: " << lua_tostring(L, -1) << endl;
        lua_pop(L, 1);
        return 0;
    }

    // 스택에서 반환값을 꺼낸다.
    luaL_checktype(L, -1, LUA_TNUMBER);
    int result = (int)lua_tonumber(L, -1);
    lua_pop(L, 1);

    // 스택에서 트레이스 함수를 꺼낸다.
    lua_pop(L, 1);

    return result;
}

단지 숫자 2개를 더해서 반환하는 함수일 뿐인데, 이 정도 코드가 필요하다. 에러 처리를 생략하면 약간 간단해지기는 하겠지만, 제대로된 디버거도 없는 상황에서 에러 처리는 필수다.

그래서 어떻게 하면 C++ 상에서 루아 쪽에 있는 함수를 좀 더 쉽게 호출할 수 있을까하고 방법을 찾아봤다. 가장 가벼운 모듈이 LuaPlus 쪽에 Call Dispatcher라는 모듈이었는데, 템플릿 떡칠이 되어있는 점이 마음에 들지 않아 결국 따로 만들게 되었다.

2 소스

이 사이트에 있는 대부분의 소스가 그렇듯이 바로 컴파일되지는 않을 것이다. 헤더 파일을 적당히 수정하고, Assert를 손봐야한다.



2.1 LuaDispatcher.h

//////////////////////////////////////////////////////////////////////////////
/// \file LuaDispatcher.h
/// \author excel96
/// \date 2005.1.19
//////////////////////////////////////////////////////////////////////////////

#pragma once

#include "LuaAPI.h"
#include "Noncopyable.h"

//////////////////////////////////////////////////////////////////////////////
/// \class LuaDispatcherBase
/// \brief C/C++ 쪽에서 Lua 쪽 함수 호출을 좀 더 쉽게 하기 위한 클래스.
///
/// LuaDispatcher 클래스의 베이스 클래스가 되는 클래스이다. 이대로 사용해도
/// 별 문제가 없기는 하나, 좀 더 편하게 하기 위해서는 LuaDispatcher 클래스를
/// 이용하는 것이 낫다.
//////////////////////////////////////////////////////////////////////////////

class LuaDispatcherBase
{
public:
    /// 에러 통지 함수
    typedef void (*PFN_ERROR_HANDLER)(const string& errormsg);


protected:
    lua_State*        m_pState;          ///< 루아 상태 객체
    int               m_MaxArgs;         ///< 인수의 갯수
    int               m_MaxReturns;      ///< 리턴값의 갯수
    int               m_CurArgs;         ///< 푸쉬된 인수의 갯수
    int               m_CurReturns;      ///< 팝된 리턴값의 갯수
    int               m_ErrorFunc;       ///< 에러 처리 함수의 스택 인덱스
    PFN_ERROR_HANDLER m_pfnErrorHandler; ///< 에러 핸들러


public:
    /// \brief 생성자
    /// \param L 루아 상태 객체
    /// \param funcname 함수 이름
    /// \param nargs 인수의 갯수
    /// \param nreturns 리턴값의 갯수
    LuaDispatcherBase(lua_State* L, const char* funcname, int nargs, int nreturns);

    /// \brief 소멸자
    virtual ~LuaDispatcherBase();


public:
    /// \name 인수 푸쉬
    /// \{
    void arg(const bool value);
    void arg(const int value);
    void arg(const string& value);
    void arg(const void* value);
    void arg(const LUA_VECTOR& value);
    void arg(const LUA_MAP& value);
    /// \}

    /// \name 리턴값 팝
    /// \{
    void ret(bool& value);
    void ret(int& value);
    void ret(string& value);
    void ret(void** value);
    void ret(LUA_VECTOR& value);
    void ret(LUA_MAP& value);
    /// \}

    /// \brief 함수를 실행한다.
    void execute();

    /// \brief 에러 핸들러를 설정한다.
    /// \param pfnErrorHandler 에러 핸들러
    void setErrorHandler(PFN_ERROR_HANDLER pfnErrorHandler) {
        m_pfnErrorHandler = pfnErrorHandler;
    }
};


//////////////////////////////////////////////////////////////////////////////
/// \class LuaDispatcher
/// \brief C/C++ 쪽에서 Lua 쪽 함수 호출을 좀 더 쉽게 하기 위한 클래스.
//////////////////////////////////////////////////////////////////////////////

class LuaDispatcher : public LuaDispatcherBase
{
public:
    LuaDispatcher(lua_State* L, const char* funcname)
    : LuaDispatcherBase(L, funcname, 0, 0)
    {
        execute();
    }

    LuaDispatcher(lua_State* L, const char* funcname, int nreturns)
    : LuaDispatcherBase(L, funcname, 0, nreturns)
    {
        execute();
    }

    template <typename A1>
    LuaDispatcher(lua_State* L, const char* funcname, int nreturns,
        const A1& a1)
    : LuaDispatcherBase(L, funcname, 1, nreturns)
    {
        arg(a1);
        execute();
    }

    template <typename A1, typename A2>
    LuaDispatcher(lua_State* L, const char* funcname, int nreturns,
        const A1& a1, const A2& a2)
    : LuaDispatcherBase(L, funcname, 2, nreturns)
    {
        arg(a1);
        arg(a2);
        execute();
    }

    template <typename A1, typename A2, typename A3>
    LuaDispatcher(lua_State* L, const char* funcname, int nreturns,
        const A1& a1, const A2& a2, const A3& a3)
    : LuaDispatcherBase(L, funcname, 3, nreturns)
    {
        arg(a1);
        arg(a2);
        arg(a3);
        execute();
    }

    template <typename A1, typename A2, typename A3, typename A4>
    LuaDispatcher(lua_State* L, const char* funcname, int nreturns,
        const A1& a1, const A2& a2, const A3& a3, const A4& a4)
    : LuaDispatcherBase(L, funcname, 4, nreturns)
    {
        arg(a1);
        arg(a2);
        arg(a3);
        arg(a4);
        execute();
    }

    template <typename A1, typename A2, typename A3, typename A4, typename A5>
    LuaDispatcher(lua_State* L, const char* funcname, int nreturns,
        const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
    : LuaDispatcherBase(L, funcname, 5, nreturns)
    {
        arg(a1);
        arg(a2);
        arg(a3);
        arg(a4);
        arg(a5);
        execute();
    }

    /// \brief 소멸자
    virtual ~LuaDispatcher() {}
};




2.2 LuaDispatcher.cpp

//////////////////////////////////////////////////////////////////////////////
/// \file LuaDispatcher.cpp
/// \author excel96
/// \date 2005.1.19
//////////////////////////////////////////////////////////////////////////////

#include "GameLibPCH.h"
#include "LuaDispatcher.h"

//////////////////////////////////////////////////////////////////////////////
/// \brief 기본 에러 핸들러
/// \param errormsg 에러 메시지
//////////////////////////////////////////////////////////////////////////////
static void DEFAULT_ERROR_HANDLER(const string& errormsg)
{
    filelog(NULL, "script execution error:\n%s", errormsg.c_str());
    Assert(false && "script execution error");
}

//////////////////////////////////////////////////////////////////////////////
/// \brief 생성자
/// \param L 루아 상태 객체
/// \param funcname 함수 이름
/// \param nargs 인수의 갯수
/// \param nreturns 리턴값의 갯수
//////////////////////////////////////////////////////////////////////////////
LuaDispatcherBase::LuaDispatcherBase(lua_State* L, const char* funcname, int nargs, int nreturns)
: m_pState(L), m_MaxArgs(nargs), m_MaxReturns(nreturns),
m_CurArgs(0), m_CurReturns(0), m_pfnErrorHandler(DEFAULT_ERROR_HANDLER)
{
    AssertPtr(m_pState);
    AssertPtr(funcname);
    Assert(m_MaxArgs >= 0);
    Assert(m_MaxReturns >= 0);

    // 함수를 가져와 스택에다 푸시한다.
    lua_getglobal(m_pState, funcname);
    luaL_checktype(m_pState, -1, LUA_TFUNCTION);

    // 디버그를 위해 트레이스 함수를 가져와 집어넣는다.
    m_ErrorFunc = lua_gettop(m_pState);
    lua_getglobal(m_pState, "_TRACEBACK");
    luaL_checktype(m_pState, -1, LUA_TFUNCTION);
    lua_insert(m_pState, m_ErrorFunc);
}

//////////////////////////////////////////////////////////////////////////////
/// \brief 소멸자
//////////////////////////////////////////////////////////////////////////////
LuaDispatcherBase::~LuaDispatcherBase()
{
    if (m_CurReturns == 0)
    {
        luaL_checktype(m_pState, -1, LUA_TFUNCTION);
        lua_pop(m_pState, 1); // 트레이스 함수를 팝 한다.
    }
    else if (m_pfnErrorHandler)
    {
        m_pfnErrorHandler("not all return values popped");
    }
}

//////////////////////////////////////////////////////////////////////////////
/// \brief 인수를 푸쉬한다.
/// \param value 인수값
//////////////////////////////////////////////////////////////////////////////
void LuaDispatcherBase::arg(const bool value)
{
    if (m_CurArgs < m_MaxArgs)
    {
        LuaAPI::push(m_pState, value);
        ++m_CurArgs;
    }
    else if (m_pfnErrorHandler)
    {
        m_pfnErrorHandler("too many arguments");
    }
}

//////////////////////////////////////////////////////////////////////////////
/// \brief 인수를 푸쉬한다.
/// \param value 인수값
//////////////////////////////////////////////////////////////////////////////
void LuaDispatcherBase::arg(const int value)
{
    if (m_CurArgs < m_MaxArgs)
    {
        LuaAPI::push(m_pState, value);
        ++m_CurArgs;
    }
    else if (m_pfnErrorHandler)
    {
        m_pfnErrorHandler("too many arguments");
    }
}

//////////////////////////////////////////////////////////////////////////////
/// \brief 인수를 푸쉬한다.
/// \param value 인수값
//////////////////////////////////////////////////////////////////////////////
void LuaDispatcherBase::arg(const string& value)
{
    if (m_CurArgs < m_MaxArgs)
    {
        LuaAPI::push(m_pState, value);
        ++m_CurArgs;
    }
    else if (m_pfnErrorHandler)
    {
        m_pfnErrorHandler("too many arguments");
    }
}

//////////////////////////////////////////////////////////////////////////////
/// \brief 인수를 푸쉬한다.
/// \param value 인수값
//////////////////////////////////////////////////////////////////////////////
void LuaDispatcherBase::arg(const void* value)
{
    if (m_CurArgs < m_MaxArgs)
    {
        LuaAPI::push(m_pState, value);
        ++m_CurArgs;
    }
    else if (m_pfnErrorHandler)
    {
        m_pfnErrorHandler("too many arguments");
    }
}

//////////////////////////////////////////////////////////////////////////////
/// \brief 인수를 푸쉬한다.
/// \param value 인수값
//////////////////////////////////////////////////////////////////////////////
void LuaDispatcherBase::arg(const LUA_VECTOR& value)
{
    if (m_CurArgs < m_MaxArgs)
    {
        LuaAPI::push(m_pState, value);
        ++m_CurArgs;
    }
    else if (m_pfnErrorHandler)
    {
        m_pfnErrorHandler("too many arguments");
    }
}

//////////////////////////////////////////////////////////////////////////////
/// \brief 인수를 푸쉬한다.
/// \param value 인수값
//////////////////////////////////////////////////////////////////////////////
void LuaDispatcherBase::arg(const LUA_MAP& value)
{
    if (m_CurArgs < m_MaxArgs)
    {
        LuaAPI::push(m_pState, value);
        ++m_CurArgs;
    }
    else if (m_pfnErrorHandler)
    {
        m_pfnErrorHandler("too many arguments");
    }
}

//////////////////////////////////////////////////////////////////////////////
/// \brief 리턴값을 스택에서 팝한다.
/// \param value 리턴값이 들어갈 변수
//////////////////////////////////////////////////////////////////////////////
void LuaDispatcherBase::ret(bool& value)
{
    if (m_CurReturns > 0)
    {
        LuaAPI::pop(m_pState, value);
        --m_CurReturns;
    }
    else if (m_pfnErrorHandler)
    {
        m_pfnErrorHandler("no more return value");
    }
}

//////////////////////////////////////////////////////////////////////////////
/// \brief 리턴값을 스택에서 팝한다.
/// \param value 리턴값이 들어갈 변수
//////////////////////////////////////////////////////////////////////////////
void LuaDispatcherBase::ret(int& value)
{
    if (m_CurReturns > 0)
    {
        LuaAPI::pop(m_pState, value);
        --m_CurReturns;
    }
    else if (m_pfnErrorHandler)
    {
        m_pfnErrorHandler("no more return value");
    }
}

//////////////////////////////////////////////////////////////////////////////
/// \brief 리턴값을 스택에서 팝한다.
/// \param value 리턴값이 들어갈 변수
//////////////////////////////////////////////////////////////////////////////
void LuaDispatcherBase::ret(string& value)
{
    if (m_CurReturns > 0)
    {
        LuaAPI::pop(m_pState, value);
        --m_CurReturns;
    }
    else if (m_pfnErrorHandler)
    {
        m_pfnErrorHandler("no more return value");
    }
}

//////////////////////////////////////////////////////////////////////////////
/// \brief 리턴값을 스택에서 팝한다.
/// \param value 리턴값이 들어갈 변수
//////////////////////////////////////////////////////////////////////////////
void LuaDispatcherBase::ret(void** value)
{
    if (m_CurReturns > 0)
    {
        LuaAPI::pop(m_pState, value);
        --m_CurReturns;
    }
    else if (m_pfnErrorHandler)
    {
        m_pfnErrorHandler("no more return value");
    }
}

//////////////////////////////////////////////////////////////////////////////
/// \brief 리턴값을 스택에서 팝한다.
/// \param value 리턴값이 들어갈 변수
//////////////////////////////////////////////////////////////////////////////
void LuaDispatcherBase::ret(LUA_VECTOR& value)
{
    if (m_CurReturns > 0)
    {
        LuaAPI::pop(m_pState, value);
        --m_CurReturns;
    }
    else if (m_pfnErrorHandler)
    {
        m_pfnErrorHandler("no more return value");
    }
}

//////////////////////////////////////////////////////////////////////////////
/// \brief 리턴값을 스택에서 팝한다.
/// \param value 리턴값이 들어갈 변수
//////////////////////////////////////////////////////////////////////////////
void LuaDispatcherBase::ret(LUA_MAP& value)
{
    if (m_CurReturns > 0)
    {
        LuaAPI::pop(m_pState, value);
        --m_CurReturns;
    }
    else if (m_pfnErrorHandler)
    {
        m_pfnErrorHandler("no more return value");
    }
}

//////////////////////////////////////////////////////////////////////////////
/// \brief 함수를 실행한다. 실행하기 전에 모든 인수를 푸쉬한 상태여야한다.
//////////////////////////////////////////////////////////////////////////////
void LuaDispatcherBase::execute()
{
    if (m_CurArgs != m_MaxArgs && m_pfnErrorHandler)
    {
        m_pfnErrorHandler("not enough or too many arguments");
        return;
    }

    if (lua_pcall(m_pState, m_MaxArgs, m_MaxReturns, m_ErrorFunc) == 0)
    {
        m_CurArgs = 0;
        m_CurReturns = m_MaxReturns;
    }
    else if (m_pfnErrorHandler)
    {
        string errormsg;
        LuaAPI::pop(m_pState, errormsg);
        m_pfnErrorHandler(errormsg);
    }
}




2.3 LuaAPI.h

//////////////////////////////////////////////////////////////////////////////
/// \file LuaAPI.h
/// \author excel96
/// \date 2004.10.18
//////////////////////////////////////////////////////////////////////////////

#pragma once

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

typedef vector<string> LUA_VECTOR;
typedef map<string, string> LUA_MAP;

//////////////////////////////////////////////////////////////////////////////
/// \class LuaAPI
/// \brief 루아 <--> C/C++ 데이터 교환을 좀 더 편하게 다루기 위해 만든
/// 유틸리티 클래스.
///
/// 테이블 같은 경우에는 vector<string>, map<string, string> 형식으로만
/// 취급한다. 테이블 안의 테이블 같은 걸 다루게 되면, 코드 크기도 크기지만
/// 사용하기가 복잡해지기 때문이다.
//////////////////////////////////////////////////////////////////////////////

class LuaAPI
{
public:
    /// \brief 스택의 최상단에 있는 값을 팝한다.
    static void pop(lua_State* L) {
        AssertPtr(L);
        lua_pop(L, 1);
    }

    /// \brief 스택의 최상단에 있는 값이 nil일 경우 팝한다.
    static void popnil(lua_State* L) {
        AssertPtr(L);
        luaL_checktype(L, -1, LUA_TNIL);
        lua_pop(L, 1);
    }

    /// \brief 스택의 최상단에 있는 값을 주어진 bool 변수에다 쓴다.
    static void pop(lua_State* L, bool& value) {
        AssertPtr(L);
        luaL_checktype(L, -1, LUA_TBOOLEAN);
        value = lua_toboolean(L, -1) != 0;
        lua_pop(L, 1);
    }

    /// \brief 스택의 최상단에 있는 값을 주어진 int 변수에다 쓴다.
    static void pop(lua_State* L, int& value) {
        AssertPtr(L);
        luaL_checkint(L, -1);
        value = static_cast<int>(lua_tonumber(L, -1));
        lua_pop(L, 1);
    }

    /// \brief 스택의 최상단에 있는 값을 주어진 string 변수에다 쓴다.
    static void pop(lua_State* L, string& value) {
        AssertPtr(L);
        luaL_checkstring(L, -1);
        value = string(lua_tostring(L, -1));
        lua_pop(L, 1);
    }

    /// \brief 스택의 최상단에 있는 값을 주어진 void* 변수에다 쓴다.
    static void pop(lua_State* L, void** value)
    {
        AssertPtr(L);
        luaL_checktype(L, -1, LUA_TLIGHTUSERDATA);
        *value = const_cast<void*>(lua_topointer(L, -1));
        lua_pop(L, 1);
    }

    /// \brief 스택의 최상단에 있는 값을 주어진 LUA_VECTOR 변수에다 쓴다.
    static void pop(lua_State* L, LUA_VECTOR& value);

    /// \brief 스택의 최상단에 있는 값을 주어진 LUA_MAP 변수에다 쓴다.
    static void pop(lua_State* L, LUA_MAP& value);


public:
    /// \brief 스택의 최상단에다 nil 값을 push한다.
    static void pushnil(lua_State* L) {
        AssertPtr(L);
        lua_pushnil(L);
    }

    /// \brief 스택의 최상단에다 bool 값을 push한다.
    static void push(lua_State* L, const bool value) {
        AssertPtr(L);
        lua_pushboolean(L, value);
    }

    /// \brief 스택의 최상단에다 int 값을 push한다.
    static void push(lua_State* L, const int value) {
        AssertPtr(L);
        lua_pushnumber(L, value);
    }

    /// \brief 스택의 최상단에다 string 값을 push한다.
    static void push(lua_State* L, const string& value) {
        AssertPtr(L);
        lua_pushstring(L, value.c_str());
    }

    static void push(lua_State* L, const void* value)
    {
        AssertPtr(L);
        lua_pushlightuserdata(L, const_cast<void*>(value));
    }

    /// \brief 스택의 최상단에다 벡터를 push한다.
    static void push(lua_State* L, const LUA_VECTOR& value);

    /// \brief 스택의 최상단에다 맵을 push한다.
    static void push(lua_State* L, const LUA_MAP& value);


public:
    /// \brief 현재 스택을 출력한다
    /// \param L 루아 상태 객체
    static void printStack(lua_State* L);
};




2.4 LuaAPI.cpp

//////////////////////////////////////////////////////////////////////////////
/// \file LuaAPI.cpp
/// \author excel96
/// \date 2004.10.18
//////////////////////////////////////////////////////////////////////////////

#include "GameLibPCH.h"
#include "LuaAPI.h"

//////////////////////////////////////////////////////////////////////////////
/// \brief 정수를 문자열로 변환한다.
/// \param i 문자열로 변환할 정수값
/// \return static string 변환된 문자열
//////////////////////////////////////////////////////////////////////////////
static string itos(const int i)
{
    char buf[128] = {0,};
    _snprintf(buf, sizeof(buf)-1, "%d", i);
    return buf;
}

//////////////////////////////////////////////////////////////////////////////
/// \brief 스택의 최상단에 있는 값을 주어진 LUA_VECTOR 변수에다 쓴다.
/// \param L 루아 상태 객체
/// \param value 값을 집어넣을 변수의 참조
//////////////////////////////////////////////////////////////////////////////
void LuaAPI::pop(lua_State* L, LUA_VECTOR& value)
{
    AssertPtr(L);

    luaL_checktype(L, -1, LUA_TTABLE); // 테이블 확인

    // 테이블을 횡단하면서 값들을 복사한다.
    lua_pushnil(L);
    while (lua_next(L, -2) != 0)
    {
        // key는 stack[-2]에 있고, value는 stack[-1]에 있다.
        switch (lua_type(L, -1))
        {
        case LUA_TNUMBER:
            value.push_back(itos(static_cast<int>(lua_tonumber(L, -1))));
            break;
        case LUA_TSTRING:
            value.push_back( string(lua_tostring(L, -1)) );
            break;
        default:
            break;
        }

        // 키에 쌍이 되는 값(value)만 제거한다.
        // 다음 iteration 실행을 위해 현재 key값은 남겨둔다.
        lua_pop(L, 1);
    }

    lua_pop(L, 1); // 테이블을 pop해준다.
}

//////////////////////////////////////////////////////////////////////////////
/// \brief 스택의 최상단에 있는 값을 주어진 LUA_MAP 변수에다 쓴다.
/// \param L 루아 상태 객체
/// \param value 값을 집어넣을 변수의 참조
//////////////////////////////////////////////////////////////////////////////
void LuaAPI::pop(lua_State* L, LUA_MAP& value)
{
    AssertPtr(L);

    luaL_checktype(L, -1, LUA_TTABLE); // 테이블 확인

    // 테이블을 횡단하면서 값들을 복사한다.
    lua_pushnil(L);
    while (lua_next(L, -2) != 0)
    {
        // key는 stack[-2]에 있고, value는 stack[-1]에 있다.
        string key, val;

        switch (lua_type(L, -2))
        {
        case LUA_TNUMBER:
            key = itos(static_cast<int>(lua_tonumber(L, -2)));
            break;
        case LUA_TSTRING:
            key = string(lua_tostring(L, -2));
            break;
        default:
            break;
        }

        switch (lua_type(L, -1))
        {
        case LUA_TNUMBER:
            val = itos(static_cast<int>(lua_tonumber(L, -1)));
            break;
        case LUA_TSTRING:
            val = string(lua_tostring(L, -1));
            break;
        default:
            break;
        }

        value.insert(LUA_MAP::value_type(key, val));

        // 키에 쌍이 되는 값(value)만 제거한다.
        // 다음 iteration 실행을 위해 현재 key값은 남겨둔다.
        lua_pop(L, 1);
    }

    lua_pop(L, 1); // 테이블을 pop해준다.
}


//////////////////////////////////////////////////////////////////////////////
/// \brief 스택의 최상단에다 벡터를 push한다.
/// \param L 루아 상태 객체
/// \param value 스택에다 집어넣을 변수
//////////////////////////////////////////////////////////////////////////////
void LuaAPI::push(lua_State* L, const LUA_VECTOR& value)
{
    AssertPtr(L);

    // 빈 테이블을 생성해 스택의 맨 위에다 놓고...
    lua_newtable(L);

    for (size_t i=0; i<value.size(); i++)
    {
        // 루아에서 index는 1부터 시작
        lua_pushnumber(L, static_cast<int>(i+1));
        lua_pushstring(L, value[i].c_str());
        lua_rawset(L, -3);
    }
}

//////////////////////////////////////////////////////////////////////////////
/// \brief 스택의 최상단에다 맵을 push한다.
/// \param L 루아 상태 객체
/// \param value 스택에다 집어넣을 변수
//////////////////////////////////////////////////////////////////////////////
void LuaAPI::push(lua_State* L, const LUA_MAP& value)
{
    AssertPtr(L);

    // 빈 테이블을 생성해 스택의 맨 위에다 놓고...
    lua_newtable(L);

    for (LUA_MAP::const_iterator itr(value.begin());
        itr != value.end(); itr++)
    {
        lua_pushstring(L, itr->first.c_str());
        lua_pushstring(L, itr->second.c_str());
        lua_rawset(L, -3);
    }
}

3 사용법

개요에서 나온 함수를 호출하고자 한다면 다음과 같이 하면 된다.


int call_add(lua_State* L, int lhs, int rhs)
{
    LuaDispatcher d(L, "add", 1, lhs, rhs);
    int result = 0;
    d.ret(result);
    return result;
}

4 TODO

• 반환값 처리하는 부분도 약간 더 신경쓰면 깔끔하게 처리할 수 있을 것 같은데...
  

• see also Lua, LuaCppBinding
  

• CategoryLanguage