324 lines
7.4 KiB
C++
324 lines
7.4 KiB
C++
#include "LuaState.h"
|
|
|
|
#include <iomanip>
|
|
#include <iostream>
|
|
#include "lua_util.h"
|
|
#include "api_lua.h"
|
|
#include "../../../util/stringutil.h"
|
|
|
|
lua::luaerror::luaerror(const std::string& message) : std::runtime_error(message) {
|
|
}
|
|
|
|
void lua::LuaState::removeLibFuncs(const char* libname, const char* funcs[]) {
|
|
if (getglobal(libname)) {
|
|
for (uint i = 0; funcs[i]; i++) {
|
|
pushnil();
|
|
setfield(funcs[i], -2);
|
|
}
|
|
}
|
|
}
|
|
|
|
lua::LuaState::LuaState() {
|
|
std::cout << LUA_VERSION << std::endl;
|
|
std::cout << LUAJIT_VERSION << std::endl;
|
|
|
|
L = luaL_newstate();
|
|
if (L == nullptr) {
|
|
throw lua::luaerror("could not to initialize Lua");
|
|
}
|
|
// Allowed standard libraries
|
|
luaopen_base(L);
|
|
luaopen_math(L);
|
|
luaopen_string(L);
|
|
luaopen_table(L);
|
|
luaopen_debug(L);
|
|
luaopen_jit(L);
|
|
luaopen_bit(L);
|
|
|
|
luaopen_os(L);
|
|
const char* removed_os[] {
|
|
"execute",
|
|
"exit",
|
|
"remove",
|
|
"rename",
|
|
"setlocale",
|
|
"tmpname",
|
|
nullptr
|
|
};
|
|
removeLibFuncs("os", removed_os);
|
|
|
|
createLibs();
|
|
|
|
lua_pushvalue(L, LUA_GLOBALSINDEX);
|
|
setglobal(envName(0));
|
|
}
|
|
|
|
const std::string lua::LuaState::envName(int env) {
|
|
return "_ENV"+util::mangleid(env);
|
|
}
|
|
|
|
lua::LuaState::~LuaState() {
|
|
lua_close(L);
|
|
}
|
|
|
|
void lua::LuaState::logError(const std::string& text) {
|
|
std::cerr << text << std::endl;
|
|
}
|
|
|
|
void lua::LuaState::addfunc(const std::string& name, lua_CFunction func) {
|
|
lua_pushcfunction(L, func);
|
|
lua_setglobal(L, name.c_str());
|
|
}
|
|
|
|
bool lua::LuaState::getglobal(const std::string& name) {
|
|
lua_getglobal(L, name.c_str());
|
|
if (lua_isnil(L, lua_gettop(L))) {
|
|
lua_pop(L, lua_gettop(L));
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool lua::LuaState::hasglobal(const std::string& name) {
|
|
lua_getglobal(L, name.c_str());
|
|
if (lua_isnil(L, lua_gettop(L))) {
|
|
lua_pop(L, lua_gettop(L));
|
|
return false;
|
|
}
|
|
lua_pop(L, lua_gettop(L));
|
|
return true;
|
|
}
|
|
|
|
void lua::LuaState::setglobal(const std::string& name) {
|
|
lua_setglobal(L, name.c_str());
|
|
}
|
|
|
|
bool lua::LuaState::rename(const std::string& from, const std::string& to) {
|
|
const char* src = from.c_str();
|
|
lua_getglobal(L, src);
|
|
if (lua_isnil(L, lua_gettop(L))) {
|
|
lua_pop(L, lua_gettop(L));
|
|
return false;
|
|
}
|
|
lua_setglobal(L, to.c_str());
|
|
|
|
// remove previous
|
|
lua_pushnil(L);
|
|
lua_setglobal(L, src);
|
|
return true;
|
|
}
|
|
|
|
void lua::LuaState::remove(const std::string& name) {
|
|
lua_pushnil(L);
|
|
lua_setglobal(L, name.c_str());
|
|
}
|
|
|
|
void lua::LuaState::createLibs() {
|
|
openlib("pack", packlib, 0);
|
|
openlib("world", worldlib, 0);
|
|
openlib("player", playerlib, 0);
|
|
openlib("inventory", inventorylib, 0);
|
|
openlib("block", blocklib, 0);
|
|
openlib("item", itemlib, 0);
|
|
openlib("time", timelib, 0);
|
|
openlib("file", filelib, 0);
|
|
openlib("gui", guilib, 0);
|
|
openlib("audio", audiolib, 0);
|
|
|
|
addfunc("print", lua_wrap_errors<l_print>);
|
|
}
|
|
|
|
void lua::LuaState::loadbuffer(int env, const std::string& src, const std::string& file) {
|
|
if (luaL_loadbuffer(L, src.c_str(), src.length(), file.c_str())) {
|
|
throw lua::luaerror(lua_tostring(L, -1));
|
|
}
|
|
if (env && getglobal(envName(env))) {
|
|
lua_setfenv(L, -2);
|
|
}
|
|
}
|
|
|
|
int lua::LuaState::call(int argc) {
|
|
if (lua_pcall(L, argc, LUA_MULTRET, 0)) {
|
|
throw lua::luaerror(lua_tostring(L, -1));
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int lua::LuaState::callNoThrow(int argc) {
|
|
if (lua_pcall(L, argc, LUA_MULTRET, 0)) {
|
|
logError(lua_tostring(L, -1));
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
int lua::LuaState::eval(int env, const std::string& src, const std::string& file) {
|
|
auto srcText = "return ("+src+")";
|
|
loadbuffer(env, srcText, file);
|
|
return call(0);
|
|
}
|
|
|
|
int lua::LuaState::execute(int env, const std::string& src, const std::string& file) {
|
|
loadbuffer(env, src, file);
|
|
return callNoThrow(0);
|
|
}
|
|
|
|
int lua::LuaState::gettop() const {
|
|
return lua_gettop(L);
|
|
}
|
|
|
|
int lua::LuaState::pushinteger(luaint x) {
|
|
lua_pushinteger(L, x);
|
|
return 1;
|
|
}
|
|
|
|
int lua::LuaState::pushnumber(luanumber x) {
|
|
lua_pushnumber(L, x);
|
|
return 1;
|
|
}
|
|
|
|
int lua::LuaState::pushboolean(bool x) {
|
|
lua_pushboolean(L, x);
|
|
return 1;
|
|
}
|
|
|
|
int lua::LuaState::pushivec3(luaint x, luaint y, luaint z) {
|
|
lua::pushivec3(L, x, y, z);
|
|
return 3;
|
|
}
|
|
|
|
int lua::LuaState::pushstring(const std::string& str) {
|
|
lua_pushstring(L, str.c_str());
|
|
return 1;
|
|
}
|
|
|
|
int lua::LuaState::pushenv(int env) {
|
|
if (getglobal(envName(env))) {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int lua::LuaState::pushvalue(int idx) {
|
|
lua_pushvalue(L, idx);
|
|
return 1;
|
|
}
|
|
|
|
int lua::LuaState::pushglobals() {
|
|
lua_pushvalue(L, LUA_GLOBALSINDEX);
|
|
return 1;
|
|
}
|
|
|
|
void lua::LuaState::pop(int n) {
|
|
lua_pop(L, n);
|
|
}
|
|
|
|
int lua::LuaState::pushnil() {
|
|
lua_pushnil(L);
|
|
return 1;
|
|
}
|
|
|
|
bool lua::LuaState::getfield(const std::string& name, int idx) {
|
|
lua_getfield(L, idx, name.c_str());
|
|
if (lua_isnil(L, -1)) {
|
|
lua_pop(L, -1);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void lua::LuaState::setfield(const std::string& name, int idx) {
|
|
lua_setfield(L, idx, name.c_str());
|
|
}
|
|
|
|
bool lua::LuaState::toboolean(int idx) {
|
|
return lua_toboolean(L, idx);
|
|
}
|
|
|
|
lua::luaint lua::LuaState::tointeger(int idx) {
|
|
return lua_tointeger(L, idx);
|
|
}
|
|
|
|
lua::luanumber lua::LuaState::tonumber(int idx) {
|
|
return lua_tonumber(L, idx);
|
|
}
|
|
|
|
const char* lua::LuaState::tostring(int idx) {
|
|
return lua_tostring(L, idx);
|
|
}
|
|
|
|
bool lua::LuaState::isstring(int idx) {
|
|
return lua_isstring(L, idx);
|
|
}
|
|
|
|
bool lua::LuaState::isfunction(int idx) {
|
|
return lua_isfunction(L, idx);
|
|
}
|
|
|
|
void lua::LuaState::openlib(const std::string& name, const luaL_Reg* libfuncs, int nup) {
|
|
lua_newtable(L);
|
|
luaL_setfuncs(L, libfuncs, nup);
|
|
lua_setglobal(L, name.c_str());
|
|
}
|
|
|
|
const std::string lua::LuaState::storeAnonymous() {
|
|
auto funcId = uintptr_t(lua_topointer(L, lua_gettop(L)));
|
|
auto funcName = "F$"+util::mangleid(funcId);
|
|
lua_setglobal(L, funcName.c_str());
|
|
return funcName;
|
|
}
|
|
|
|
int lua::LuaState::createEnvironment(int parent) {
|
|
int id = nextEnvironment++;
|
|
|
|
// local env = {}
|
|
lua_createtable(L, 0, 1);
|
|
|
|
// setmetatable(env, {__index=_G})
|
|
lua_createtable(L, 0, 1);
|
|
if (parent == 0 || true) {
|
|
lua_pushvalue(L, LUA_GLOBALSINDEX);
|
|
} else {
|
|
if (pushenv(parent) == 0) {
|
|
lua_pushvalue(L, LUA_GLOBALSINDEX);
|
|
}
|
|
}
|
|
lua_setfield(L, -2, "__index");
|
|
lua_setmetatable(L, -2);
|
|
|
|
// envname = env
|
|
setglobal(envName(id));
|
|
return id;
|
|
}
|
|
|
|
|
|
void lua::LuaState::removeEnvironment(int id) {
|
|
lua_pushnil(L);
|
|
setglobal(envName(id));
|
|
}
|
|
|
|
void lua::LuaState::dumpStack() {
|
|
int top = gettop();
|
|
for (int i = 1; i <= top; i++) {
|
|
std::cout << std::setw(3) << i << std::setw(20) << luaL_typename(L, i) << std::setw(30);
|
|
switch (lua_type(L, i)) {
|
|
case LUA_TNUMBER:
|
|
std::cout << tonumber(i);
|
|
break;
|
|
case LUA_TSTRING:
|
|
std::cout << tostring(i);
|
|
break;
|
|
case LUA_TBOOLEAN:
|
|
std::cout << (toboolean(i) ? "true" : "false");
|
|
break;
|
|
case LUA_TNIL:
|
|
std::cout << "nil";
|
|
break;
|
|
default:
|
|
std::cout << lua_topointer(L, i);
|
|
break;
|
|
}
|
|
std::cout << std::endl;
|
|
}
|
|
}
|