diff options
| -rw-r--r-- | builtin/async_env.lua | 24 | ||||
| -rw-r--r-- | builtin/async_event.lua | 66 | ||||
| -rw-r--r-- | src/guiEngine.cpp | 46 | ||||
| -rw-r--r-- | src/httpfetch.cpp | 2 | ||||
| -rw-r--r-- | src/script/cpp_api/CMakeLists.txt | 1 | ||||
| -rw-r--r-- | src/script/cpp_api/s_async.cpp | 301 | ||||
| -rw-r--r-- | src/script/cpp_api/s_async.h | 171 | ||||
| -rw-r--r-- | src/script/lua_api/CMakeLists.txt | 2 | ||||
| -rw-r--r-- | src/script/lua_api/l_async_events.cpp | 370 | ||||
| -rw-r--r-- | src/script/lua_api/l_async_events.h | 220 | ||||
| -rw-r--r-- | src/script/lua_api/l_mainmenu.cpp | 19 | ||||
| -rw-r--r-- | src/script/lua_api/l_util.cpp | 2 | ||||
| -rw-r--r-- | src/script/lua_api/marshall.c | 551 | ||||
| -rw-r--r-- | src/script/scripting_game.cpp | 9 | ||||
| -rw-r--r-- | src/script/scripting_mainmenu.cpp | 32 | ||||
| -rw-r--r-- | src/script/scripting_mainmenu.h | 11 |
16 files changed, 568 insertions, 1259 deletions
diff --git a/builtin/async_env.lua b/builtin/async_env.lua index afc69219c..cdcb82ee3 100644 --- a/builtin/async_env.lua +++ b/builtin/async_env.lua @@ -1,19 +1,21 @@ -engine.log("info","Initializing Asynchronous environment") +engine.log("info", "Initializing Asynchronous environment") +local tbl = engine or minetest +minetest = tbl +dofile(SCRIPTDIR .. DIR_DELIM .. "serialize.lua") dofile(SCRIPTDIR .. DIR_DELIM .. "misc_helpers.lua") -function engine.job_processor(serialized_function, serialized_data) +function tbl.job_processor(serialized_func, serialized_param) + local func = loadstring(serialized_func) + local param = tbl.deserialize(serialized_param) + local retval = nil - local fct = marshal.decode(serialized_function) - local params = marshal.decode(serialized_data) - local retval = marshal.encode(nil) - - if fct ~= nil and type(fct) == "function" then - local result = fct(params) - retval = marshal.encode(result) + if type(func) == "function" then + retval = tbl.serialize(func(param)) else - engine.log("error","ASYNC WORKER: unable to deserialize function") + tbl.log("error", "ASYNC WORKER: Unable to deserialize function") end - return retval,retval:len() + return retval or tbl.serialize(nil) end + diff --git a/builtin/async_event.lua b/builtin/async_event.lua index f4c7d2449..2c3fb8fa7 100644 --- a/builtin/async_event.lua +++ b/builtin/async_event.lua @@ -1,59 +1,45 @@ local tbl = engine or minetest +local SCRIPTDIR = SCRIPTDIR or tbl.get_scriptdir() +minetest = tbl +dofile(SCRIPTDIR .. DIR_DELIM .. "serialize.lua") + tbl.async_jobs = {} -if engine ~= nil then - function tbl.async_event_handler(jobid, serialized_retval) - local retval = nil - if serialized_retval ~= "ERROR" then - retval= marshal.decode(serialized_retval) - else - tbl.log("error","Error fetching async result") - end +local function handle_job(jobid, serialized_retval) + local retval = tbl.deserialize(serialized_retval) + assert(type(tbl.async_jobs[jobid]) == "function") + tbl.async_jobs[jobid](retval) + tbl.async_jobs[jobid] = nil +end - assert(type(tbl.async_jobs[jobid]) == "function") - tbl.async_jobs[jobid](retval) - tbl.async_jobs[jobid] = nil - end +if engine ~= nil then + tbl.async_event_handler = handle_job else - - minetest.register_globalstep( - function(dtime) - local list = tbl.get_finished_jobs() - - for i=1,#list,1 do - local retval = marshal.decode(list[i].retval) - - assert(type(tbl.async_jobs[jobid]) == "function") - tbl.async_jobs[list[i].jobid](retval) - tbl.async_jobs[list[i].jobid] = nil - end - end) + minetest.register_globalstep(function(dtime) + for i, job in ipairs(tbl.get_finished_jobs()) do + handle_job(job.jobid, job.retval) + end + end) end -function tbl.handle_async(fct, parameters, callback) - - --serialize fct - local serialized_fct = marshal.encode(fct) +function tbl.handle_async(func, parameter, callback) + -- Serialize function + local serialized_func = string.dump(func) - assert(marshal.decode(serialized_fct) ~= nil) + assert(serialized_func ~= nil) - --serialize parameters - local serialized_params = marshal.encode(parameters) + -- Serialize parameters + local serialized_param = tbl.serialize(parameter) - if serialized_fct == nil or - serialized_params == nil or - serialized_fct:len() == 0 or - serialized_params:len() == 0 then + if serialized_param == nil then return false end - local jobid = tbl.do_async_callback( serialized_fct, - serialized_fct:len(), - serialized_params, - serialized_params:len()) + local jobid = tbl.do_async_callback(serialized_func, serialized_param) tbl.async_jobs[jobid] = callback return true end + diff --git a/src/guiEngine.cpp b/src/guiEngine.cpp index b929c4f71..672a0d37f 100644 --- a/src/guiEngine.cpp +++ b/src/guiEngine.cpp @@ -186,19 +186,20 @@ GUIEngine::GUIEngine( irr::IrrlichtDevice* dev, // Initialize scripting - infostream<<"GUIEngine: Initializing Lua"<<std::endl; + infostream << "GUIEngine: Initializing Lua" << std::endl; m_script = new MainMenuScripting(this); try { - if (m_data->errormessage != "") - { + if (m_data->errormessage != "") { m_script->setMainMenuErrorMessage(m_data->errormessage); m_data->errormessage = ""; } - if (!loadMainMenuScript()) - assert("no future without mainmenu" == 0); + if (!loadMainMenuScript()) { + errorstream << "No future without mainmenu" << std::endl; + abort(); + } run(); } @@ -512,32 +513,25 @@ bool GUIEngine::setTexture(texture_layer layer,std::string texturepath) { /******************************************************************************/ bool GUIEngine::downloadFile(std::string url,std::string target) { #if USE_CURL - bool retval = true; + std::ofstream targetfile(target.c_str(), std::ios::out | std::ios::binary); - FILE* targetfile = fopen(target.c_str(),"wb"); + if (!targetfile.good()) { + return false; + } - if (targetfile) { - HTTPFetchRequest fetchrequest; - HTTPFetchResult fetchresult; - fetchrequest.url = url; - fetchrequest.caller = HTTPFETCH_SYNC; - httpfetch_sync(fetchrequest,fetchresult); + HTTPFetchRequest fetchrequest; + HTTPFetchResult fetchresult; + fetchrequest.url = url; + fetchrequest.caller = HTTPFETCH_SYNC; + httpfetch_sync(fetchrequest, fetchresult); - if (fetchresult.succeeded) { - if (fwrite(fetchresult.data.c_str(),1,fetchresult.data.size(),targetfile) != fetchresult.data.size()) { - retval = false; - } - } - else { - retval = false; - } - fclose(targetfile); - } - else { - retval = false; + if (fetchresult.succeeded) { + targetfile << fetchresult.data; + } else { + return false; } - return retval; + return true; #else return false; #endif diff --git a/src/httpfetch.cpp b/src/httpfetch.cpp index 751a4471a..313988fd8 100644 --- a/src/httpfetch.cpp +++ b/src/httpfetch.cpp @@ -45,7 +45,7 @@ HTTPFetchRequest::HTTPFetchRequest() caller = HTTPFETCH_DISCARD; request_id = 0; timeout = g_settings->getS32("curl_timeout"); - connect_timeout = timeout * 5; + connect_timeout = timeout; useragent = std::string("Minetest/") + minetest_version_hash + " (" + porting::get_sysinfo() + ")"; } diff --git a/src/script/cpp_api/CMakeLists.txt b/src/script/cpp_api/CMakeLists.txt index b753eda17..c45020055 100644 --- a/src/script/cpp_api/CMakeLists.txt +++ b/src/script/cpp_api/CMakeLists.txt @@ -9,6 +9,7 @@ set(common_SCRIPT_CPP_API_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/s_nodemeta.cpp ${CMAKE_CURRENT_SOURCE_DIR}/s_player.cpp ${CMAKE_CURRENT_SOURCE_DIR}/s_server.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/s_async.cpp PARENT_SCOPE) # Used by client only diff --git a/src/script/cpp_api/s_async.cpp b/src/script/cpp_api/s_async.cpp new file mode 100644 index 000000000..603b6fe9c --- /dev/null +++ b/src/script/cpp_api/s_async.cpp @@ -0,0 +1,301 @@ +/* +Minetest +Copyright (C) 2013 sapier, <sapier AT gmx DOT net> + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License along +with this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#include <stdio.h> +#include <stdlib.h> + +extern "C" { +#include "lua.h" +#include "lauxlib.h" +#include "lualib.h" +} + +#include "s_async.h" +#include "log.h" +#include "filesys.h" +#include "porting.h" +#include "common/c_internal.h" + +/******************************************************************************/ +AsyncEngine::AsyncEngine() : + m_initDone(false), + m_JobIdCounter(0) +{ +} + +/******************************************************************************/ +AsyncEngine::~AsyncEngine() +{ + // Force kill all threads + for (std::vector<AsyncWorkerThread*>::iterator i = m_WorkerThreads.begin(); + i != m_WorkerThreads.end(); i++) { + (*i)->Kill(); + delete *i; + } + + m_JobQueueMutex.Lock(); + m_JobQueue.clear(); + m_JobQueueMutex.Unlock(); + m_WorkerThreads.clear(); +} + +/******************************************************************************/ +bool AsyncEngine::registerFunction(const char* name, lua_CFunction func) +{ + if (m_initDone) { + return false; + } + m_FunctionList[name] = func; + return true; +} + +/******************************************************************************/ +void AsyncEngine::Initialize(unsigned int numEngines) +{ + m_initDone = true; + + for (unsigned int i = 0; i < numEngines; i++) { + AsyncWorkerThread* toAdd = new AsyncWorkerThread(this, i); + m_WorkerThreads.push_back(toAdd); + toAdd->Start(); + } +} + +/******************************************************************************/ +unsigned int AsyncEngine::doAsyncJob(std::string func, std::string params) +{ + m_JobQueueMutex.Lock(); + LuaJobInfo toadd; + toadd.JobId = m_JobIdCounter++; + toadd.serializedFunction = func; + toadd.serializedParams = params; + + m_JobQueue.push_back(toadd); + + m_JobQueueCounter.Post(); + + m_JobQueueMutex.Unlock(); + + return toadd.JobId; +} + +/******************************************************************************/ +LuaJobInfo AsyncEngine::getJob() +{ + m_JobQueueCounter.Wait(); + m_JobQueueMutex.Lock(); + + LuaJobInfo retval; + retval.valid = false; + + if (m_JobQueue.size() != 0) { + retval = m_JobQueue.front(); + retval.valid = true; + m_JobQueue.erase(m_JobQueue.begin()); + } + m_JobQueueMutex.Unlock(); + + return retval; +} + +/******************************************************************************/ +void AsyncEngine::putJobResult(LuaJobInfo result) +{ + m_ResultQueueMutex.Lock(); + m_ResultQueue.push_back(result); + m_ResultQueueMutex.Unlock(); +} + +/******************************************************************************/ +void AsyncEngine::Step(lua_State *L, int errorhandler) +{ + lua_getglobal(L, "engine"); + m_ResultQueueMutex.Lock(); + while (!m_ResultQueue.empty()) { + LuaJobInfo jobdone = m_ResultQueue.front(); + m_ResultQueue.erase(m_ResultQueue.begin()); + + lua_getfield(L, -1, "async_event_handler"); + + if (lua_isnil(L, -1)) { + assert("Async event handler does not exist!" == 0); + } + + luaL_checktype(L, -1, LUA_TFUNCTION); + + lua_pushinteger(L, jobdone.JobId); + lua_pushlstring(L, jobdone.serializedResult.c_str(), + jobdone.serializedResult.length()); + + if (lua_pcall(L, 2, 0, errorhandler)) { + script_error(L); + } + } + m_ResultQueueMutex.Unlock(); + lua_pop(L, 1); // Pop engine +} + +/******************************************************************************/ +void AsyncEngine::PushFinishedJobs(lua_State* L) { + // Result Table + m_ResultQueueMutex.Lock(); + + unsigned int index = 1; + lua_createtable(L, m_ResultQueue.size(), 0); + int top = lua_gettop(L); + + while (!m_ResultQueue.empty()) { + LuaJobInfo jobdone = m_ResultQueue.front(); + m_ResultQueue.erase(m_ResultQueue.begin()); + + lua_createtable(L, 0, 2); // Pre-alocate space for two map fields + int top_lvl2 = lua_gettop(L); + + lua_pushstring(L, "jobid"); + lua_pushnumber(L, jobdone.JobId); + lua_settable(L, top_lvl2); + + lua_pushstring(L, "retval"); + lua_pushlstring(L, jobdone.serializedResult.data(), + jobdone.serializedResult.size()); + lua_settable(L, top_lvl2); + + lua_rawseti(L, top, index++); + } + + m_ResultQueueMutex.Unlock(); +} + +/******************************************************************************/ +void AsyncEngine::PrepareEnvironment(lua_State* L, int top) { + for (std::map<std::string, lua_CFunction>::iterator it = m_FunctionList.begin(); + it != m_FunctionList.end(); it++) { + lua_pushstring(L, it->first.c_str()); + lua_pushcfunction(L, it->second); + lua_settable(L, top); + } +} + +/******************************************************************************/ +AsyncWorkerThread::AsyncWorkerThread(AsyncEngine* jobDispatcher, + unsigned int threadNum) : + ScriptApiBase(), + m_JobDispatcher(jobDispatcher), + m_threadnum(threadNum) +{ + lua_State *L = getStack(); + + luaL_openlibs(L); + + // Prepare job lua environment + lua_newtable(L); + lua_setglobal(L, "engine"); + lua_getglobal(L, "engine"); + int top = lua_gettop(L); + + lua_pushstring(L, DIR_DELIM); + lua_setglobal(L, "DIR_DELIM"); + + lua_pushstring(L, + (porting::path_share + DIR_DELIM + "builtin").c_str()); + lua_setglobal(L, "SCRIPTDIR"); + + m_JobDispatcher->PrepareEnvironment(L, top); +} + +/******************************************************************************/ +AsyncWorkerThread::~AsyncWorkerThread() +{ + assert(IsRunning() == false); +} + +/******************************************************************************/ +void* AsyncWorkerThread::Thread() +{ + ThreadStarted(); + + // Register thread for error logging + char number[21]; + snprintf(number, sizeof(number), "%d", m_threadnum); + log_register_thread(std::string("AsyncWorkerThread_") + number); + + porting::setThreadName((std::string("AsyncWorkTh_") + number).c_str()); + + std::string asyncscript = porting::path_share + DIR_DELIM + "builtin" + + DIR_DELIM + "async_env.lua"; + + if (!loadScript(asyncscript)) { + errorstream + << "AsyncWorkderThread execution of async base environment failed!" + << std::endl; + abort(); + } + + lua_State *L = getStack(); + // Main loop + while (!StopRequested()) { + // Wait for job + LuaJobInfo toProcess = m_JobDispatcher->getJob(); + + if (toProcess.valid == false || StopRequested()) { + continue; + } + + lua_getglobal(L, "engine"); + if (lua_isnil(L, -1)) { + errorstream << "Unable to find engine within async environment!"; + abort(); + } + + lua_getfield(L, -1, "job_processor"); + if (lua_isnil(L, -1)) { + errorstream << "Unable to get async job processor!" << std::endl; + abort(); + } + + luaL_checktype(L, -1, LUA_TFUNCTION); + + // Call it + lua_pushlstring(L, + toProcess.serializedFunction.data(), + toProcess.serializedFunction.size()); + lua_pushlstring(L, + toProcess.serializedParams.data(), + toProcess.serializedParams.size()); + + if (lua_pcall(L, 2, 1, m_errorhandler)) { + scriptError(); + toProcess.serializedResult = ""; + } else { + // Fetch result + size_t length; + const char *retval = lua_tolstring(L, -1, &length); + toProcess.serializedResult = std::string(retval, length); + } + + // Pop engine, job_processor, and retval + lua_pop(L, 3); + + // Put job result + m_JobDispatcher->putJobResult(toProcess); + } + log_deregister_thread(); + return 0; +} + diff --git a/src/script/cpp_api/s_async.h b/src/script/cpp_api/s_async.h new file mode 100644 index 000000000..c5c0e091d --- /dev/null +++ b/src/script/cpp_api/s_async.h @@ -0,0 +1,171 @@ +/* +Minetest +Copyright (C) 2013 sapier, <sapier AT gmx DOT net> + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public License along +with this program; if not, write to the Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. +*/ + +#ifndef L_ASYNC_EVENTS_H_ +#define L_ASYNC_EVENTS_H_ + +#include <vector> +#include <map> + +#include "jthread/jthread.h" +#include "jthread/jmutex.h" +#include "jthread/jsemaphore.h" +#include "debug.h" +#include "lua.h" +#include "cpp_api/s_base.h" + +// Forward declarations +class AsyncEngine; + + +// Declarations + +// Data required to queue a job +struct LuaJobInfo { + // Function to be called in async environment + std::string serializedFunction; + // Parameter to be passed to function + std::string serializedParams; + // Result of function call + std::string serializedResult; + // JobID used to identify a job and match it to callback + unsigned int JobId; + + bool valid; +}; + +// Asynchronous working environment +class AsyncWorkerThread : public JThread, public ScriptApiBase { +public: + /** + * default constructor + * @param pointer to job dispatcher + */ + AsyncWorkerThread(AsyncEngine* jobDispatcher, unsigned int threadNum); + + virtual ~AsyncWorkerThread(); + + void* Thread(); + +private: + AsyncEngine* m_JobDispatcher; + + // Thread number. Used for debug output + unsigned int m_threadnum; + +}; + +// Asynchornous thread and job management +class AsyncEngine { + friend class AsyncWorkerThread; +public: + AsyncEngine(); + ~AsyncEngine(); + + /** + * Register function to be used within engine + * @param name Function name to be used within Lua environment + * @param func C function to be called + */ + bool registerFunction(const char* name, lua_CFunction func); + + /** + * Create async engine tasks and lock function registration + * @param numEngines Number of async threads to be started + */ + void Initialize(unsigned int numEngines); + + /** + * queue/run a async job + * @param func Serialized lua function + * @param params Serialized parameters + * @return jobid The job is queued + */ + unsigned int doAsyncJob(std::string func, std::string params); + + /** + * Engine step to process finished jobs + * the engine step is one way to pass events back, PushFinishedJobs another + * @param L The Lua stack + * @param errorhandler Stack index of the Lua error handler + */ + void Step(lua_State *L, int errorhandler); + + /** + * Push a list of finished jobs onto the stack + * @param L The Lua stack + */ + void PushFinishedJobs(lua_State *L); + +protected: + /** + * Get a Job from queue to be processed + * this function blocks until a job is ready + * @return a job to be processed + */ + LuaJobInfo getJob(); + + /** + * Put a Job result back to result queue + * @param result result of completed job + */ + void putJobResult(LuaJobInfo result); + + /** + * Initialize environment with current registred functions + * this function adds all functions registred by registerFunction to the + * passed lua stack + * @param L Lua stack to initialize + * @param top Stack position + */ + void PrepareEnvironment(lua_State* L, int top); + +private: + + // Stack index of error handler + int m_errorhandler; + + // variable locking the engine against further modification + bool m_initDone; + + // Internal store for registred functions + std::map<std::string, lua_CFunction> m_FunctionList; + + // Internal counter to create job IDs + unsigned int m_JobIdCounter; + + // Mutex to protect job queue + JMutex m_JobQueueMutex; + + // Job queue + std::vector<LuaJobInfo> m_JobQueue; + + // Mutex to protect result queue + JMutex m_ResultQueueMutex; + // Result queue + std::vector<LuaJobInfo> m_ResultQueue; + + // List of current worker threads + std::vector<AsyncWorkerThread*> m_WorkerThreads; + + // Counter semaphore for job dispatching + JSemaphore m_JobQueueCounter; +}; + +#endif // L_ASYNC_EVENTS_H_ diff --git a/src/script/lua_api/CMakeLists.txt b/src/script/lua_api/CMakeLists.txt index 0b89df6a3..08960d2ad 100644 --- a/src/script/lua_api/CMakeLists.txt +++ b/src/script/lua_api/CMakeLists.txt @@ -16,8 +16,6 @@ set(common_SCRIPT_LUA_API_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/l_util.cpp ${CMAKE_CURRENT_SOURCE_DIR}/l_vmanip.cpp ${CMAKE_CURRENT_SOURCE_DIR}/l_settings.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/l_async_events.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/marshall.c PARENT_SCOPE) # Used by client only diff --git a/src/script/lua_api/l_async_events.cpp b/src/script/lua_api/l_async_events.cpp deleted file mode 100644 index f5c27a235..000000000 --- a/src/script/lua_api/l_async_events.cpp +++ /dev/null @@ -1,370 +0,0 @@ -/* -Minetest -Copyright (C) 2013 sapier, <sapier AT gmx DOT net> - -This program is free software; you can redistribute it and/or modify -it under the terms of the GNU Lesser General Public License as published by -the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details. - -You should have received a copy of the GNU Lesser General Public License along -with this program; if not, write to the Free Software Foundation, Inc., -51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. -*/ - -extern "C" { -#include "lua.h" -#include "lauxlib.h" -#include "lualib.h" -int luaopen_marshal(lua_State *L); -} -#include <stdio.h> - -#include "l_async_events.h" -#include "log.h" -#include "filesys.h" -#include "porting.h" -#include "common/c_internal.h" - -/******************************************************************************/ -AsyncEngine::AsyncEngine() : - m_initDone(false), - m_JobIdCounter(0) -{ -} - -/******************************************************************************/ -AsyncEngine::~AsyncEngine() -{ - /** request all threads to stop **/ - for (std::vector<AsyncWorkerThread*>::iterator i= m_WorkerThreads.begin(); - i != m_WorkerThreads.end();i++) { - (*i)->Stop(); - } - - - /** wakeup all threads **/ - for (std::vector<AsyncWorkerThread*>::iterator i= m_WorkerThreads.begin(); - i != m_WorkerThreads.end();i++) { - m_JobQueueCounter.Post(); - } - - /** wait for threads to finish **/ - for (std::vector<AsyncWorkerThread*>::iterator i= m_WorkerThreads.begin(); - i != m_WorkerThreads.end();i++) { - (*i)->Wait(); - } - - /** force kill all threads **/ - for (std::vector<AsyncWorkerThread*>::iterator i= m_WorkerThreads.begin(); - i != m_WorkerThreads.end();i++) { - (*i)->Kill(); - delete *i; - } - - m_JobQueueMutex.Lock(); - m_JobQueue.clear(); - m_JobQueueMutex.Unlock(); - m_WorkerThreads.clear(); -} - -/******************************************************************************/ -bool AsyncEngine::registerFunction(const char* name, lua_CFunction fct) { - - if (m_initDone) return false; - m_FunctionList[name] = fct; - return true; -} - -/******************************************************************************/ -void AsyncEngine::Initialize(unsigned int numengines) { - m_initDone = true; - - for (unsigned int i=0; i < numengines; i ++) { - - AsyncWorkerThread* toadd = new AsyncWorkerThread(this,i); - m_WorkerThreads.push_back(toadd); - toadd->Start(); - } -} - -/******************************************************************************/ -unsigned int AsyncEngine::doAsyncJob(std::string fct, std::string params) { - - m_JobQueueMutex.Lock(); - LuaJobInfo toadd; - toadd.JobId = m_JobIdCounter++; - toadd.serializedFunction = fct; - toadd.serializedParams = params; - - m_JobQueue.push_back(toadd); - - m_JobQueueCounter.Post(); - - m_JobQueueMutex.Unlock(); - - return toadd.JobId; -} - -/******************************************************************************/ -LuaJobInfo AsyncEngine::getJob() { - - m_JobQueueCounter.Wait(); - m_JobQueueMutex.Lock(); - - LuaJobInfo retval; - retval.valid = false; - - if (m_JobQueue.size() != 0) { - retval = m_JobQueue.front(); - retval.valid = true; - m_JobQueue.erase((m_JobQueue.begin())); - } - m_JobQueueMutex.Unlock(); - - return retval; -} - -/******************************************************************************/ -void AsyncEngine::putJobResult(LuaJobInfo result) { - m_ResultQueueMutex.Lock(); - m_ResultQueue.push_back(result); - m_ResultQueueMutex.Unlock(); -} - -/******************************************************************************/ -void AsyncEngine::Step(lua_State *L) { - lua_pushcfunction(L, script_error_handler); - int errorhandler = lua_gettop(L); - lua_getglobal(L, "engine"); - m_ResultQueueMutex.Lock(); - while(!m_ResultQueue.empty()) { - LuaJobInfo jobdone = m_ResultQueue.front(); - m_ResultQueue.erase(m_ResultQueue.begin()); - - lua_getfield(L, -1, "async_event_handler"); - - if(lua_isnil(L, -1)) - assert("Someone managed to destroy a async callback in engine!" == 0); - - luaL_checktype(L, -1, LUA_TFUNCTION); - - lua_pushinteger(L, jobdone.JobId); - lua_pushlstring(L, jobdone.serializedResult.c_str(), - jobdone.serializedResult.length()); - - if(lua_pcall(L, 2, 0, errorhandler)) { - script_error(L); - } - } - m_ResultQueueMutex.Unlock(); - lua_pop(L, 2); // Pop engine and error handler -} - -/******************************************************************************/ -void AsyncEngine::PushFinishedJobs(lua_State* L) { - //Result Table - m_ResultQueueMutex.Lock(); - - unsigned int index=1; - lua_newtable(L); - int top = lua_gettop(L); - - while(!m_ResultQueue.empty()) { - - LuaJobInfo jobdone = m_ResultQueue.front(); - m_ResultQueue.erase(m_ResultQueue.begin()); - - lua_pushnumber(L,index); - - lua_newtable(L); - int top_lvl2 = lua_gettop(L); - - lua_pushstring(L,"jobid"); - lua_pushnumber(L,jobdone.JobId); - lua_settable(L, top_lvl2); - - lua_pushstring(L,"retval"); - lua_pushstring(L, jobdone.serializedResult.c_str()); - lua_settable(L, top_lvl2); - - lua_settable(L, top); - index++; - } - - m_ResultQueueMutex.Unlock(); - -} -/******************************************************************************/ -void AsyncEngine::PrepareEnvironment(lua_State* L, int top) { - for(std::map<std::string,lua_CFunction>::iterator i = m_FunctionList.begin(); - i != m_FunctionList.end(); i++) { - - lua_pushstring(L,i->first.c_str()); - lua_pushcfunction(L,i->second); - lua_settable(L, top); - - } -} - -/******************************************************************************/ -int async_worker_ErrorHandler(lua_State *L) { - lua_getfield(L, LUA_GLOBALSINDEX, "debug"); - if (!lua_istable(L, -1)) { - lua_pop(L, 1); - return 1; - } - lua_getfield(L, -1, "traceback"); - if (!lua_isfunction(L, -1)) { - lua_pop(L, 2); - return 1; - } - lua_pushvalue(L, 1); - lua_pushinteger(L, 2); - lua_call(L, 2, 1); - return 1; -} - -/******************************************************************************/ -AsyncWorkerThread::AsyncWorkerThread(AsyncEngine* jobdispatcher, - unsigned int numthreadnumber) : - m_JobDispatcher(jobdispatcher), - m_luaerrorhandler(-1), - m_threadnum(numthreadnumber) -{ - // create luastack - m_LuaStack = luaL_newstate(); - - // load basic lua modules - luaL_openlibs(m_LuaStack); - - // load serialization functions - luaopen_marshal(m_LuaStack); -} - -/******************************************************************************/ -AsyncWorkerThread::~AsyncWorkerThread() { - - assert(IsRunning() == false); - lua_close(m_LuaStack); -} - -/******************************************************************************/ -void* AsyncWorkerThread::worker_thread_main() { - - //register thread for error logging - char number[21]; - snprintf(number,sizeof(number),"%d",m_threadnum); - log_register_thread(std::string("AsyncWorkerThread_") + number); - - porting::setThreadName( - std::string(std::string("AsyncWorkTh_") + number).c_str()); - - /** prepare job lua environment **/ - lua_newtable(m_LuaStack); - lua_setglobal(m_LuaStack, "engine"); - - lua_getglobal(m_LuaStack, "engine"); - int top = lua_gettop(m_LuaStack); - - lua_pushstring(m_LuaStack, DIR_DELIM); - lua_setglobal(m_LuaStack, "DIR_DELIM"); - - lua_pushstring(m_LuaStack, - std::string(porting::path_share + DIR_DELIM + "builtin").c_str()); - lua_setglobal(m_LuaStack, "SCRIPTDIR"); - - - m_JobDispatcher->PrepareEnvironment(m_LuaStack,top); - - std::string asyncscript = - porting::path_share + DIR_DELIM + "builtin" - + DIR_DELIM + "async_env.lua"; - - lua_pushcfunction(m_LuaStack, async_worker_ErrorHandler); - m_luaerrorhandler = lua_gettop(m_LuaStack); - - if(!runScript(asyncscript)) { - infostream - << "AsyncWorkderThread::worker_thread_main execution of async base environment failed!" - << std::endl; - assert("no future with broken builtin async environment scripts" == 0); - } - /** main loop **/ - while(!StopRequested()) { - //wait for job - LuaJobInfo toprocess = m_JobDispatcher->getJob(); - - if (toprocess.valid == false) { continue; } - if (StopRequested()) { continue; } - - //first push error handler - lua_pushcfunction(m_LuaStack, script_error_handler); - int errorhandler = lua_gettop(m_LuaStack); - - lua_getglobal(m_LuaStack, "engine"); - if(lua_isnil(m_LuaStack, -1)) - assert("unable to find engine within async environment" == 0); - - lua_getfield(m_LuaStack, -1, "job_processor"); - if(lua_isnil(m_LuaStack, -1)) - assert("Someone managed to destroy a async worker engine!" == 0); - - luaL_checktype(m_LuaStack, -1, LUA_TFUNCTION); - - //call it - lua_pushlstring(m_LuaStack, - toprocess.serializedFunction.c_str(), - toprocess.serializedFunction.length()); - lua_pushlstring(m_LuaStack, - toprocess.serializedParams.c_str(), - toprocess.serializedParams.length()); - - if (StopRequested()) { continue; } - if(lua_pcall(m_LuaStack, 2, 2, errorhandler)) { - script_error(m_LuaStack); - toprocess.serializedResult = "ERROR"; - } else { - //fetch result - const char *retval = lua_tostring(m_LuaStack, -2); - unsigned int lenght = lua_tointeger(m_LuaStack,-1); - toprocess.serializedResult = std::string(retval,lenght); - } - - if (StopRequested()) { continue; } - //put job result - m_JobDispatcher->putJobResult(toprocess); - } - log_deregister_thread(); - return 0; -} - -/******************************************************************************/ -bool AsyncWorkerThread::runScript(std::string script) { - - int ret = luaL_loadfile(m_LuaStack, script.c_str()) || - lua_pcall(m_LuaStack, 0, 0, m_luaerrorhandler); - if(ret){ - errorstream<<"==== ERROR FROM LUA WHILE INITIALIZING ASYNC ENVIRONMENT ====="<<std::endl; - errorstream<<"Failed to load and run script from "<<std::endl; - errorstream<<script<<":"<<std::endl; - errorstream<<std::endl; - errorstream<<lua_tostring(m_LuaStack, -1)<<std::endl; - errorstream<<std::endl; - errorstream<<"=================== END OF ERROR FROM LUA ===================="<<std::endl; - lua_pop(m_LuaStack, 1); // Pop error message from stack - lua_pop(m_LuaStack, 1); // Pop the error handler from stack - return false; - } - return true; -} - -/******************************************************************************/ -void* AsyncWorkerThread::worker_thread_wrapper(void* thread) { - return ((AsyncWorkerThread*) thread)->worker_thread_main(); -} diff --git a/src/script/lua_api/l_async_events.h b/src/script/lua_api/l_async_events.h deleted file mode 100644 index 9d42b07cf..000000000 --- a/src/script/lua_api/l_async_events.h +++ /dev/null @@ -1,220 +0,0 @@ -/* -Minetest -Copyright (C) 2013 sapier, <sapier AT gmx DOT net> - -This program is free software; you can redistribute it and/or modify -it under the terms of the GNU Lesser General Public License as published by -the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details. - -You should have received a copy of the GNU Lesser General Public License along -with this program; if not, write to the Free Software Foundation, Inc., -51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. -*/ - -#ifndef L_ASYNC_EVENTS_H_ -#define L_ASYNC_EVENTS_H_ - -#include <vector> -#include <map> - -/******************************************************************************/ -/* Includes */ -/******************************************************************************/ -#include "jthread/jthread.h" -#include "jthread/jmutex.h" -#include "jthread/jsemaphore.h" -#include "debug.h" -#include "lua.h" - -/******************************************************************************/ -/* Typedefs and macros */ -/******************************************************************************/ -#define MAINMENU_NUMBER_OF_ASYNC_THREADS 4 - -/******************************************************************************/ -/* forward declarations */ -/******************************************************************************/ -class AsyncEngine; - -/******************************************************************************/ -/* declarations */ -/******************************************************************************/ - -/** a struct to encapsulate data required to queue a job **/ -struct LuaJobInfo { - /** function to be called in async environment **/ - std::string serializedFunction; - /** parameter table to be passed to function **/ - std::string serializedParams; - /** result of function call **/ - std::string serializedResult; - /** jobid used to identify a job and match it to callback **/ - unsigned int JobId; - /** valid marker **/ - bool valid; -}; - -/** class encapsulating a asynchronous working environment **/ -class AsyncWorkerThread : public JThread { -public: - /** - * default constructor - * @param pointer to job dispatcher - */ - AsyncWorkerThread(AsyncEngine* jobdispatcher, unsigned int threadnumber); - - /** - * default destructor - */ - virtual ~AsyncWorkerThread(); - - /** - * thread function - */ - void* Thread() { - ThreadStarted(); - return worker_thread_wrapper(this); - } - -private: - /** - * helper function to run a lua script - * @param path of script - */ - bool runScript(std::string script); - - /** - * main function of thread - */ - void* worker_thread_main(); - - /** - * static wrapper for thread creation - * @param this pointer to the thread to be created - */ - static void* worker_thread_wrapper(void* thread); - - /** - * pointer to job dispatcher - */ - AsyncEngine* m_JobDispatcher; - - /** - * the lua stack to run at - */ - lua_State* m_LuaStack; - - /** - * lua internal stack number of error handler - */ - int m_luaerrorhandler; - - /** - * thread number used for debug output - */ - unsigned int m_threadnum; - -}; - -/** asynchornous thread and job management **/ -class AsyncEngine { - friend class AsyncWorkerThread; -public: - /** - * default constructor - */ - AsyncEngine(); - /** - * default destructor - */ - ~AsyncEngine(); - - /** - * register function to be used within engines - * @param name function name to be used within lua environment - * @param fct c-function to be called - */ - bool registerFunction(const char* name, lua_CFunction fct); - - /** - * create async engine tasks and lock function registration - * @param numengines number of async threads to be started - */ - void Initialize(unsigned int numengines); - - /** - * queue/run a async job - * @param fct serialized lua function - * @param params serialized parameters - * @return jobid the job is queued - */ - unsigned int doAsyncJob(std::string fct, std::string params); - - /** - * engine step to process finished jobs - * the engine step is one way to pass events back, PushFinishedJobs another - * @param L the lua environment to do the step in - */ - void Step(lua_State *L); - - - void PushFinishedJobs(lua_State* L); - -protected: - /** - * Get a Job from queue to be processed - * this function blocks until a job is ready - * @return a job to be processed - */ - LuaJobInfo getJob(); - - /** - * put a Job result back to result queue - * @param result result of completed job - */ - void putJobResult(LuaJobInfo result); - - /** - * initialize environment with current registred functions - * this function adds all functions registred by registerFunction to the - * passed lua stack - * @param L lua stack to initialize - * @param top stack position - */ - void PrepareEnvironment(lua_State* L, int top); - -private: - - /** variable locking the engine against further modification **/ - bool m_initDone; - - /** internal store for registred functions **/ - std::map<std::string,lua_CFunction> m_FunctionList; - - /** internal counter to create job id's **/ - unsigned int m_JobIdCounter; - - /** mutex to protect job queue **/ - JMutex m_JobQueueMutex; - /** job queue **/ - std::vector<LuaJobInfo> m_JobQueue; - - /** mutext to protect result queue **/ - JMutex m_ResultQueueMutex; - /** result queue **/ - std::vector<LuaJobInfo> m_ResultQueue; - - /** list of current worker threads **/ - std::vector<AsyncWorkerThread*> m_WorkerThreads; - - /** counter semaphore for job dispatching **/ - JSemaphore m_JobQueueCounter; -}; - -#endif /* L_ASYNC_EVENTS_H_ */ diff --git a/src/script/lua_api/l_mainmenu.cpp b/src/script/lua_api/l_mainmenu.cpp index 5de1c77f0..31fc45ce2 100644 --- a/src/script/lua_api/l_mainmenu.cpp +++ b/src/script/lua_api/l_mainmenu.cpp @@ -20,7 +20,7 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "lua_api/l_mainmenu.h" #include "lua_api/l_internal.h" #include "common/c_content.h" -#include "lua_api/l_async_events.h" +#include "cpp_api/s_async.h" #include "guiEngine.h" #include "guiMainMenu.h" #include "guiKeyChangeMenu.h" @@ -1034,19 +1034,18 @@ int ModApiMainMenu::l_do_async_callback(lua_State *L) { GUIEngine* engine = getGuiEngine(L); - const char* serialized_fct_raw = luaL_checkstring(L, 1); - unsigned int lenght_fct = luaL_checkint(L, 2); + size_t func_length, param_length; + const char* serialized_func_raw = luaL_checklstring(L, 1, &func_length); - const char* serialized_params_raw = luaL_checkstring(L, 3); - unsigned int lenght_params = luaL_checkint(L, 4); + const char* serialized_param_raw = luaL_checklstring(L, 2, ¶m_length); - assert(serialized_fct_raw != 0); - assert(serialized_params_raw != 0); + assert(serialized_func_raw != NULL); + assert(serialized_param_raw != NULL); - std::string serialized_fct = std::string(serialized_fct_raw,lenght_fct); - std::string serialized_params = std::string(serialized_params_raw,lenght_params); + std::string serialized_func = std::string(serialized_func_raw, func_length); + std::string serialized_param = std::string(serialized_param_raw, param_length); - lua_pushinteger(L,engine->DoAsync(serialized_fct,serialized_params)); + lua_pushinteger(L, engine->DoAsync(serialized_func, serialized_param)); return 1; } diff --git a/src/script/lua_api/l_util.cpp b/src/script/lua_api/l_util.cpp index f2bbf181d..90a1d77ab 100644 --- a/src/script/lua_api/l_util.cpp +++ b/src/script/lua_api/l_util.cpp @@ -21,7 +21,7 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "lua_api/l_internal.h" #include "common/c_converter.h" #include "common/c_content.h" -#include "lua_api/l_async_events.h" +#include "cpp_api/s_async.h" #include "debug.h" #include "log.h" #include "tool.h" diff --git a/src/script/lua_api/marshall.c b/src/script/lua_api/marshall.c deleted file mode 100644 index ef70566cb..000000000 --- a/src/script/lua_api/marshall.c +++ /dev/null @@ -1,551 +0,0 @@ -/* -* lmarshal.c -* A Lua library for serializing and deserializing Lua values -* Richard Hundt <richardhundt@gmail.com> -* -* License: MIT -* -* Copyright (c) 2010 Richard Hundt -* -* Permission is hereby granted, free of charge, to any person -* obtaining a copy of this software and associated documentation -* files (the "Software"), to deal in the Software without -* restriction, including without limitation the rights to use, -* copy, modify, merge, publish, distribute, sublicense, and/or sell -* copies of the Software, and to permit persons to whom the -* Software is furnished to do so, subject to the following -* conditions: -* -* The above copyright notice and this permission notice shall be -* included in all copies or substantial portions of the Software. -* -* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, -* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES -* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND -* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT -* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, -* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR -* OTHER DEALINGS IN THE SOFTWARE. -*/ - -#include <stdlib.h> -#include <string.h> -#include <stdint.h> - -#include "lua.h" -#include "lualib.h" -#include "lauxlib.h" - - -#define MAR_TREF 1 -#define MAR_TVAL 2 -#define MAR_TUSR 3 - -#define MAR_CHR 1 -#define MAR_I32 4 -#define MAR_I64 8 - -#define MAR_MAGIC 0x8e -#define SEEN_IDX 3 - -typedef struct mar_Buffer { - size_t size; - size_t seek; - size_t head; - char* data; -} mar_Buffer; - -static int mar_encode_table(lua_State *L, mar_Buffer *buf, size_t *idx); -static int mar_decode_table(lua_State *L, const char* buf, size_t len, size_t *idx); - -static void buf_init(lua_State *L, mar_Buffer *buf) -{ - buf->size = 128; - buf->seek = 0; - buf->head = 0; - if (!(buf->data = malloc(buf->size))) luaL_error(L, "Out of memory!"); -} - -static void buf_done(lua_State* L, mar_Buffer *buf) -{ - free(buf->data); -} - -static int buf_write(lua_State* L, const char* str, size_t len, mar_Buffer *buf) -{ - if (len > UINT32_MAX) luaL_error(L, "buffer too long"); - if (buf->size - buf->head < len) { - size_t new_size = buf->size << 1; - size_t cur_head = buf->head; - while (new_size - cur_head <= len) { - new_size = new_size << 1; - } - if (!(buf->data = realloc(buf->data, new_size))) { - luaL_error(L, "Out of memory!"); - } - buf->size = new_size; - } - memcpy(&buf->data[buf->head], str, len); - buf->head += len; - return 0; -} - -static const char* buf_read(lua_State *L, mar_Buffer *buf, size_t *len) -{ - if (buf->seek < buf->head) { - buf->seek = buf->head; - *len = buf->seek; - return buf->data; - } - *len = 0; - return NULL; -} - -static void mar_encode_value(lua_State *L, mar_Buffer *buf, int val, size_t *idx) -{ - size_t l; - int val_type = lua_type(L, val); - lua_pushvalue(L, val); - - buf_write(L, (void*)&val_type, MAR_CHR, buf); - switch (val_type) { - case LUA_TBOOLEAN: { - int int_val = lua_toboolean(L, -1); - buf_write(L, (void*)&int_val, MAR_CHR, buf); - break; - } - case LUA_TSTRING: { - const char *str_val = lua_tolstring(L, -1, &l); - buf_write(L, (void*)&l, MAR_I32, buf); - buf_write(L, str_val, l, buf); - break; - } - case LUA_TNUMBER: { - lua_Number num_val = lua_tonumber(L, -1); - buf_write(L, (void*)&num_val, MAR_I64, buf); - break; - } - case LUA_TTABLE: { - int tag, ref; - lua_pushvalue(L, -1); - lua_rawget(L, SEEN_IDX); - if (!lua_isnil(L, -1)) { - ref = lua_tointeger(L, -1); - tag = MAR_TREF; - buf_write(L, (void*)&tag, MAR_CHR, buf); - buf_write(L, (void*)&ref, MAR_I32, buf); - lua_pop(L, 1); - } - else { - mar_Buffer rec_buf; - lua_pop(L, 1); /* pop nil */ - if (luaL_getmetafield(L, -1, "__persist")) { - tag = MAR_TUSR; - - lua_pushvalue(L, -2); /* self */ - lua_call(L, 1, 1); - if (!lua_isfunction(L, -1)) { - luaL_error(L, "__persist must return a function"); - } - - lua_remove(L, -2); /* __persist */ - - lua_newtable(L); - lua_pushvalue(L, -2); /* callback */ - lua_rawseti(L, -2, 1); - - buf_init(L, &rec_buf); - mar_encode_table(L, &rec_buf, idx); - - buf_write(L, (void*)&tag, MAR_CHR, buf); - buf_write(L, (void*)&rec_buf.head, MAR_I32, buf); - buf_write(L, rec_buf.data, rec_buf.head, buf); - buf_done(L, &rec_buf); - lua_pop(L, 1); - } - else { - tag = MAR_TVAL; - - lua_pushvalue(L, -1); - lua_pushinteger(L, (*idx)++); - lua_rawset(L, SEEN_IDX); - - lua_pushvalue(L, -1); - buf_init(L, &rec_buf); - mar_encode_table(L, &rec_buf, idx); - lua_pop(L, 1); - - buf_write(L, (void*)&tag, MAR_CHR, buf); - buf_write(L, (void*)&rec_buf.head, MAR_I32, buf); - buf_write(L, rec_buf.data,rec_buf.head, buf); - buf_done(L, &rec_buf); - } - } - break; - } - case LUA_TFUNCTION: { - int tag, ref; - lua_pushvalue(L, -1); - lua_rawget(L, SEEN_IDX); - if (!lua_isnil(L, -1)) { - ref = lua_tointeger(L, -1); - tag = MAR_TREF; - buf_write(L, (void*)&tag, MAR_CHR, buf); - buf_write(L, (void*)&ref, MAR_I32, buf); - lua_pop(L, 1); - } - else { - mar_Buffer rec_buf; - int i; - lua_Debug ar; - lua_pop(L, 1); /* pop nil */ - - lua_pushvalue(L, -1); - lua_getinfo(L, ">nuS", &ar); - if (ar.what[0] != 'L') { - luaL_error(L, "attempt to persist a C function '%s'", ar.name); - } - tag = MAR_TVAL; - lua_pushvalue(L, -1); - lua_pushinteger(L, (*idx)++); - lua_rawset(L, SEEN_IDX); - - lua_pushvalue(L, -1); - buf_init(L, &rec_buf); - lua_dump(L, (lua_Writer)buf_write, &rec_buf); - - buf_write(L, (void*)&tag, MAR_CHR, buf); - buf_write(L, (void*)&rec_buf.head, MAR_I32, buf); - buf_write(L, rec_buf.data, rec_buf.head, buf); - buf_done(L, &rec_buf); - lua_pop(L, 1); - - lua_newtable(L); - for (i=1; i <= ar.nups; i++) { - lua_getupvalue(L, -2, i); - lua_rawseti(L, -2, i); - } - - buf_init(L, &rec_buf); - mar_encode_table(L, &rec_buf, idx); - - buf_write(L, (void*)&rec_buf.head, MAR_I32, buf); - buf_write(L, rec_buf.data, rec_buf.head, buf); - buf_done(L, &rec_buf); - lua_pop(L, 1); - } - - break; - } - case LUA_TUSERDATA: { - int tag, ref; - lua_pushvalue(L, -1); - lua_rawget(L, SEEN_IDX); - if (!lua_isnil(L, -1)) { - ref = lua_tointeger(L, -1); - tag = MAR_TREF; - buf_write(L, (void*)&tag, MAR_CHR, buf); - buf_write(L, (void*)&ref, MAR_I32, buf); - lua_pop(L, 1); - } - else { - mar_Buffer rec_buf; - lua_pop(L, 1); /* pop nil */ - if (luaL_getmetafield(L, -1, "__persist")) { - tag = MAR_TUSR; - - lua_pushvalue(L, -2); - lua_pushinteger(L, (*idx)++); - lua_rawset(L, SEEN_IDX); - - lua_pushvalue(L, -2); - lua_call(L, 1, 1); - if (!lua_isfunction(L, -1)) { - luaL_error(L, "__persist must return a function"); - } - lua_newtable(L); - lua_pushvalue(L, -2); - lua_rawseti(L, -2, 1); - lua_remove(L, -2); - - buf_init(L, &rec_buf); - mar_encode_table(L, &rec_buf, idx); - - buf_write(L, (void*)&tag, MAR_CHR, buf); - buf_write(L, (void*)&rec_buf.head, MAR_I32, buf); - buf_write(L, rec_buf.data, rec_buf.head, buf); - buf_done(L, &rec_buf); - } - else { - luaL_error(L, "attempt to encode userdata (no __persist hook)"); - } - lua_pop(L, 1); - } - break; - } - case LUA_TNIL: break; - default: - luaL_error(L, "invalid value type (%s)", lua_typename(L, val_type)); - } - lua_pop(L, 1); -} - -static int mar_encode_table(lua_State *L, mar_Buffer *buf, size_t *idx) -{ - lua_pushnil(L); - while (lua_next(L, -2) != 0) { - mar_encode_value(L, buf, -2, idx); - mar_encode_value(L, buf, -1, idx); - lua_pop(L, 1); - } - return 1; -} - -#define mar_incr_ptr(l) \ - if (((*p)-buf)+(l) > len) luaL_error(L, "bad code"); (*p) += (l); - -#define mar_next_len(l,T) \ - if (((*p)-buf)+sizeof(T) > len) luaL_error(L, "bad code"); \ - l = *(T*)*p; (*p) += sizeof(T); - -static void mar_decode_value - (lua_State *L, const char *buf, size_t len, const char **p, size_t *idx) -{ - size_t l; - char val_type = **p; - mar_incr_ptr(MAR_CHR); - switch (val_type) { - case LUA_TBOOLEAN: - lua_pushboolean(L, *(char*)*p); - mar_incr_ptr(MAR_CHR); - break; - case LUA_TNUMBER: - lua_pushnumber(L, *(lua_Number*)*p); - mar_incr_ptr(MAR_I64); - break; - case LUA_TSTRING: - mar_next_len(l, uint32_t); - lua_pushlstring(L, *p, l); - mar_incr_ptr(l); - break; - case LUA_TTABLE: { - char tag = *(char*)*p; - mar_incr_ptr(MAR_CHR); - if (tag == MAR_TREF) { - int ref; - mar_next_len(ref, int); - lua_rawgeti(L, SEEN_IDX, ref); - } - else if (tag == MAR_TVAL) { - mar_next_len(l, uint32_t); - lua_newtable(L); - lua_pushvalue(L, -1); - lua_rawseti(L, SEEN_IDX, (*idx)++); - mar_decode_table(L, *p, l, idx); - mar_incr_ptr(l); - } - else if (tag == MAR_TUSR) { - mar_next_len(l, uint32_t); - lua_newtable(L); - mar_decode_table(L, *p, l, idx); - lua_rawgeti(L, -1, 1); - lua_call(L, 0, 1); - lua_remove(L, -2); - lua_pushvalue(L, -1); - lua_rawseti(L, SEEN_IDX, (*idx)++); - mar_incr_ptr(l); - } - else { - luaL_error(L, "bad encoded data"); - } - break; - } - case LUA_TFUNCTION: { - size_t nups; - int i; - mar_Buffer dec_buf; - char tag = *(char*)*p; - mar_incr_ptr(1); - if (tag == MAR_TREF) { - int ref; - mar_next_len(ref, int); - lua_rawgeti(L, SEEN_IDX, ref); - } - else { - mar_next_len(l, uint32_t); - dec_buf.data = (char*)*p; - dec_buf.size = l; - dec_buf.head = l; - dec_buf.seek = 0; - lua_load(L, (lua_Reader)buf_read, &dec_buf, "=marshal"); - mar_incr_ptr(l); - - lua_pushvalue(L, -1); - lua_rawseti(L, SEEN_IDX, (*idx)++); - - mar_next_len(l, uint32_t); - lua_newtable(L); - mar_decode_table(L, *p, l, idx); - nups = lua_objlen(L, -1); - for (i=1; i <= nups; i++) { - lua_rawgeti(L, -1, i); - lua_setupvalue(L, -3, i); - } - lua_pop(L, 1); - mar_incr_ptr(l); - } - break; - } - case LUA_TUSERDATA: { - char tag = *(char*)*p; - mar_incr_ptr(MAR_CHR); - if (tag == MAR_TREF) { - int ref; - mar_next_len(ref, int); - lua_rawgeti(L, SEEN_IDX, ref); - } - else if (tag == MAR_TUSR) { - mar_next_len(l, uint32_t); - lua_newtable(L); - mar_decode_table(L, *p, l, idx); - lua_rawgeti(L, -1, 1); - lua_call(L, 0, 1); - lua_remove(L, -2); - lua_pushvalue(L, -1); - lua_rawseti(L, SEEN_IDX, (*idx)++); - mar_incr_ptr(l); - } - else { /* tag == MAR_TVAL */ - lua_pushnil(L); - } - break; - } - case LUA_TNIL: - case LUA_TTHREAD: - lua_pushnil(L); - break; - default: - luaL_error(L, "bad code"); - } -} - -static int mar_decode_table(lua_State *L, const char* buf, size_t len, size_t *idx) -{ - const char* p; - p = buf; - while (p - buf < len) { - mar_decode_value(L, buf, len, &p, idx); - mar_decode_value(L, buf, len, &p, idx); - lua_settable(L, -3); - } - return 1; -} - -static int mar_encode(lua_State* L) -{ - const unsigned char m = MAR_MAGIC; - size_t idx, len; - mar_Buffer buf; - - if (lua_isnone(L, 1)) { - lua_pushnil(L); - } - if (lua_isnoneornil(L, 2)) { - lua_newtable(L); - } - else if (!lua_istable(L, 2)) { - luaL_error(L, "bad argument #2 to encode (expected table)"); - } - lua_settop(L, 2); - - len = lua_objlen(L, 2); - lua_newtable(L); - for (idx = 1; idx <= len; idx++) { - lua_rawgeti(L, 2, idx); - if (lua_isnil(L, -1)) { - lua_pop(L, 1); - continue; - } - lua_pushinteger(L, idx); - lua_rawset(L, SEEN_IDX); - } - lua_pushvalue(L, 1); - - buf_init(L, &buf); - buf_write(L, (void*)&m, 1, &buf); - - mar_encode_value(L, &buf, -1, &idx); - - lua_pop(L, 1); - - lua_pushlstring(L, buf.data, buf.head); - - buf_done(L, &buf); - - lua_remove(L, SEEN_IDX); - - return 1; -} - -static int mar_decode(lua_State* L) -{ - size_t l, idx, len; - const char *p; - const char *s = luaL_checklstring(L, 1, &l); - - if (l < 1) luaL_error(L, "bad header"); - if (*(unsigned char *)s++ != MAR_MAGIC) luaL_error(L, "bad magic"); - l -= 1; - - if (lua_isnoneornil(L, 2)) { - lua_newtable(L); - } - else if (!lua_istable(L, 2)) { - luaL_error(L, "bad argument #2 to decode (expected table)"); - } - lua_settop(L, 2); - - len = lua_objlen(L, 2); - lua_newtable(L); - for (idx = 1; idx <= len; idx++) { - lua_rawgeti(L, 2, idx); - lua_rawseti(L, SEEN_IDX, idx); - } - - p = s; - mar_decode_value(L, s, l, &p, &idx); - - lua_remove(L, SEEN_IDX); - lua_remove(L, 2); - - return 1; -} - -static int mar_clone(lua_State* L) -{ - mar_encode(L); - lua_replace(L, 1); - mar_decode(L); - return 1; -} - -static const luaL_reg R[] = -{ - {"encode", mar_encode}, - {"decode", mar_decode}, - {"clone", mar_clone}, - {NULL, NULL} -}; - -int luaopen_marshal(lua_State *L) -{ - lua_newtable(L); - luaL_register(L, "marshal", R); - return 1; -} - - - - - diff --git a/src/script/scripting_game.cpp b/src/script/scripting_game.cpp index 043ee4bae..12baac032 100644 --- a/src/script/scripting_game.cpp +++ b/src/script/scripting_game.cpp @@ -56,6 +56,9 @@ GameScripting::GameScripting(Server* server) // Create the main minetest table lua_newtable(L); + lua_setglobal(L, "minetest"); + lua_getglobal(L, "minetest"); + int top = lua_gettop(L); lua_newtable(L); lua_setfield(L, -2, "object_refs"); @@ -63,15 +66,11 @@ GameScripting::GameScripting(Server* server) lua_newtable(L); lua_setfield(L, -2, "luaentities"); - lua_setglobal(L, "minetest"); - // Initialize our lua_api modules - lua_getglobal(L, "minetest"); - int top = lua_gettop(L); InitializeModApi(L, top); lua_pop(L, 1); - infostream << "SCRIPTAPI: initialized game modules" << std::endl; + infostream << "SCRIPTAPI: Initialized game modules" << std::endl; } void GameScripting::InitializeModApi(lua_State *L, int top) diff --git a/src/script/scripting_mainmenu.cpp b/src/script/scripting_mainmenu.cpp index a4619e9da..58ed6238c 100644 --- a/src/script/scripting_mainmenu.cpp +++ b/src/script/scripting_mainmenu.cpp @@ -28,9 +28,11 @@ with this program; if not, write to the Free Software Foundation, Inc., extern "C" { #include "lualib.h" - int luaopen_marshal(lua_State *L); } -/******************************************************************************/ + +#define MAINMENU_ASYNC_THREADS 4 + + MainMenuScripting::MainMenuScripting(GUIEngine* guiengine) { setGuiEngine(guiengine); @@ -38,32 +40,31 @@ MainMenuScripting::MainMenuScripting(GUIEngine* guiengine) //TODO add security luaL_openlibs(getStack()); - luaopen_marshal(getStack()); SCRIPTAPI_PRECHECKHEADER + lua_newtable(L); + lua_setglobal(L, "engine"); + lua_getglobal(L, "engine"); + int top = lua_gettop(L); + lua_pushstring(L, DIR_DELIM); lua_setglobal(L, "DIR_DELIM"); lua_newtable(L); lua_setglobal(L, "gamedata"); - lua_newtable(L); - lua_setglobal(L, "engine"); - // Initialize our lua_api modules - lua_getglobal(L, "engine"); - int top = lua_gettop(L); InitializeModApi(L, top); lua_pop(L, 1); - infostream << "SCRIPTAPI: initialized mainmenu modules" << std::endl; + infostream << "SCRIPTAPI: Initialized main menu modules" << std::endl; } /******************************************************************************/ void MainMenuScripting::InitializeModApi(lua_State *L, int top) { - // Initialize mod api modules + // Initialize mod API modules ModApiMainMenu::Initialize(L, top); ModApiUtil::Initialize(L, top); @@ -76,16 +77,17 @@ void MainMenuScripting::InitializeModApi(lua_State *L, int top) // Initialize async environment //TODO possibly make number of async threads configurable - m_AsyncEngine.Initialize(MAINMENU_NUMBER_OF_ASYNC_THREADS); + m_AsyncEngine.Initialize(MAINMENU_ASYNC_THREADS); } /******************************************************************************/ void MainMenuScripting::Step() { - m_AsyncEngine.Step(getStack()); + m_AsyncEngine.Step(getStack(), m_errorhandler); } /******************************************************************************/ -unsigned int MainMenuScripting::DoAsync(std::string serialized_fct, - std::string serialized_params) { - return m_AsyncEngine.doAsyncJob(serialized_fct,serialized_params); +unsigned int MainMenuScripting::DoAsync(std::string serialized_func, + std::string serialized_param) { + return m_AsyncEngine.doAsyncJob(serialized_func, serialized_param); } + diff --git a/src/script/scripting_mainmenu.h b/src/script/scripting_mainmenu.h index f4d78f664..6a95d3fc9 100644 --- a/src/script/scripting_mainmenu.h +++ b/src/script/scripting_mainmenu.h @@ -22,7 +22,7 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "cpp_api/s_base.h" #include "cpp_api/s_mainmenu.h" -#include "lua_api/l_async_events.h" +#include "cpp_api/s_async.h" /*****************************************************************************/ /* Scripting <-> Main Menu Interface */ @@ -35,14 +35,11 @@ class MainMenuScripting public: MainMenuScripting(GUIEngine* guiengine); - // use ScriptApiBase::loadMod() or ScriptApiBase::loadScript() - // to load scripts - - /* global step handler to pass back async events */ + // Global step handler to pass back async events void Step(); - /* pass async events from engine to async threads */ - unsigned int DoAsync(std::string serialized_fct, + // Pass async events from engine to async threads + unsigned int DoAsync(std::string serialized_func, std::string serialized_params); private: void InitializeModApi(lua_State *L, int top); |