From 03428d9825cfdf2cfaed6ac9410dafccac0d4f3a Mon Sep 17 00:00:00 2001 From: Jude Melton-Houghton Date: Mon, 26 Sep 2022 07:23:48 -0400 Subject: [PATCH] Modify PUC Lua to wrap C++ exceptions (#12445) --- lib/lua/src/lapi.c | 12 ++++++ lib/lua/src/ldo.c | 6 ++- lib/lua/src/lstate.c | 1 + lib/lua/src/lstate.h | 1 + lib/lua/src/lua.h | 5 +++ src/script/cpp_api/s_base.cpp | 6 ++- src/unittest/test_lua.cpp | 78 ++++++++++++++++++++++++++++++++++- 7 files changed, 105 insertions(+), 4 deletions(-) diff --git a/lib/lua/src/lapi.c b/lib/lua/src/lapi.c index 5d5145d2e..383e65d60 100644 --- a/lib/lua/src/lapi.c +++ b/lib/lua/src/lapi.c @@ -137,6 +137,18 @@ LUA_API lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf) { } +/* MINETEST-SPECIFIC CHANGE */ +LUA_API lua_CFunctionwrapper lua_atccall (lua_State *L, + lua_CFunctionwrapper wrapf) { + lua_CFunctionwrapper old; + lua_lock(L); + old = G(L)->wrapcf; + G(L)->wrapcf = wrapf; + lua_unlock(L); + return old; +} + + LUA_API lua_State *lua_newthread (lua_State *L) { lua_State *L1; lua_lock(L); diff --git a/lib/lua/src/ldo.c b/lib/lua/src/ldo.c index d1bf786cb..57d2ac7c2 100644 --- a/lib/lua/src/ldo.c +++ b/lib/lua/src/ldo.c @@ -317,7 +317,11 @@ int luaD_precall (lua_State *L, StkId func, int nresults) { if (L->hookmask & LUA_MASKCALL) luaD_callhook(L, LUA_HOOKCALL, -1); lua_unlock(L); - n = (*curr_func(L)->c.f)(L); /* do the actual call */ + /* MINETEST-SPECIFIC CHANGE: Let custom code wrap C function calls. */ + if (G(L)->wrapcf) + n = G(L)->wrapcf(L, *curr_func(L)->c.f); + else + n = (*curr_func(L)->c.f)(L); lua_lock(L); if (n < 0) /* yielding? */ return PCRYIELD; diff --git a/lib/lua/src/lstate.c b/lib/lua/src/lstate.c index 4313b83a0..eced4a585 100644 --- a/lib/lua/src/lstate.c +++ b/lib/lua/src/lstate.c @@ -166,6 +166,7 @@ LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) { setnilvalue(registry(L)); luaZ_initbuffer(L, &g->buff); g->panic = NULL; + g->wrapcf = NULL; /* MINETEST-SPECIFIC CHANGE */ g->gcstate = GCSpause; g->rootgc = obj2gco(L); g->sweepstrgc = 0; diff --git a/lib/lua/src/lstate.h b/lib/lua/src/lstate.h index 3bc575b6b..c4364ea3f 100644 --- a/lib/lua/src/lstate.h +++ b/lib/lua/src/lstate.h @@ -86,6 +86,7 @@ typedef struct global_State { int gcpause; /* size of pause between successive GCs */ int gcstepmul; /* GC `granularity' */ lua_CFunction panic; /* to be called in unprotected errors */ + lua_CFunctionwrapper wrapcf; /* MINETEST-SPECIFIC CHANGE */ TValue l_registry; struct lua_State *mainthread; UpVal uvhead; /* head of double-linked list of all open upvalues */ diff --git a/lib/lua/src/lua.h b/lib/lua/src/lua.h index a4b73e743..1d7fe927f 100644 --- a/lib/lua/src/lua.h +++ b/lib/lua/src/lua.h @@ -113,6 +113,11 @@ LUA_API lua_State *(lua_newthread) (lua_State *L); LUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf); +/* MINETEST-SPECIFIC CHANGE: Let custom code wrap C function calls. */ +typedef int (*lua_CFunctionwrapper)(lua_State *L, lua_CFunction f); +LUA_API lua_CFunctionwrapper (lua_atccall) (lua_State *L, + lua_CFunctionwrapper wrapf); + /* ** basic stack manipulation diff --git a/src/script/cpp_api/s_base.cpp b/src/script/cpp_api/s_base.cpp index 659b32777..5569a536e 100644 --- a/src/script/cpp_api/s_base.cpp +++ b/src/script/cpp_api/s_base.cpp @@ -109,12 +109,14 @@ ScriptApiBase::ScriptApiBase(ScriptingType type): lua_rawseti(m_luastack, LUA_REGISTRYINDEX, CUSTOM_RIDX_BACKTRACE); lua_pop(m_luastack, 1); // pop debug - // If we are using LuaJIT add a C++ wrapper function to catch - // exceptions thrown in Lua -> C++ calls + // Add a C++ wrapper function to catch exceptions thrown in Lua -> C++ calls #if USE_LUAJIT lua_pushlightuserdata(m_luastack, (void*) script_exception_wrapper); luaJIT_setmode(m_luastack, -1, LUAJIT_MODE_WRAPCFUNC | LUAJIT_MODE_ON); lua_pop(m_luastack, 1); +#else + // (This is a custom API from the bundled Lua.) + lua_atccall(m_luastack, script_exception_wrapper); #endif // Add basic globals diff --git a/src/unittest/test_lua.cpp b/src/unittest/test_lua.cpp index fc8f895af..724da1080 100644 --- a/src/unittest/test_lua.cpp +++ b/src/unittest/test_lua.cpp @@ -19,12 +19,27 @@ with this program; if not, write to the Free Software Foundation, Inc., */ #include "test.h" +#include "config.h" + +#include extern "C" { -#include +#if USE_LUAJIT + #include +#else + #include +#endif #include } +/* + * This class tests for two common issues that prevent correct error handling + * between Lua and C++. + * Further reading: + * - https://luajit.org/extensions.html#exceptions + * - http://lua-users.org/wiki/ErrorHandlingBetweenLuaAndCplusplus + */ + class TestLua : public TestBase { public: @@ -34,6 +49,7 @@ public: void runTests(IGameDef *gamedef); void testLuaDestructors(); + void testCxxExceptions(); }; static TestLua g_test_instance; @@ -41,10 +57,16 @@ static TestLua g_test_instance; void TestLua::runTests(IGameDef *gamedef) { TEST(testLuaDestructors); + TEST(testCxxExceptions); } //////////////////////////////////////////////////////////////////////////////// +/* + Check that Lua unwinds the stack correctly when it throws errors internally. + (This is not the case with PUC Lua unless it was compiled as C++.) +*/ + namespace { @@ -77,3 +99,57 @@ void TestLua::testLuaDestructors() UASSERT(did_destruct); } + +namespace { + + int wrapper(lua_State *L, lua_CFunction inner) + { + try { + return inner(L); + } catch (std::exception &e) { + lua_pushstring(L, e.what()); + return lua_error(L); + } + } + +} + +/* + Check that C++ exceptions are caught and re-thrown as Lua errors. + This is handled by a wrapper we define ourselves. + (PUC Lua does not support use of such a wrapper, we have a patched version) +*/ + +void TestLua::testCxxExceptions() +{ + lua_State *L = luaL_newstate(); + +#if USE_LUAJIT + lua_pushlightuserdata(L, reinterpret_cast(wrapper)); + luaJIT_setmode(L, -1, LUAJIT_MODE_WRAPCFUNC | LUAJIT_MODE_ON); + lua_pop(L, 1); +#else + lua_atccall(L, wrapper); +#endif + + lua_pushcfunction(L, [](lua_State *L) -> int { + throw std::runtime_error("example"); + }); + + int caught = 0; + std::string errmsg; + try { + if (lua_pcall(L, 0, 0, 0) != 0) { + caught = 2; + errmsg = lua_isstring(L, -1) ? lua_tostring(L, -1) : ""; + } + } catch (std::exception &e) { + caught = 1; + } + + if (caught != 1) + lua_close(L); + + UASSERTEQ(int, caught, 2); + UASSERT(errmsg.find("example") != std::string::npos); +}