K3dLua.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2007 by Jan Koci   *
 *   honza.koci@email.cz   *
 *   http://kengine.sourceforge.net/tutorial/
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

// Load all files from a given directory
// http://www.lua.org/pil/29.1.html


#include "K3dLua.h"

K3dLua::K3dLua(K3dGameData *_pGameData)
{
        m_pGameData = _pGameData;
        // Set this class to the global data
        m_pGameData->SetLua(this);
        m_pLua = NULL;
        InitLua();
        // Open Lua
        //m_pLua = lua_open();
/*
        m_pLua = luaL_newstate();
        if(m_pLua)
        {
                luaL_openlibs(m_pLua);
                //luaopen_base(m_pLua);
                //luaopen_table(m_pLua);
                //luaopen_string(m_pLua);
                //luaopen_math(m_pLua);
                //m_pLuaThread = lua_newthread(m_pLua);
                //luaopen_base(m_pLuaThread);
                //luaopen_table(m_pLuaThread);
                //luaopen_string(m_pLuaThread);
                //luaopen_math(m_pLuaThread);
                //m_pLuaDebug = new lua_Debug;
        }
        else
        {
                cerr << "Error in K3dLua::K3dLua() -- Lua is not opened!!!" << endl;
        }
*/
}

K3dLua::~K3dLua()
{
        std::cout << "Destructor ~K3dLua()" << endl;
        DeleteLua();
        // Close Lua state
/*
        if(m_pLua)
        {
                if(m_pLuaDebug)
                {
                        delete m_pLuaDebug;
                        m_pLuaDebug = NULL;
                }
                //lua_close(m_pLua);
                std::cout << "Destructor ~K3dLua() OK" << endl;
        }
*/
}

void K3dLua::InitLua()
{
        if(m_pLua == NULL)
        {
                m_pLua = luaL_newstate();
                if(m_pLua)
                {
                        luaL_openlibs(m_pLua);
                }
                else
                {
                        cerr << "Error -- K3dLua::InitLua() -- Lua is not allocated!!!" << endl;
                }
        }
}

void K3dLua::DeleteLua()
{
        if(m_pLua)
        {
                lua_close(m_pLua);
                m_pLua = NULL;
        }
}

void K3dLua::ResetLua()
{
        DeleteLua();
        InitLua();
}

bool K3dLua::LuaLoadFile(const char *_strFilename)
{
        std::cout << "bool K3dLua::LuaLoadFile(const char *_strFilename)" << endl;
        std::cout << "_strFilename = " << _strFilename << endl;
        if(luaL_loadfile(m_pLua ,_strFilename) || LuaPCall(0,0,0))
        {
                LuaError("Error -- K3dLua::LuaLoadFile() -- cannot run file: %s", LuaToString(-1));
                return false;
        }
        return true;
}

int K3dLua::LuaPCall(const int _iNumArgs,const int _iNumResults,const int _iErrFunc)
{
        return lua_pcall(m_pLua, _iNumArgs, _iNumResults, _iErrFunc);
        
}

void K3dLua::LuaError (const char *_strFmt, ...)
{
        va_list argp;
        va_start(argp, _strFmt);
        vfprintf(stderr, _strFmt, argp);
        cerr << endl;
        va_end(argp);
}

void K3dLua::LuaRegister( const char *_strName, lua_CFunction _f)
{
        lua_register(m_pLua, _strName, _f);
}

const char *K3dLua::LuaToString(const int _id)
{
        return lua_tostring(m_pLua, _id);
}

double K3dLua::LuaToNumber(const int _id)
{
        return lua_tonumber (m_pLua, _id);
}

int K3dLua::LuaToBoolean(const int _id)
{
        return lua_toboolean (m_pLua, _id);
}

void K3dLua::LuaGetGlobal(const char *_strVarName)
{
        if(LuaCheckStack(1))
        {
                lua_getglobal(m_pLua, _strVarName);
        }
        else
        {
                cerr << "Error :: void K3dLua::LuaGetGlobal() -- Lua stack overflow !!!" << endl;
        }
        
}

int K3dLua::LuaIsNumber(const int _id)
{
        return lua_isnumber (m_pLua, _id);
}

int K3dLua::LuaIsBoolean(const int _id)
{
        return lua_isboolean(m_pLua, _id);
}

int K3dLua::LuaIsString(const int _id)
{
        return lua_isstring(m_pLua, _id);
}

void K3dLua::LuaPushString(const char *strKey)
{
        if(LuaCheckStack(1))
        {
                lua_pushstring(m_pLua, strKey);
        }
        else
        {
                cerr << "Error :: void K3dLua::LuaPushString() -- Lua stack overflow !!!" << endl;
        }
}

void K3dLua::LuaPop(const int _id)
{       
        lua_pop(m_pLua, _id);
}

void K3dLua::LuaGetTable(const int _id)
{
        lua_gettable(m_pLua, _id);
}

double K3dLua::LuaGetFieldNumber(const char * _strKey)
{
        if(LuaCheckStack(1))
        {
                double dResult;
                lua_pushstring(m_pLua, _strKey);
                // get table[key] 
                lua_gettable(m_pLua, -2);
                if (!lua_isnumber(m_pLua, -1))
                {
                        K3dString strErr = "Error, not found in map file a number `";
                        strErr += _strKey;
                        strErr += "`";
                        LuaError(strErr.GetString().c_str());
                }
                dResult = lua_tonumber(m_pLua, -1);
                // remove number
                lua_pop(m_pLua, 1);
                return dResult;
        }
        else
        {
                cerr << "Error :: void K3dLua::LuaGetFieldNumber() -- Lua stack overflow !!!" << endl;
                return 0;
        }
        
}

bool K3dLua::LuaGetFieldBool(const char * _strKey)
{
        if(LuaCheckStack(1))
        {
                bool bResult;
                lua_pushstring(m_pLua, _strKey);
                // get table[key] 
                lua_gettable(m_pLua, -2);
                if (!lua_isboolean(m_pLua, -1))
                {
                        K3dString strErr = "Error, not found in map file a boolean `";
                        strErr += _strKey;
                        strErr += "`";
                        LuaError(strErr.GetString().c_str());
                }
                bResult = (bool)lua_toboolean(m_pLua, -1);
                // remove number
                lua_pop(m_pLua, 1);
                return bResult;
        }
        else
        {
                cerr << "Error :: bool K3dLua::LuaGetFieldBool() -- Lua stack overflow !!!" << endl;
                return 0;
        }
        
}

const char *K3dLua::LuaGetFieldString(const char * _strKey)
{
        if(LuaCheckStack(1))
        {
                const char * strResult=NULL;
                lua_pushstring(m_pLua, _strKey);
                // get table[key] 
                lua_gettable(m_pLua, -2);
                if (!lua_isstring(m_pLua, -1))
                {
                        K3dString strErr = "Error, not found in map file a string `";
                        strErr += _strKey;
                        strErr += "`";
                        LuaError(strErr.GetString().c_str());
                        return strResult;
                }
                strResult = lua_tostring(m_pLua, -1);
                // remove number
                lua_pop(m_pLua, 1);
                return strResult;
        }
        else
        {
                cerr << "Error :: bool K3dLua::LuaGetFieldString() -- Lua stack overflow !!!" << endl;
                return 0;
        }
        
}

int K3dLua::LuaIsTable(const int _id)
{
        return lua_istable(m_pLua, _id);
}

void K3dLua::StackDump()
{
        int i;
        int top = lua_gettop(m_pLua);
        for (i = 1; i <= top; i++) 
        {  /* repeat for each level */
                int t = lua_type(m_pLua, i);
                switch (t) 
                {
                        case LUA_TSTRING:  /* strings */
                        printf("`%s'", lua_tostring(m_pLua, i));
                        break;
                
                        case LUA_TBOOLEAN:  /* booleans */
                        printf(lua_toboolean(m_pLua, i) ? "true" : "false");
                        break;
                
                        case LUA_TNUMBER:  /* numbers */
                        printf("%g", lua_tonumber(m_pLua, i));
                        break;
                
                        default:  /* other values */
                        printf("%s", lua_typename(m_pLua, t));
                        break;
                }
                printf("  ");  /* put a separator */
        }
        printf("\n");  /* end the listing */
}

bool K3dLua::LuaCheckStack(const int _iNum)
{
        return LuaCheckStack(m_pLua, _iNum);
}

bool K3dLua::LuaCheckStack(lua_State *_pState, const int _iNum)
{
        //int iSize = lua_gettop (_pState);
        if(lua_checkstack(_pState, 1)>0)
        {
                return true;
        }
        return false;
}

---