mirror-games/glest-source
1
0
Fork 0
mirror of https://github.com/glest/glest-source.git synced 2025-09-30 09:29:25 +02:00
Code Issues Projects Releases Wiki Activity
Files
35b7b1f1a61c61cc5c2b1beaa5ecd02b5d402d07
glest-source/source/shared_lib/sources/lua/lua_script.cpp
mathusummut 35b7b1f1a6 Fixed the god-awful indentation
2018-05-06 00:01:36 +02:00

1135 lines
37 KiB
C++
Raw Blame History

// ==============================================================
// This file is part of Glest Shared Library (www.glest.org)
//
// Copyright (C) 2001-2008 Martiño Figueroa
//
// You can redistribute this code 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
// ==============================================================
#include "lua_script.h"
#include <stdexcept>
#include "conversion.h"
#include "util.h"
#include "platform_util.h"
#include "leak_dumper.h"
using namespace std;
using namespace Shared::Util;
namespace Shared {
namespace Lua {
//
// This class wraps streflop for LuaScript. We need to toggle the data type
// for streflop to use when calling into LUA as streflop may corrupt some
// numeric values passed from Lua otherwise
//
class Lua_STREFLOP_Wrapper {
public:
Lua_STREFLOP_Wrapper() {
#ifdef USE_STREFLOP
streflop_init<streflop::Double>();
#endif
}
~Lua_STREFLOP_Wrapper() {
#ifdef USE_STREFLOP
streflop_init<streflop::Simple>();
#endif
}
};
// =====================================================
// class LuaScript
// =====================================================
bool LuaScript::disableSandbox = false;
bool LuaScript::debugModeEnabled = false;
LuaScript::LuaScript() {
Lua_STREFLOP_Wrapper streflopWrapper;
currentLuaFunction = "";
currentLuaFunctionIsValid = false;
sandboxWrapperFunctionName = "";
sandboxCode = "";
luaState = luaL_newstate();
luaL_openlibs(luaState);
if (luaState == NULL) {
throw megaglest_runtime_error("Can not allocate lua state");
}
argumentCount = -1;
if (disableSandbox == false) {
lua_getglobal(luaState, "os");
lua_pushnil(luaState);
lua_setfield(luaState, -2, "execute");
lua_pushnil(luaState);
lua_setfield(luaState, -2, "rename");
lua_pushnil(luaState);
lua_setfield(luaState, -2, "remove");
lua_pushnil(luaState);
lua_setfield(luaState, -2, "exit");
lua_getglobal(luaState, "io");
lua_pushnil(luaState);
lua_setfield(luaState, -2, "open");
lua_pushnil(luaState);
lua_setfield(luaState, -2, "close");
lua_pushnil(luaState);
lua_setfield(luaState, -2, "write");
lua_pushnil(luaState);
lua_setfield(luaState, -2, "read");
lua_pushnil(luaState);
lua_setfield(luaState, -2, "flush");
lua_pushnil(luaState);
lua_setglobal(luaState, "loadfile");
lua_pushnil(luaState);
lua_setglobal(luaState, "dofile");
lua_pushnil(luaState);
lua_setglobal(luaState, "getfenv");
lua_pushnil(luaState);
lua_setglobal(luaState, "getmetatable");
lua_pushnil(luaState);
lua_setglobal(luaState, "load");
lua_pushnil(luaState);
lua_setglobal(luaState, "loadfile");
lua_pushnil(luaState);
lua_setglobal(luaState, "loadstring");
lua_pushnil(luaState);
lua_setglobal(luaState, "rawequal");
lua_pushnil(luaState);
lua_setglobal(luaState, "rawget");
lua_pushnil(luaState);
lua_setglobal(luaState, "rawset");
lua_pushnil(luaState);
lua_setglobal(luaState, "setfenv");
lua_pushnil(luaState);
lua_setglobal(luaState, "setmetatable");
lua_pop(luaState, 1);
}
}
void LuaScript::DumpGlobals() {
LuaHandle *L = luaState;
// push the first key (nil = beginning of table)
#if LUA_VERSION_NUM <= 501
lua_pushnil(L);
#endif
// lua_next will:
// 1 - pop the key
// 2 - push the next key
// 3 - push the value at that key
// ... so the key will be at index -2 and the value at index -1
#if LUA_VERSION_NUM > 501
lua_pushglobaltable(L);
lua_pushnil(L);
while (lua_next(L, -2) != 0) {
#else
while (lua_next(L, LUA_GLOBALSINDEX) != 0) {
#endif
// get type of key and value
int key_type = lua_type(L, -2);
int value_type = lua_type(L, -1);
// support only string keys
// globals aren't likely to have a non-string key, but just to be certain ...
if (key_type != LUA_TSTRING) {
lua_pop(L, 1); // pop the value so that the top contains the key for the next iteration
continue;
}
// support only number, boolean and string values
if (value_type != LUA_TNUMBER &&
value_type != LUA_TBOOLEAN &&
value_type != LUA_TSTRING) {
lua_pop(L, 1); // again, pop the value before going to the next loop iteration
continue;
}
// get the key as a string
string key_string = lua_tostring(L, -2); // no copy required - we already know this is a string
// do not support variables that start with '_'
// lua has some predefined values like _VERSION. They all start with underscore
if (!key_string.size()) { // this again is highly unlikely, but still ...
lua_pop(L, 1);
continue;
}
if (key_string[0] == '_') {
lua_pop(L, 1);
continue;
}
string value_string;
// convert the value to a string. This depends on its type
switch (value_type) {
case LUA_TSTRING:
case LUA_TNUMBER:
// numbers can be converted to strings
// get the value as a string (this requires a copy because traversing tables
// uses the top of the stack as an index. If conversion from a number to string
// happens, the top of the stack will be altered and the table index will become invalid)
lua_pushvalue(L, -1);
value_string = lua_tostring(L, -1);
lua_pop(L, 1);
break;
case LUA_TBOOLEAN:
value_string = lua_toboolean(L, -1) == 0 ? "false" : "true";
break;
}
// enclose the value in "" if it is a string
if (value_type == LUA_TSTRING) {
value_string = "\"" + value_string + "\"";
}
// resulting line. Somehow save this and when you need to restore it, just
// call luaL_dostring with that line.
//SaveLine(key_string + " = " + value_string); // Pop the value so the index remains on top of the stack for the next iteration
printf("Found global LUA var: %s = %s\n", key_string.c_str(), value_string.c_str());
lua_pop(L, 1);
}
#if LUA_VERSION_NUM > 501
lua_pop(L, 1);
#endif
}
void LuaScript::saveGame(XmlNode *rootNode) {
std::map<string, string> mapTagReplacements;
//try{
LuaHandle *L = luaState;
// push the first key (nil = beginning of table)
#if LUA_VERSION_NUM <= 501
lua_pushnil(L);
#endif
// lua_next will:
// 1 - pop the key
// 2 - push the next key
// 3 - push the value at that key
// ... so the key will be at index -2 and the value at index -1
#if LUA_VERSION_NUM > 501
lua_pushglobaltable(L);
lua_pushnil(L);
while (lua_next(L, -2) != 0) {
#else
while (lua_next(L, LUA_GLOBALSINDEX) != 0) {
#endif
// get type of key and value
int key_type = lua_type(L, -2);
int value_type = lua_type(L, -1);
if (LuaScript::debugModeEnabled == true) printf("LUA save key_type = %d, value_type = %d for var [%s]\n", key_type, value_type, lua_tostring(L, -2));
// support only string keys
// globals aren't likely to have a non-string key, but just to be certain ...
if (key_type != LUA_TSTRING) {
lua_pop(L, 1); // pop the value so that the top contains the key for the next iteration
continue;
}
// support only number, boolean and string values
if (value_type != LUA_TNUMBER &&
value_type != LUA_TBOOLEAN &&
value_type != LUA_TSTRING &&
value_type != LUA_TTABLE) {
lua_pop(L, 1); // again, pop the value before going to the next loop iteration
continue;
}
// get the key as a string
string key_string = lua_tostring(L, -2); // no copy required - we already know this is a string
if (LuaScript::debugModeEnabled == true) printf("key_string [%s]\n", key_string.c_str());
// do not support variables that start with '_'
// lua has some predefined values like _VERSION. They all start with underscore
if (!key_string.size()) { // this again is highly unlikely, but still ...
lua_pop(L, 1);
continue;
}
if (key_string[0] == '_') {
lua_pop(L, 1);
continue;
}
bool skipTable = false;
// The first pair is the tables key type,value
// The second pair is the tables value type,value
vector<pair<pair<int, string>, pair<int, string> > > tableList;
string value_string;
// convert the value to a string. This depends on its type
switch (value_type) {
case LUA_TSTRING:
case LUA_TNUMBER:
// numbers can be converted to strings
// get the value as a string (this requires a copy because traversing tables
// uses the top of the stack as an index. If conversion from a number to string
// happens, the top of the stack will be altered and the table index will become invalid)
lua_pushvalue(L, -1);
value_string = lua_tostring(L, -1);
lua_pop(L, 1);
break;
case LUA_TBOOLEAN:
value_string = lua_toboolean(L, -1) == 0 ? "false" : "true";
break;
case LUA_TTABLE:
{
int tableItemCount = 0;
if (LuaScript::debugModeEnabled == true) printf("================ LUA TABLE DETECTED - START =================\n");
for (lua_pushnil(L); lua_next(L, -2);) {
tableItemCount++;
if (LuaScript::debugModeEnabled == true) printf("LUA TABLE loop A\n");
int tableKeyType = lua_type(L, -2);
int tableValueType = lua_type(L, -1);
if (LuaScript::debugModeEnabled == true) printf("LUA TABLE loop item type [%s] key: %d value type: %d\n", lua_typename(L, tableValueType), tableKeyType, tableValueType);
switch (tableValueType) {
case LUA_TSTRING:
case LUA_TNUMBER:
case LUA_TBOOLEAN:
break;
default:
skipTable = true;
break;
}
if (skipTable == false) {
// Stack: value, key, table
std::string value = "";
if (!lua_isnil(L, -1)) {
if (LuaScript::debugModeEnabled == true) printf("LUA TABLE loop B\n");
lua_pushvalue(L, -1);
if (LuaScript::debugModeEnabled == true) printf("LUA TABLE loop C\n");
if (tableValueType == LUA_TBOOLEAN) {
value = lua_toboolean(L, -1) == 0 ? "false" : "true";
} else {
value = lua_tostring(L, -1);
}
if (LuaScript::debugModeEnabled == true) printf("LUA TABLE loop D\n");
lua_pop(L, 1);
}
lua_pop(L, 1);
if (LuaScript::debugModeEnabled == true) printf("LUA TABLE value [%s]\n", value.c_str());
// Stack: key, table
lua_pushvalue(L, -1);
// Stack: key, key, table
std::string key = lua_tostring(L, -1);
lua_pop(L, 1);
// Stack: key, table
//std :: cout << key << "" << value << "\ n";
if (LuaScript::debugModeEnabled == true) printf("[%s] [%s]\n", key.c_str(), value.c_str());
if (value_string != "") {
value_string += "|||";
}
char szBuf[8096] = "";
snprintf(szBuf, 8096, "[%s] [%s]", key.c_str(), value.c_str());
//value_string += szBuf;
//vector<pair<pair<int,string>, pair<int,string>> > tableList;
tableList.push_back(make_pair(make_pair(tableKeyType, key), make_pair(tableValueType, value)));
} else {
if (LuaScript::debugModeEnabled == true) printf("***WARNING*** SKIPPING LUA TABLE because it has an unsupported embedded type: %d [%s]\n", tableValueType, lua_typename(L, tableValueType));
lua_pop(L, 1);
}
}
if (tableItemCount < 1) {
if (LuaScript::debugModeEnabled == true) printf("Skipping lua table tableItemCount = %d\n", tableItemCount);
skipTable = true;
}
if (LuaScript::debugModeEnabled == true) printf("---------------------------- LUA TABLE DETECTED - END ----------------------------\n");
}
break;
}
// enclose the value in "" if it is a string
//if (value_type == LUA_TSTRING) {
//value_string = "\"" + value_string + "\"";
//}
if (skipTable == true) {
if (LuaScript::debugModeEnabled == true) printf("#2 SKIPPING TABLE\n");
} else {
//vector<pair<pair<int,string>, pair<int,string>> > tableList;
if (tableList.empty() == false) {
XmlNode *luaScriptNode = rootNode->addChild("LuaScript");
luaScriptNode->addAttribute("variable", key_string, mapTagReplacements);
luaScriptNode->addAttribute("value_type", intToStr(value_type), mapTagReplacements);
for (unsigned int i = 0; i < tableList.size(); ++i) {
pair<pair<int, string>, pair<int, string> > &item = tableList[i];
XmlNode *luaScriptTableNode = luaScriptNode->addChild("Table");
luaScriptTableNode->addAttribute("key_type", intToStr(item.first.first), mapTagReplacements);
luaScriptTableNode->addAttribute("key", item.first.second, mapTagReplacements);
luaScriptTableNode->addAttribute("value", item.second.second, mapTagReplacements);
luaScriptTableNode->addAttribute("value_type", intToStr(item.second.first), mapTagReplacements);
}
} else {
// resulting line. Somehow save this and when you need to restore it, just
// call luaL_dostring with that line.
//SaveLine(key_string + " = " + value_string); // Pop the value so the index remains on top of the stack for the next iteration
//printf("Found global LUA var: %s = %s\n",key_string.c_str(),value_string.c_str());
XmlNode *luaScriptNode = rootNode->addChild("LuaScript");
luaScriptNode->addAttribute("variable", key_string, mapTagReplacements);
luaScriptNode->addAttribute("value", value_string, mapTagReplacements);
luaScriptNode->addAttribute("value_type", intToStr(value_type), mapTagReplacements);
}
}
lua_pop(L, 1);
}
#if LUA_VERSION_NUM > 501
lua_pop(L, 1);
#endif
//}
//catch(const exception &ex) {
// abort();
//}
}
void LuaScript::loadGame(const XmlNode *rootNode) {
if (LuaScript::debugModeEnabled) printf("START [%s::%s] Line: %d\n", extractFileFromDirectoryPath(__FILE__).c_str(), __FUNCTION__, __LINE__);
vector<XmlNode *> luaScriptNodeList = rootNode->getChildList("LuaScript");
if (LuaScript::debugModeEnabled) printf("luaScriptNodeList.size(): %d\n", (int) luaScriptNodeList.size());
for (unsigned int i = 0; i < luaScriptNodeList.size(); ++i) {
XmlNode *node = luaScriptNodeList[i];
string variable = node->getAttribute("variable")->getValue();
int value_type = node->getAttribute("value_type")->getIntValue();
if (LuaScript::debugModeEnabled) printf(" index #: %u [%s] [%d]\n", i, variable.c_str(), value_type);
switch (value_type) {
case LUA_TSTRING:
if (LuaScript::debugModeEnabled) printf(" value [%s]\n", node->getAttribute("value")->getValue().c_str());
lua_pushstring(luaState, node->getAttribute("value")->getValue().c_str());
break;
case LUA_TNUMBER:
if (LuaScript::debugModeEnabled) printf(" value [%s]\n", node->getAttribute("value")->getValue().c_str());
lua_pushnumber(luaState, node->getAttribute("value")->getFloatValue());
break;
case LUA_TBOOLEAN:
if (LuaScript::debugModeEnabled) printf(" value [%s]\n", node->getAttribute("value")->getValue().c_str());
lua_pushboolean(luaState, node->getAttribute("value")->getBoolValue());
break;
case LUA_TTABLE:
{
if (LuaScript::debugModeEnabled == true) printf("================ LUA TABLE DETECTED - START =================\n");
lua_newtable(luaState); /* We will pass a table */
vector<XmlNode *> luaScriptTableNode = node->getChildList("Table");
if (LuaScript::debugModeEnabled) printf("luaScriptTableNode.size(): %d\n", (int) luaScriptTableNode.size());
for (unsigned int j = 0; j < luaScriptTableNode.size(); ++j) {
XmlNode *nodeTable = luaScriptTableNode[j];
int key_type = nodeTable->getAttribute("key_type")->getIntValue();
if (LuaScript::debugModeEnabled == true) printf("Table item key_type: %d [%s]\n", key_type, lua_typename(luaState, key_type));
switch (key_type) {
case LUA_TSTRING:
if (LuaScript::debugModeEnabled) printf(" table item key [%s]\n", nodeTable->getAttribute("key")->getValue().c_str());
lua_pushstring(luaState, nodeTable->getAttribute("key")->getValue().c_str());
break;
case LUA_TNUMBER:
if (LuaScript::debugModeEnabled) printf(" table item key [%s]\n", nodeTable->getAttribute("key")->getValue().c_str());
lua_pushnumber(luaState, nodeTable->getAttribute("key")->getFloatValue());
break;
case LUA_TBOOLEAN:
if (LuaScript::debugModeEnabled) printf(" table item key [%s]\n", nodeTable->getAttribute("key")->getValue().c_str());
lua_pushboolean(luaState, nodeTable->getAttribute("key")->getBoolValue());
break;
}
int value_type = nodeTable->getAttribute("value_type")->getIntValue();
if (LuaScript::debugModeEnabled == true) printf("Table item value_type: %d [%s]\n", value_type, lua_typename(luaState, value_type));
switch (value_type) {
case LUA_TSTRING:
if (LuaScript::debugModeEnabled) printf(" table item value [%s]\n", nodeTable->getAttribute("value")->getValue().c_str());
lua_pushstring(luaState, nodeTable->getAttribute("value")->getValue().c_str());
break;
case LUA_TNUMBER:
if (LuaScript::debugModeEnabled) printf(" table item value [%s]\n", nodeTable->getAttribute("value")->getValue().c_str());
lua_pushnumber(luaState, nodeTable->getAttribute("value")->getFloatValue());
break;
case LUA_TBOOLEAN:
if (LuaScript::debugModeEnabled) printf(" table item value [%s]\n", nodeTable->getAttribute("value")->getValue().c_str());
lua_pushboolean(luaState, nodeTable->getAttribute("value")->getBoolValue());
break;
}
lua_rawset(luaState, -3); /* Stores the pair in the table */
}
if (LuaScript::debugModeEnabled == true) printf("----------------- LUA TABLE DETECTED - END -----------------\n");
}
break;
}
lua_setglobal(luaState, variable.c_str());
}
}
LuaScript::~LuaScript() {
Lua_STREFLOP_Wrapper streflopWrapper;
// LuaInterface.LuaTable luatab;
//
// luatab = lua.GetTable("_G");
//
//
// foreach (DictionaryEntry d in luatab)
//
// {
//
// Console.WriteLine("{0} -> {1}", d.Key, d.Value);
//
// }
//DumpGlobals();
lua_close(luaState);
}
void LuaScript::loadCode(string code, string name) {
Lua_STREFLOP_Wrapper streflopWrapper;
//printf("Code [%s]\nName [%s]\n",code.c_str(),name.c_str());
int errorCode = luaL_loadbuffer(luaState, code.c_str(), code.length(), name.c_str());
if (errorCode != 0) {
printf("=========================================================\n");
printf("Error loading lua code: %s\n", errorToString(errorCode).c_str());
printf("Function name [%s]\ncode:\n%s\n", name.c_str(), code.c_str());
printf("=========================================================\n");
throw megaglest_runtime_error("Error loading lua code: " + errorToString(errorCode), true);
}
if (SystemFlags::getSystemSettingType(SystemFlags::debugLUA).enabled) SystemFlags::OutputDebug(SystemFlags::debugLUA, "In [%s::%s Line: %d] name [%s], errorCode = %d\n", __FILE__, __FUNCTION__, __LINE__, name.c_str(), errorCode);
//run code
errorCode = lua_pcall(luaState, 0, 0, 0);
if (errorCode != 0) {
printf("=========================================================\n");
printf("Error calling lua pcall: %s\n", errorToString(errorCode).c_str());
printf("=========================================================\n");
throw megaglest_runtime_error("Error initializing lua: " + errorToString(errorCode), true);
}
//const char *errMsg = lua_tostring(luaState, -1);
//printf("END of call to Name [%s]\n",name.c_str());
if (SystemFlags::getSystemSettingType(SystemFlags::debugLUA).enabled) SystemFlags::OutputDebug(SystemFlags::debugLUA, "In [%s::%s Line: %d] name [%s], errorCode = %d\n", __FILE__, __FUNCTION__, __LINE__, name.c_str(), errorCode);
}
void LuaScript::setSandboxWrapperFunctionName(string name) {
sandboxWrapperFunctionName = name;
}
void LuaScript::setSandboxCode(string code) {
sandboxCode = code;
}
int LuaScript::runCode(string code) {
Lua_STREFLOP_Wrapper streflopWrapper;
int errorCode = luaL_dostring(luaState, code.c_str());
return errorCode;
}
void LuaScript::beginCall(string functionName) {
Lua_STREFLOP_Wrapper streflopWrapper;
currentLuaFunction = functionName;
if (SystemFlags::getSystemSettingType(SystemFlags::debugLUA).enabled) SystemFlags::OutputDebug(SystemFlags::debugLUA, "In [%s::%s Line: %d] functionName [%s]\n", __FILE__, __FUNCTION__, __LINE__, functionName.c_str());
if (SystemFlags::getSystemSettingType(SystemFlags::debugPerformance).enabled) SystemFlags::OutputDebug(SystemFlags::debugPerformance, "In [%s::%s Line: %d] functionName [%s]\n", __FILE__, __FUNCTION__, __LINE__, functionName.c_str());
//string funcLuaFunction = functionName;
// if(sandboxWrapperFunctionName != "" && sandboxCode != "") {
// int errorCode= runCode(sandboxCode);
// if(errorCode !=0 ) {
// throw megaglest_runtime_error("Error calling lua function [" + currentLuaFunction + "] error: " + errorToString(errorCode));
// }
// //functionName = sandboxWrapperFunctionName;
// }
lua_getglobal(luaState, functionName.c_str());
currentLuaFunctionIsValid = lua_isfunction(luaState, lua_gettop(luaState));
//printf("currentLuaFunctionIsValid = %d functionName [%s]\n",currentLuaFunctionIsValid,functionName.c_str());
argumentCount = 0;
}
void LuaScript::endCall() {
Lua_STREFLOP_Wrapper streflopWrapper;
if (SystemFlags::getSystemSettingType(SystemFlags::debugLUA).enabled) SystemFlags::OutputDebug(SystemFlags::debugLUA, "In [%s::%s Line: %d] currentLuaFunction [%s], currentLuaFunctionIsValid = %d\n", __FILE__, __FUNCTION__, __LINE__, currentLuaFunction.c_str(), currentLuaFunctionIsValid);
if (currentLuaFunctionIsValid == true) {
if (sandboxWrapperFunctionName != "" && sandboxCode != "") {
//lua_pushstring(luaState, currentLuaFunction.c_str()); // push 1st argument, the real lua function
//argumentCount = 1;
string safeWrapper = sandboxWrapperFunctionName + " [[" + currentLuaFunction + "()]]";
printf("Trying to execute [%s]\n", safeWrapper.c_str());
int errorCode = runCode(safeWrapper);
if (errorCode != 0) {
throw megaglest_runtime_error("Error calling lua function [" + currentLuaFunction + "] error: " + errorToString(errorCode), true);
}
//printf("Trying to execute [%s]\n",currentLuaFunction.c_str());
//lua_getglobal(luaState, sandboxWrapperFunctionName.c_str());
//argumentCount = 1;
//lua_pushstring( luaState, currentLuaFunction.c_str() );
// int errorCode= lua_pcall(luaState, argumentCount, 0, 0);
// if(errorCode !=0 ) {
// throw megaglest_runtime_error("Error calling lua function [" + currentLuaFunction + "] error: " + errorToString(errorCode));
// }
} else {
int errorCode = lua_pcall(luaState, argumentCount, 0, 0);
if (errorCode != 0) {
throw megaglest_runtime_error("Error calling lua function [" + currentLuaFunction + "] error: " + errorToString(errorCode), true);
}
}
} else {
lua_pcall(luaState, argumentCount, 0, 0);
}
}
void LuaScript::registerFunction(LuaFunction luaFunction, string functionName) {
Lua_STREFLOP_Wrapper streflopWrapper;
if (SystemFlags::getSystemSettingType(SystemFlags::debugLUA).enabled) SystemFlags::OutputDebug(SystemFlags::debugLUA, "In [%s::%s Line: %d] functionName [%s]\n", __FILE__, __FUNCTION__, __LINE__, functionName.c_str());
lua_pushcfunction(luaState, luaFunction);
lua_setglobal(luaState, functionName.c_str());
}
string LuaScript::errorToString(int errorCode) {
Lua_STREFLOP_Wrapper streflopWrapper;
string error;
switch (errorCode) {
case LUA_ERRSYNTAX:
error += "Syntax error";
break;
case LUA_ERRRUN:
error += "Runtime error";
break;
case LUA_ERRMEM:
error += "Memory allocation error";
break;
case LUA_ERRERR:
error += "Error while running the error handler";
break;
default:
error += "Unknown LUA error" + intToStr(errorCode);
break;
}
error += string(": ") + luaL_checkstring(luaState, -1);
return error;
}
// =====================================================
// class LuaArguments
// =====================================================
LuaArguments::LuaArguments(lua_State *luaState) {
Lua_STREFLOP_Wrapper streflopWrapper;
this->luaState = luaState;
returnCount = 0;
}
int LuaArguments::getInt(int argumentIndex) const {
Lua_STREFLOP_Wrapper streflopWrapper;
if (!lua_isnumber(luaState, argumentIndex)) {
throwLuaError("Can not get int from Lua state");
}
int result = (int) luaL_checkinteger(luaState, argumentIndex);
return result;
}
float LuaArguments::getFloat(int argumentIndex) const {
Lua_STREFLOP_Wrapper streflopWrapper;
if (!lua_isnumber(luaState, argumentIndex)) {
throwLuaError("Can not get int from Lua state");
}
float result = static_cast<float>(luaL_checknumber(luaState, argumentIndex));
return result;
}
Vec2f LuaArguments::getVec2f(int argumentIndex) const {
Lua_STREFLOP_Wrapper streflopWrapper;
Vec2f v;
if (!lua_istable(luaState, argumentIndex)) {
throwLuaError("Can not get vec2f from Lua state, value on the stack is not a table");
}
#if LUA_VERSION_NUM > 501
if (lua_rawlen(luaState, argumentIndex) != 2) {
#else
if (luaL_getn(luaState, argumentIndex) != 2) {
#endif
throwLuaError("Can not get vec2f from Lua state, array size not 2");
}
//string stackString = getStackText();
//printf("Lua Stack:\n%s\n",stackString.c_str());
lua_rawgeti(luaState, argumentIndex, 1);
//printf("xa = %s argumentIndex = %d\n",lua_tostring(luaState, argumentIndex),argumentIndex);
//v.x= (int)luaL_checkinteger(luaState, argumentIndex);
v.x = static_cast<float>(lua_tonumber(luaState, argumentIndex));
lua_pop(luaState, 1);
//printf("X = %d\n",v.x);
lua_rawgeti(luaState, argumentIndex, 2);
//printf("ya = %s\n",lua_tostring(luaState, argumentIndex));
//v.y= (int)luaL_checkinteger(luaState, argumentIndex);
v.y = static_cast<float>(lua_tonumber(luaState, argumentIndex));
lua_pop(luaState, 1);
//printf("Y = %d\n",v.y);
return v;
}
Vec3f LuaArguments::getVec3f(int argumentIndex) const {
Lua_STREFLOP_Wrapper streflopWrapper;
Vec3f v;
if (!lua_istable(luaState, argumentIndex)) {
throwLuaError("Can not get vec3f from Lua state, value on the stack is not a table");
}
#if LUA_VERSION_NUM > 501
if (lua_rawlen(luaState, argumentIndex) != 3) {
#else
if (luaL_getn(luaState, argumentIndex) != 3) {
#endif
throwLuaError("Can not get vec3f from Lua state, array size not 3");
}
//string stackString = getStackText();
//printf("Lua Stack:\n%s\n",stackString.c_str());
lua_rawgeti(luaState, argumentIndex, 1);
//printf("xa = %s argumentIndex = %d\n",lua_tostring(luaState, argumentIndex),argumentIndex);
//v.x= (int)luaL_checkinteger(luaState, argumentIndex);
v.x = static_cast<float>(lua_tonumber(luaState, argumentIndex));
lua_pop(luaState, 1);
//printf("X = %d\n",v.x);
lua_rawgeti(luaState, argumentIndex, 2);
//printf("ya = %s\n",lua_tostring(luaState, argumentIndex));
//v.y= (int)luaL_checkinteger(luaState, argumentIndex);
v.y = static_cast<float>(lua_tonumber(luaState, argumentIndex));
lua_pop(luaState, 1);
//printf("Y = %d\n",v.y);
lua_rawgeti(luaState, argumentIndex, 3);
//printf("ya = %s\n",lua_tostring(luaState, argumentIndex));
//v.y= (int)luaL_checkinteger(luaState, argumentIndex);
v.z = static_cast<float>(lua_tonumber(luaState, argumentIndex));
lua_pop(luaState, 1);
return v;
}
Vec4f LuaArguments::getVec4f(int argumentIndex) const {
Lua_STREFLOP_Wrapper streflopWrapper;
Vec4f v;
if (!lua_istable(luaState, argumentIndex)) {
throwLuaError("Can not get vec4f from Lua state, value on the stack is not a table");
}
#if LUA_VERSION_NUM > 501
if (lua_rawlen(luaState, argumentIndex) != 4) {
#else
if (luaL_getn(luaState, argumentIndex) != 4) {
#endif
throwLuaError("Can not get vec4f from Lua state, array size not 4");
}
//string stackString = getStackText();
//printf("Lua Stack:\n%s\n",stackString.c_str());
lua_rawgeti(luaState, argumentIndex, 1);
//printf("xa = %s argumentIndex = %d\n",lua_tostring(luaState, argumentIndex),argumentIndex);
//v.x= (int)luaL_checkinteger(luaState, argumentIndex);
v.x = static_cast<float>(lua_tonumber(luaState, argumentIndex));
lua_pop(luaState, 1);
//printf("X = %d\n",v.x);
lua_rawgeti(luaState, argumentIndex, 2);
//printf("ya = %s\n",lua_tostring(luaState, argumentIndex));
//v.y= (int)luaL_checkinteger(luaState, argumentIndex);
v.y = static_cast<float>(lua_tonumber(luaState, argumentIndex));
lua_pop(luaState, 1);
//printf("Y = %d\n",v.y);
lua_rawgeti(luaState, argumentIndex, 3);
//printf("ya = %s\n",lua_tostring(luaState, argumentIndex));
//v.y= (int)luaL_checkinteger(luaState, argumentIndex);
v.z = static_cast<float>(lua_tonumber(luaState, argumentIndex));
lua_pop(luaState, 1);
lua_rawgeti(luaState, argumentIndex, 4);
//printf("ya = %s\n",lua_tostring(luaState, argumentIndex));
//v.y= (int)luaL_checkinteger(luaState, argumentIndex);
v.w = static_cast<float>(lua_tonumber(luaState, argumentIndex));
lua_pop(luaState, 1);
return v;
}
string LuaArguments::getString(int argumentIndex) const {
Lua_STREFLOP_Wrapper streflopWrapper;
if (!lua_isstring(luaState, argumentIndex)) {
throwLuaError("Can not get string from Lua state");
}
return luaL_checkstring(luaState, argumentIndex);
}
void * LuaArguments::getGenericData(int argumentIndex) const {
Lua_STREFLOP_Wrapper streflopWrapper;
if (lua_isstring(luaState, argumentIndex)) {
const char *result = luaL_checkstring(luaState, argumentIndex);
//printf("\nGENERIC param %d is a string, %s!\n",argumentIndex,result);
return (void *) result;
}
//else if(lua_isnumber(luaState, argumentIndex)) {
// double result = luaL_checknumber(luaState, argumentIndex);
// printf("\nGENERIC param %d is a double, %f!\n",argumentIndex,result);
// return (void *)result;
//}
else if (lua_isnumber(luaState, argumentIndex)) {
lua_Integer result = luaL_checkinteger(luaState, argumentIndex);
//printf("\nGENERIC param %d is an int, %d!\n",argumentIndex,(int)result);
return (void *) result;
} else {
//printf("\nGENERIC param %d is a NULL!\n",argumentIndex);
return NULL;
}
}
Vec2i LuaArguments::getVec2i(int argumentIndex) const {
Lua_STREFLOP_Wrapper streflopWrapper;
Vec2i v;
if (!lua_istable(luaState, argumentIndex)) {
throwLuaError("Can not get vec2i from Lua state, value on the stack is not a table");
}
#if LUA_VERSION_NUM > 501
if (lua_rawlen(luaState, argumentIndex) != 2) {
#else
if (luaL_getn(luaState, argumentIndex) != 2) {
#endif
throwLuaError("Can not get vec2i from Lua state, array size not 2");
}
//string stackString = getStackText();
//printf("Lua Stack:\n%s\n",stackString.c_str());
lua_rawgeti(luaState, argumentIndex, 1);
//printf("xa = %s argumentIndex = %d\n",lua_tostring(luaState, argumentIndex),argumentIndex);
//v.x= (int)luaL_checkinteger(luaState, argumentIndex);
v.x = (int) lua_tointeger(luaState, argumentIndex);
lua_pop(luaState, 1);
//printf("X = %d\n",v.x);
lua_rawgeti(luaState, argumentIndex, 2);
//printf("ya = %s\n",lua_tostring(luaState, argumentIndex));
//v.y= (int)luaL_checkinteger(luaState, argumentIndex);
v.y = (int) lua_tointeger(luaState, argumentIndex);
lua_pop(luaState, 1);
//printf("Y = %d\n",v.y);
return v;
}
Vec4i LuaArguments::getVec4i(int argumentIndex) const {
Lua_STREFLOP_Wrapper streflopWrapper;
Vec4i v;
if (!lua_istable(luaState, argumentIndex)) {
throwLuaError("Can not get vec4i from Lua state, value on the stack is not a table");
}
#if LUA_VERSION_NUM > 501
if (lua_rawlen(luaState, argumentIndex) != 4) {
#else
if (luaL_getn(luaState, argumentIndex) != 4) {
#endif
throwLuaError("Can not get vec4i from Lua state, array size not 4");
}
lua_rawgeti(luaState, argumentIndex, 1);
v.x = (int) luaL_checkinteger(luaState, argumentIndex);
lua_pop(luaState, 1);
lua_rawgeti(luaState, argumentIndex, 2);
v.y = (int) luaL_checkinteger(luaState, argumentIndex);
lua_pop(luaState, 1);
lua_rawgeti(luaState, argumentIndex, 3);
v.z = (int) luaL_checkinteger(luaState, argumentIndex);
lua_pop(luaState, 1);
lua_rawgeti(luaState, argumentIndex, 4);
v.w = (int) luaL_checkinteger(luaState, argumentIndex);
lua_pop(luaState, 1);
return v;
}
void LuaArguments::returnInt(int value) {
Lua_STREFLOP_Wrapper streflopWrapper;
++returnCount;
lua_pushinteger(luaState, value);
}
void LuaArguments::returnFloat(float value) {
Lua_STREFLOP_Wrapper streflopWrapper;
++returnCount;
lua_pushnumber(luaState, value);
}
void LuaArguments::returnString(const string &value) {
Lua_STREFLOP_Wrapper streflopWrapper;
++returnCount;
lua_pushstring(luaState, value.c_str());
}
void LuaArguments::returnVec2i(const Vec2i &value) {
//Lua_STREFLOP_Wrapper streflopWrapper;
++returnCount;
lua_newtable(luaState);
lua_pushnumber(luaState, value.x);
lua_rawseti(luaState, -2, 1);
lua_pushnumber(luaState, value.y);
lua_rawseti(luaState, -2, 2);
}
void LuaArguments::returnVec4i(const Vec4i &value) {
//Lua_STREFLOP_Wrapper streflopWrapper;
++returnCount;
lua_newtable(luaState);
lua_pushnumber(luaState, value.x);
lua_rawseti(luaState, -2, 1);
lua_pushnumber(luaState, value.y);
lua_rawseti(luaState, -2, 2);
lua_pushnumber(luaState, value.z);
lua_rawseti(luaState, -2, 3);
lua_pushnumber(luaState, value.w);
lua_rawseti(luaState, -2, 4);
}
void LuaArguments::returnVectorInt(const vector<int> &value) {
//Lua_STREFLOP_Wrapper streflopWrapper;
++returnCount;
lua_newtable(luaState);
for (unsigned int i = 0; i < value.size(); ++i) {
lua_pushnumber(luaState, value[i]);
lua_rawseti(luaState, -2, i + 1);
}
}
string LuaArguments::getStackText() const {
Lua_STREFLOP_Wrapper streflopWrapper;
string stackString;
int stackSize = lua_gettop(luaState);
//build stack string
for (int i = 1; i <= stackSize; ++i) {
stackString += "-" + intToStr(i) + ": ";
if (lua_isnumber(luaState, -i)) {
stackString += "Number: " + doubleToStr(luaL_checknumber(luaState, -i));
} else if (lua_isstring(luaState, -i)) {
stackString += "String: " + string(luaL_checkstring(luaState, -i));
} else if (lua_istable(luaState, -i)) {
//int tableLen = 0;
#if LUA_VERSION_NUM > 501
int tableLen = lua_rawlen(luaState, -i);
#else
int tableLen = luaL_getn(luaState, -i);
#endif
stackString += "Table (" + intToStr(tableLen) + ")\n";
// for(unsigned int j = 1; j < tableLen; ++j) {
// stackString+= "entry# " + intToStr(j) + ", value = " + lua_tostring(luaState, -i) + "\n";
// }
// int j = 1;
// lua_pushnil(luaState); // The initial key for the traversal.
//
// printf("start loop\n");
//
// while (lua_next(luaState, -2)!=0) {
// printf("in loop j = %d\n",j);
//
// const char* Param=lua_tostring(luaState, -1);
//
// printf("passed in loop j = %d Param [%s]\n",j,(Param != NULL ? Param : "<nil>"));
//
// if (Param!=NULL) {
// stackString+= "entry# " + intToStr(j) + ", value = " + Param + "\n";
// }
//
// // Remove the value, keep the key for the next iteration.
// lua_pop(luaState, 1);
// j++;
// }
// const int len = lua_objlen( luaState, -i );
// printf("Table Len = %d\n",len);
//
// for ( int j = 1; j <= len; ++j ) {
// printf("A Table\n");
//
// lua_pushinteger( luaState, j );
//
// printf("B Table\n");
//
// lua_gettable( luaState, -2 );
//
// printf("C Table\n");
//
// //v.push_back( lua_tointeger( L, -1 ) );
// const char *value = lua_tostring( luaState, -1 );
// printf("D Table value = %s\n",(value != NULL ? value : "<nil>"));
//
// //v.push_back( lua_tointeger( L, -1 ) );
// const char *value2 = lua_tostring( luaState, -2 );
// printf("E Table value2 = %s\n",(value2 != NULL ? value2 : "<nil>"));
//
// value2 = lua_tostring( luaState, -3 );
// printf("F Table value2 = %s\n",(value2 != NULL ? value2 : "<nil>"));
//
// value2 = lua_tostring( luaState, 0 );
// printf("G Table value2 = %s\n",(value2 != NULL ? value2 : "<nil>"));
//
// value2 = lua_tostring( luaState, 1 );
// printf("H Table value2 = %s\n",(value2 != NULL ? value2 : "<nil>"));
//
// stackString+= "entry# " + intToStr(j) + ", value = " + (value != NULL ? value : "<nil>") + "\n";
//
// printf("E Table\n");
//
// lua_pop( luaState, 1 );
// }
} else {
stackString += "Unknown";
}
stackString += "\n";
}
return stackString;
}
void LuaArguments::throwLuaError(const string &message) const {
Lua_STREFLOP_Wrapper streflopWrapper;
string stackString = getStackText();
throw megaglest_runtime_error("Lua error: " + message + "\n\nLua Stack:\n" + stackString, true);
}
}
}//end namespace
Reference in New Issue View Git Blame Copy Permalink