915 lines
20 KiB
C++
915 lines
20 KiB
C++
// Copyright (C) 2017 Jérôme Leclercq
|
|
// This file is part of the "Nazara Engine - Lua scripting module"
|
|
// For conditions of distribution and use, see copyright notice in Config.hpp
|
|
|
|
#include <Nazara/Lua/LuaInstance.hpp>
|
|
#include <Lua/lauxlib.h>
|
|
#include <Lua/lua.h>
|
|
#include <Lua/lualib.h>
|
|
#include <Nazara/Core/Clock.hpp>
|
|
#include <Nazara/Core/Error.hpp>
|
|
#include <Nazara/Core/File.hpp>
|
|
#include <Nazara/Core/MemoryHelper.hpp>
|
|
#include <Nazara/Core/MemoryView.hpp>
|
|
#include <Nazara/Core/StringStream.hpp>
|
|
#include <cstdlib>
|
|
#include <stdexcept>
|
|
#include <unordered_map>
|
|
#include <Nazara/Lua/Debug.hpp>
|
|
|
|
namespace Nz
|
|
{
|
|
namespace
|
|
{
|
|
LuaType FromLuaType(int type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case LUA_TBOOLEAN:
|
|
return LuaType_Boolean;
|
|
|
|
case LUA_TFUNCTION:
|
|
return LuaType_Function;
|
|
|
|
case LUA_TLIGHTUSERDATA:
|
|
return LuaType_LightUserdata;
|
|
|
|
case LUA_TNIL:
|
|
return LuaType_Nil;
|
|
|
|
case LUA_TNONE:
|
|
return LuaType_None;
|
|
|
|
case LUA_TNUMBER:
|
|
return LuaType_Number;
|
|
|
|
case LUA_TSTRING:
|
|
return LuaType_String;
|
|
|
|
case LUA_TTABLE:
|
|
return LuaType_Table;
|
|
|
|
case LUA_TTHREAD:
|
|
return LuaType_Thread;
|
|
|
|
case LUA_TUSERDATA:
|
|
return LuaType_Userdata;
|
|
|
|
default:
|
|
return LuaType_None;
|
|
}
|
|
}
|
|
|
|
struct StreamData
|
|
{
|
|
Stream* stream;
|
|
char buffer[NAZARA_CORE_FILE_BUFFERSIZE];
|
|
};
|
|
|
|
int AtPanic(lua_State* state)
|
|
{
|
|
String lastError(lua_tostring(state, -1));
|
|
|
|
throw std::runtime_error("Lua panic: " + lastError);
|
|
}
|
|
|
|
const char* StreamReader(lua_State* state, void* data, std::size_t* size)
|
|
{
|
|
NazaraUnused(state);
|
|
|
|
StreamData* streamData = static_cast<StreamData*>(data);
|
|
|
|
if (streamData->stream->EndOfStream())
|
|
return nullptr;
|
|
else
|
|
{
|
|
*size = streamData->stream->Read(streamData->buffer, NAZARA_CORE_FILE_BUFFERSIZE);
|
|
return streamData->buffer;
|
|
}
|
|
}
|
|
|
|
int s_comparisons[] = {
|
|
LUA_OPEQ, // LuaComparison_Equality
|
|
LUA_OPLT, // LuaComparison_Less
|
|
LUA_OPLE // LuaComparison_LessOrEqual
|
|
};
|
|
|
|
static_assert(sizeof(s_comparisons)/sizeof(int) == LuaComparison_Max+1, "Lua comparison array is incomplete");
|
|
|
|
int s_operations[] = {
|
|
LUA_OPADD, // LuaOperation_Addition
|
|
LUA_OPBAND, // LuaOperation_BitwiseAnd
|
|
LUA_OPSHL, // LuaOperation_BitwiseLeftShift
|
|
LUA_OPBNOT, // LuaOperation_BitwiseNot
|
|
LUA_OPBOR, // LuaOperation_BitwiseOr
|
|
LUA_OPSHR, // LuaOperation_BitwiseRightShift
|
|
LUA_OPBXOR, // LuaOperation_BitwiseXOr
|
|
LUA_OPDIV, // LuaOperation_Division
|
|
LUA_OPPOW, // LuaOperation_Exponentiation
|
|
LUA_OPIDIV, // LuaOperation_FloorDivision
|
|
LUA_OPMUL, // LuaOperation_Multiplication
|
|
LUA_OPMOD, // LuaOperation_Modulo
|
|
LUA_OPUNM, // LuaOperation_Negation
|
|
LUA_OPSUB // LuaOperation_Substraction
|
|
};
|
|
|
|
static_assert(sizeof(s_operations)/sizeof(int) == LuaOperation_Max+1, "Lua operation array is incomplete");
|
|
|
|
int s_types[] = {
|
|
LUA_TBOOLEAN, // LuaType_Boolean
|
|
LUA_TFUNCTION, // LuaType_Function
|
|
LUA_TLIGHTUSERDATA, // LuaType_LightUserdata
|
|
LUA_TNIL, // LuaType_Nil
|
|
LUA_TNUMBER, // LuaType_Number
|
|
LUA_TNONE, // LuaType_None
|
|
LUA_TSTRING, // LuaType_String
|
|
LUA_TTABLE, // LuaType_Table
|
|
LUA_TTHREAD, // LuaType_Thread
|
|
LUA_TUSERDATA // LuaType_Userdata
|
|
};
|
|
|
|
static_assert(sizeof(s_types)/sizeof(int) == LuaType_Max+1, "Lua type array is incomplete");
|
|
}
|
|
|
|
LuaInstance::LuaInstance() :
|
|
m_memoryLimit(0),
|
|
m_memoryUsage(0),
|
|
m_timeLimit(1000),
|
|
m_level(0)
|
|
{
|
|
m_state = lua_newstate(MemoryAllocator, this);
|
|
lua_atpanic(m_state, AtPanic);
|
|
lua_sethook(m_state, TimeLimiter, LUA_MASKCOUNT, 1000);
|
|
luaL_openlibs(m_state);
|
|
}
|
|
|
|
LuaInstance::LuaInstance(LuaInstance&& instance) noexcept :
|
|
m_memoryLimit(instance.m_memoryLimit),
|
|
m_memoryUsage(instance.m_memoryUsage),
|
|
m_timeLimit(instance.m_timeLimit),
|
|
m_clock(std::move(instance.m_clock)),
|
|
m_lastError(std::move(instance.m_lastError)),
|
|
m_state(instance.m_state),
|
|
m_level(instance.m_level)
|
|
{
|
|
instance.m_state = nullptr;
|
|
|
|
lua_setallocf(m_state, MemoryAllocator, this);
|
|
}
|
|
|
|
LuaInstance::~LuaInstance()
|
|
{
|
|
if (m_state)
|
|
lua_close(m_state);
|
|
}
|
|
|
|
void LuaInstance::ArgCheck(bool condition, unsigned int argNum, const char* error) const
|
|
{
|
|
luaL_argcheck(m_state, condition, argNum, error);
|
|
}
|
|
|
|
void LuaInstance::ArgCheck(bool condition, unsigned int argNum, const String& error) const
|
|
{
|
|
luaL_argcheck(m_state, condition, argNum, error.GetConstBuffer());
|
|
}
|
|
|
|
int LuaInstance::ArgError(unsigned int argNum, const char* error) const
|
|
{
|
|
return luaL_argerror(m_state, argNum, error);
|
|
}
|
|
|
|
int LuaInstance::ArgError(unsigned int argNum, const String& error) const
|
|
{
|
|
return luaL_argerror(m_state, argNum, error.GetConstBuffer());
|
|
}
|
|
|
|
bool LuaInstance::Call(unsigned int argCount)
|
|
{
|
|
return Run(argCount, LUA_MULTRET);
|
|
}
|
|
|
|
bool LuaInstance::Call(unsigned int argCount, unsigned int resultCount)
|
|
{
|
|
return Run(argCount, resultCount);
|
|
}
|
|
|
|
void LuaInstance::CheckAny(int index) const
|
|
{
|
|
luaL_checkany(m_state, index);
|
|
}
|
|
|
|
bool LuaInstance::CheckBoolean(int index) const
|
|
{
|
|
if (lua_isnoneornil(m_state, index))
|
|
{
|
|
const char* msg = lua_pushfstring(m_state, "%s expected, got %s", lua_typename(m_state, LUA_TBOOLEAN), luaL_typename(m_state, index));
|
|
luaL_argerror(m_state, index, msg); // Lance une exception
|
|
return false;
|
|
}
|
|
|
|
return lua_toboolean(m_state, index) != 0;
|
|
}
|
|
|
|
bool LuaInstance::CheckBoolean(int index, bool defValue) const
|
|
{
|
|
if (lua_isnoneornil(m_state, index))
|
|
return defValue;
|
|
|
|
return lua_toboolean(m_state, index) != 0;
|
|
}
|
|
|
|
long long LuaInstance::CheckInteger(int index) const
|
|
{
|
|
return luaL_checkinteger(m_state, index);
|
|
}
|
|
|
|
long long LuaInstance::CheckInteger(int index, long long defValue) const
|
|
{
|
|
return luaL_optinteger(m_state, index, defValue);
|
|
}
|
|
|
|
double LuaInstance::CheckNumber(int index) const
|
|
{
|
|
return luaL_checknumber(m_state, index);
|
|
}
|
|
|
|
double LuaInstance::CheckNumber(int index, double defValue) const
|
|
{
|
|
return luaL_optnumber(m_state, index, defValue);
|
|
}
|
|
|
|
void LuaInstance::CheckStack(int space, const char* error) const
|
|
{
|
|
luaL_checkstack(m_state, space, error);
|
|
}
|
|
|
|
void LuaInstance::CheckStack(int space, const String& error) const
|
|
{
|
|
CheckStack(space, error.GetConstBuffer());
|
|
}
|
|
|
|
const char* LuaInstance::CheckString(int index, std::size_t* length) const
|
|
{
|
|
return luaL_checklstring(m_state, index, length);
|
|
}
|
|
|
|
const char* LuaInstance::CheckString(int index, const char* defValue, std::size_t* length) const
|
|
{
|
|
return luaL_optlstring(m_state, index, defValue, length);
|
|
}
|
|
|
|
void LuaInstance::CheckType(int index, LuaType type) const
|
|
{
|
|
#ifdef NAZARA_DEBUG
|
|
if (type > LuaType_Max)
|
|
{
|
|
NazaraError("Lua type out of enum");
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
luaL_checktype(m_state, index, s_types[type]);
|
|
}
|
|
|
|
void* LuaInstance::CheckUserdata(int index, const char* tname) const
|
|
{
|
|
return luaL_checkudata(m_state, index, tname);
|
|
}
|
|
|
|
void* LuaInstance::CheckUserdata(int index, const String& tname) const
|
|
{
|
|
return luaL_checkudata(m_state, index, tname.GetConstBuffer());
|
|
}
|
|
|
|
bool LuaInstance::Compare(int index1, int index2, LuaComparison comparison) const
|
|
{
|
|
#ifdef NAZARA_DEBUG
|
|
if (comparison > LuaComparison_Max)
|
|
{
|
|
NazaraError("Lua comparison out of enum");
|
|
return false;
|
|
}
|
|
#endif
|
|
|
|
return (lua_compare(m_state, index1, index2, s_comparisons[comparison]) != 0);
|
|
}
|
|
|
|
void LuaInstance::Compute(LuaOperation operation) const
|
|
{
|
|
#ifdef NAZARA_DEBUG
|
|
if (operation > LuaOperation_Max)
|
|
{
|
|
NazaraError("Lua operation out of enum");
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
lua_arith(m_state, s_operations[operation]);
|
|
}
|
|
|
|
void LuaInstance::Concatenate(int count) const
|
|
{
|
|
lua_concat(m_state, count);
|
|
}
|
|
|
|
int LuaInstance::CreateReference()
|
|
{
|
|
return luaL_ref(m_state, LUA_REGISTRYINDEX);
|
|
}
|
|
|
|
void LuaInstance::DestroyReference(int ref)
|
|
{
|
|
luaL_unref(m_state, LUA_REGISTRYINDEX, ref);
|
|
}
|
|
|
|
String LuaInstance::DumpStack() const
|
|
{
|
|
StringStream stream;
|
|
unsigned int stackTop = GetStackTop();
|
|
stream << stackTop << " entries\n";
|
|
|
|
for (unsigned int i = 1; i <= stackTop; ++i)
|
|
{
|
|
stream << i << ": ";
|
|
switch (GetType(i))
|
|
{
|
|
case LuaType_Boolean:
|
|
stream << "Boolean(" << ToBoolean(i) << ')';
|
|
break;
|
|
|
|
case LuaType_Function:
|
|
stream << "Function(" << ToPointer(i) << ')';
|
|
break;
|
|
|
|
case LuaType_LightUserdata:
|
|
case LuaType_Userdata:
|
|
stream << "Userdata(" << ToUserdata(i) << ')';
|
|
break;
|
|
|
|
case LuaType_Nil:
|
|
stream << "Nil";
|
|
break;
|
|
|
|
case LuaType_None:
|
|
stream << "None";
|
|
break;
|
|
|
|
case LuaType_Number:
|
|
stream << "Number(" << ToNumber(i) << ')';
|
|
break;
|
|
|
|
case LuaType_String:
|
|
stream << "String(" << ToString(i) << ')';
|
|
break;
|
|
|
|
case LuaType_Table:
|
|
stream << "Table(" << ToPointer(i) << ')';
|
|
break;
|
|
|
|
case LuaType_Thread:
|
|
stream << "Thread(" << ToPointer(i) << ')';
|
|
break;
|
|
|
|
default:
|
|
stream << "Unknown(" << ToPointer(i) << ')';
|
|
break;
|
|
}
|
|
|
|
stream << '\n';
|
|
}
|
|
|
|
return stream.ToString();
|
|
}
|
|
|
|
void LuaInstance::Error(const char* message) const
|
|
{
|
|
luaL_error(m_state, message);
|
|
}
|
|
|
|
void LuaInstance::Error(const String& message) const
|
|
{
|
|
luaL_error(m_state, message.GetConstBuffer());
|
|
}
|
|
|
|
bool LuaInstance::Execute(const String& code)
|
|
{
|
|
if (code.IsEmpty())
|
|
return true;
|
|
|
|
if (luaL_loadstring(m_state, code.GetConstBuffer()) != 0)
|
|
{
|
|
m_lastError = lua_tostring(m_state, -1);
|
|
lua_pop(m_state, 1);
|
|
|
|
return false;
|
|
}
|
|
|
|
return Run(0, 0);
|
|
}
|
|
|
|
bool LuaInstance::ExecuteFromFile(const String& filePath)
|
|
{
|
|
File file(filePath);
|
|
if (!file.Open(OpenMode_ReadOnly | OpenMode_Text))
|
|
{
|
|
NazaraError("Failed to open file");
|
|
return false;
|
|
}
|
|
|
|
std::size_t length = static_cast<std::size_t>(file.GetSize());
|
|
|
|
String source(length, '\0');
|
|
|
|
if (file.Read(&source[0], length) != length)
|
|
{
|
|
NazaraError("Failed to read file");
|
|
return false;
|
|
}
|
|
|
|
file.Close();
|
|
|
|
return Execute(source);
|
|
}
|
|
|
|
bool LuaInstance::ExecuteFromMemory(const void* data, std::size_t size)
|
|
{
|
|
MemoryView stream(data, size);
|
|
return ExecuteFromStream(stream);
|
|
}
|
|
|
|
bool LuaInstance::ExecuteFromStream(Stream& stream)
|
|
{
|
|
StreamData data;
|
|
data.stream = &stream;
|
|
|
|
if (lua_load(m_state, StreamReader, &data, "C++", nullptr) != 0)
|
|
{
|
|
m_lastError = lua_tostring(m_state, -1);
|
|
lua_pop(m_state, 1);
|
|
|
|
return false;
|
|
}
|
|
|
|
return Run(0, 0);
|
|
}
|
|
|
|
int LuaInstance::GetAbsIndex(int index) const
|
|
{
|
|
return lua_absindex(m_state, index);
|
|
}
|
|
|
|
LuaType LuaInstance::GetField(const char* fieldName, int tableIndex) const
|
|
{
|
|
return FromLuaType(lua_getfield(m_state, tableIndex, fieldName));
|
|
}
|
|
|
|
LuaType LuaInstance::GetField(const String& fieldName, int tableIndex) const
|
|
{
|
|
return FromLuaType(lua_getfield(m_state, tableIndex, fieldName.GetConstBuffer()));
|
|
}
|
|
|
|
LuaType LuaInstance::GetGlobal(const char* name) const
|
|
{
|
|
return FromLuaType(lua_getglobal(m_state, name));
|
|
}
|
|
|
|
LuaType LuaInstance::GetGlobal(const String& name) const
|
|
{
|
|
return FromLuaType(lua_getglobal(m_state, name.GetConstBuffer()));
|
|
}
|
|
|
|
LuaType LuaInstance::GetMetatable(const char* tname) const
|
|
{
|
|
return FromLuaType(luaL_getmetatable(m_state, tname));
|
|
}
|
|
|
|
LuaType LuaInstance::GetMetatable(const String& tname) const
|
|
{
|
|
return FromLuaType(luaL_getmetatable(m_state, tname.GetConstBuffer()));
|
|
}
|
|
|
|
bool LuaInstance::GetMetatable(int index) const
|
|
{
|
|
return lua_getmetatable(m_state, index) != 0;
|
|
}
|
|
|
|
unsigned int LuaInstance::GetStackTop() const
|
|
{
|
|
return static_cast<int>(lua_gettop(m_state));
|
|
}
|
|
|
|
LuaType LuaInstance::GetTable(int index) const
|
|
{
|
|
return FromLuaType(lua_gettable(m_state, index));
|
|
}
|
|
|
|
LuaType LuaInstance::GetType(int index) const
|
|
{
|
|
return FromLuaType(lua_type(m_state, index));
|
|
}
|
|
|
|
const char* LuaInstance::GetTypeName(LuaType type) const
|
|
{
|
|
#ifdef NAZARA_DEBUG
|
|
if (type > LuaType_Max)
|
|
{
|
|
NazaraError("Lua type out of enum");
|
|
return nullptr;
|
|
}
|
|
#endif
|
|
|
|
return lua_typename(m_state, s_types[type]);
|
|
}
|
|
|
|
void LuaInstance::Insert(int index) const
|
|
{
|
|
lua_insert(m_state, index);
|
|
}
|
|
|
|
bool LuaInstance::IsOfType(int index, LuaType type) const
|
|
{
|
|
switch (type)
|
|
{
|
|
case LuaType_Boolean:
|
|
return lua_isboolean(m_state, index) != 0;
|
|
|
|
case LuaType_Function:
|
|
return lua_isfunction(m_state, index) != 0;
|
|
|
|
case LuaType_LightUserdata:
|
|
return lua_islightuserdata(m_state, index) != 0;
|
|
|
|
case LuaType_Nil:
|
|
return lua_isnil(m_state, index) != 0;
|
|
|
|
case LuaType_None:
|
|
return lua_isnone(m_state, index) != 0;
|
|
|
|
case LuaType_Number:
|
|
return lua_isnumber(m_state, index) != 0;
|
|
|
|
case LuaType_String:
|
|
return lua_isstring(m_state, index) != 0;
|
|
|
|
case LuaType_Table:
|
|
return lua_istable(m_state, index) != 0;
|
|
|
|
case LuaType_Thread:
|
|
return lua_isthread(m_state, index) != 0;
|
|
|
|
case LuaType_Userdata:
|
|
return lua_isuserdata(m_state, index) != 0;
|
|
}
|
|
|
|
NazaraError("Lua type not handled (0x" + String::Number(type, 16) + ')');
|
|
return false;
|
|
}
|
|
|
|
bool LuaInstance::IsOfType(int index, const char* tname) const
|
|
{
|
|
void* ud = luaL_testudata(m_state, index, tname);
|
|
return ud != nullptr;
|
|
}
|
|
|
|
bool LuaInstance::IsOfType(int index, const String& tname) const
|
|
{
|
|
return IsOfType(index, tname.GetConstBuffer());
|
|
}
|
|
|
|
bool LuaInstance::IsValid(int index) const
|
|
{
|
|
return lua_isnoneornil(m_state, index) == 0;
|
|
}
|
|
|
|
long long LuaInstance::Length(int index) const
|
|
{
|
|
return luaL_len(m_state, index);
|
|
}
|
|
|
|
void LuaInstance::MoveTo(LuaInstance* instance, int n) const
|
|
{
|
|
lua_xmove(m_state, instance->m_state, n);
|
|
}
|
|
|
|
bool LuaInstance::NewMetatable(const char* str)
|
|
{
|
|
return luaL_newmetatable(m_state, str) != 0;
|
|
}
|
|
|
|
bool LuaInstance::NewMetatable(const String& str)
|
|
{
|
|
return luaL_newmetatable(m_state, str.GetConstBuffer()) != 0;
|
|
}
|
|
|
|
bool LuaInstance::Next(int index) const
|
|
{
|
|
return lua_next(m_state, index) != 0;
|
|
}
|
|
|
|
void LuaInstance::Pop(unsigned int n) const
|
|
{
|
|
lua_pop(m_state, static_cast<int>(n));
|
|
}
|
|
|
|
void LuaInstance::PushBoolean(bool value) const
|
|
{
|
|
lua_pushboolean(m_state, (value) ? 1 : 0);
|
|
}
|
|
|
|
void LuaInstance::PushCFunction(LuaCFunction func, unsigned int upvalueCount) const
|
|
{
|
|
lua_pushcclosure(m_state, func, upvalueCount);
|
|
}
|
|
|
|
void LuaInstance::PushFunction(LuaFunction func) const
|
|
{
|
|
LuaFunction* luaFunc = static_cast<LuaFunction*>(lua_newuserdata(m_state, sizeof(LuaFunction)));
|
|
PlacementNew(luaFunc, std::move(func));
|
|
|
|
lua_pushcclosure(m_state, ProxyFunc, 1);
|
|
}
|
|
|
|
void LuaInstance::PushInteger(long long value) const
|
|
{
|
|
lua_pushinteger(m_state, value);
|
|
}
|
|
|
|
void LuaInstance::PushLightUserdata(void* value) const
|
|
{
|
|
lua_pushlightuserdata(m_state, value);
|
|
}
|
|
|
|
void LuaInstance::PushMetatable(const char* str) const
|
|
{
|
|
luaL_getmetatable(m_state, str);
|
|
}
|
|
|
|
void LuaInstance::PushMetatable(const String& str) const
|
|
{
|
|
luaL_getmetatable(m_state, str.GetConstBuffer());
|
|
}
|
|
|
|
void LuaInstance::PushNil() const
|
|
{
|
|
lua_pushnil(m_state);
|
|
}
|
|
|
|
void LuaInstance::PushNumber(double value) const
|
|
{
|
|
lua_pushnumber(m_state, value);
|
|
}
|
|
|
|
void LuaInstance::PushReference(int ref) const
|
|
{
|
|
lua_rawgeti(m_state, LUA_REGISTRYINDEX, ref);
|
|
}
|
|
|
|
void LuaInstance::PushString(const char* str) const
|
|
{
|
|
lua_pushstring(m_state, str);
|
|
}
|
|
|
|
void LuaInstance::PushString(const char* str, std::size_t size) const
|
|
{
|
|
lua_pushlstring(m_state, str, size);
|
|
}
|
|
|
|
void LuaInstance::PushString(const String& str) const
|
|
{
|
|
lua_pushlstring(m_state, str.GetConstBuffer(), str.GetSize());
|
|
}
|
|
|
|
void LuaInstance::PushTable(std::size_t sequenceElementCount, std::size_t arrayElementCount) const
|
|
{
|
|
constexpr std::size_t maxInt = std::numeric_limits<int>::max();
|
|
lua_createtable(m_state, static_cast<int>(std::min(sequenceElementCount, maxInt)), static_cast<int>(std::min(arrayElementCount, maxInt)));
|
|
}
|
|
|
|
void* LuaInstance::PushUserdata(std::size_t size) const
|
|
{
|
|
return lua_newuserdata(m_state, size);
|
|
}
|
|
|
|
void LuaInstance::PushValue(int index) const
|
|
{
|
|
lua_pushvalue(m_state, index);
|
|
}
|
|
|
|
void LuaInstance::Remove(int index) const
|
|
{
|
|
lua_remove(m_state, index);
|
|
}
|
|
|
|
void LuaInstance::Replace(int index) const
|
|
{
|
|
lua_replace(m_state, index);
|
|
}
|
|
|
|
void LuaInstance::SetField(const char* name, int tableIndex) const
|
|
{
|
|
lua_setfield(m_state, tableIndex, name);
|
|
}
|
|
|
|
void LuaInstance::SetField(const String& name, int tableIndex) const
|
|
{
|
|
lua_setfield(m_state, tableIndex, name.GetConstBuffer());
|
|
}
|
|
|
|
void LuaInstance::SetGlobal(const char* name)
|
|
{
|
|
lua_setglobal(m_state, name);
|
|
}
|
|
|
|
void LuaInstance::SetGlobal(const String& name)
|
|
{
|
|
lua_setglobal(m_state, name.GetConstBuffer());
|
|
}
|
|
|
|
void LuaInstance::SetMetatable(const char* tname) const
|
|
{
|
|
luaL_setmetatable(m_state, tname);
|
|
}
|
|
|
|
void LuaInstance::SetMetatable(const String& tname) const
|
|
{
|
|
luaL_setmetatable(m_state, tname.GetConstBuffer());
|
|
}
|
|
|
|
void LuaInstance::SetMetatable(int index) const
|
|
{
|
|
lua_setmetatable(m_state, index);
|
|
}
|
|
|
|
void LuaInstance::SetMemoryLimit(std::size_t memoryLimit)
|
|
{
|
|
m_memoryLimit = memoryLimit;
|
|
}
|
|
|
|
void LuaInstance::SetTable(int index) const
|
|
{
|
|
lua_settable(m_state, index);
|
|
}
|
|
|
|
void LuaInstance::SetTimeLimit(UInt32 timeLimit)
|
|
{
|
|
if (m_timeLimit != timeLimit)
|
|
{
|
|
if (m_timeLimit == 0)
|
|
lua_sethook(m_state, TimeLimiter, LUA_MASKCOUNT, 1000);
|
|
else if (timeLimit == 0)
|
|
lua_sethook(m_state, TimeLimiter, 0, 1000);
|
|
|
|
m_timeLimit = timeLimit;
|
|
}
|
|
}
|
|
|
|
bool LuaInstance::ToBoolean(int index) const
|
|
{
|
|
return lua_toboolean(m_state, index) != 0;
|
|
}
|
|
|
|
long long LuaInstance::ToInteger(int index, bool* succeeded) const
|
|
{
|
|
int success;
|
|
long long result = lua_tointegerx(m_state, index, &success);
|
|
|
|
if (succeeded)
|
|
*succeeded = (success != 0);
|
|
|
|
return result;
|
|
}
|
|
|
|
double LuaInstance::ToNumber(int index, bool* succeeded) const
|
|
{
|
|
int success;
|
|
double result = lua_tonumberx(m_state, index, &success);
|
|
|
|
if (succeeded)
|
|
*succeeded = (success != 0);
|
|
|
|
return result;
|
|
}
|
|
|
|
const void* LuaInstance::ToPointer(int index) const
|
|
{
|
|
return lua_topointer(m_state, index);
|
|
}
|
|
|
|
const char* LuaInstance::ToString(int index, std::size_t* length) const
|
|
{
|
|
return lua_tolstring(m_state, index, length);
|
|
}
|
|
|
|
void* LuaInstance::ToUserdata(int index) const
|
|
{
|
|
return lua_touserdata(m_state, index);
|
|
}
|
|
|
|
void* LuaInstance::ToUserdata(int index, const char* tname) const
|
|
{
|
|
return luaL_testudata(m_state, index, tname);
|
|
}
|
|
|
|
void* LuaInstance::ToUserdata(int index, const String& tname) const
|
|
{
|
|
return luaL_testudata(m_state, index, tname.GetConstBuffer());
|
|
}
|
|
|
|
LuaInstance& LuaInstance::operator=(LuaInstance&& instance) noexcept
|
|
{
|
|
m_clock = std::move(instance.m_clock);
|
|
m_lastError = std::move(instance.m_lastError);
|
|
m_level = instance.m_level;
|
|
m_memoryLimit = instance.m_memoryLimit;
|
|
m_memoryUsage = instance.m_memoryUsage;
|
|
m_state = instance.m_state;
|
|
m_timeLimit = instance.m_timeLimit;
|
|
|
|
instance.m_state = nullptr;
|
|
|
|
// Update allocator pointer
|
|
lua_setallocf(m_state, MemoryAllocator, this);
|
|
|
|
return *this;
|
|
}
|
|
|
|
int LuaInstance::GetIndexOfUpValue(int upValue)
|
|
{
|
|
return lua_upvalueindex(upValue);
|
|
}
|
|
|
|
LuaInstance* LuaInstance::GetInstance(lua_State* state)
|
|
{
|
|
LuaInstance* instance;
|
|
lua_getallocf(state, reinterpret_cast<void**>(&instance));
|
|
|
|
return instance;
|
|
}
|
|
|
|
bool LuaInstance::Run(int argCount, int resultCount)
|
|
{
|
|
if (m_level++ == 0)
|
|
m_clock.Restart();
|
|
|
|
int status = lua_pcall(m_state, argCount, resultCount, 0);
|
|
|
|
m_level--;
|
|
|
|
if (status != 0)
|
|
{
|
|
m_lastError = lua_tostring(m_state, -1);
|
|
lua_pop(m_state, 1);
|
|
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void* LuaInstance::MemoryAllocator(void* ud, void* ptr, std::size_t osize, std::size_t nsize)
|
|
{
|
|
LuaInstance* instance = static_cast<LuaInstance*>(ud);
|
|
std::size_t& memoryLimit = instance->m_memoryLimit;
|
|
std::size_t& memoryUsage = instance->m_memoryUsage;
|
|
|
|
if (nsize == 0)
|
|
{
|
|
memoryUsage -= osize;
|
|
std::free(ptr);
|
|
|
|
return nullptr;
|
|
}
|
|
else
|
|
{
|
|
std::size_t usage = memoryUsage + nsize;
|
|
if (ptr)
|
|
usage -= osize;
|
|
|
|
if (memoryLimit != 0 && usage > memoryLimit)
|
|
{
|
|
NazaraError("Lua memory usage is over memory limit (" + String::Number(usage) + " > " + String::Number(memoryLimit) + ')');
|
|
return nullptr;
|
|
}
|
|
|
|
memoryUsage = usage;
|
|
|
|
return std::realloc(ptr, nsize);
|
|
}
|
|
}
|
|
|
|
int LuaInstance::ProxyFunc(lua_State* state)
|
|
{
|
|
LuaFunction& func = *static_cast<LuaFunction*>(lua_touserdata(state, lua_upvalueindex(1)));
|
|
return func(*GetInstance(state));
|
|
}
|
|
|
|
void LuaInstance::TimeLimiter(lua_State* state, lua_Debug* debug)
|
|
{
|
|
NazaraUnused(debug);
|
|
|
|
LuaInstance* instance = GetInstance(state);
|
|
if (instance->m_clock.GetMilliseconds() > instance->m_timeLimit)
|
|
luaL_error(state, "maximum execution time exceeded");
|
|
}
|
|
}
|