Modify PUC Lua to wrap C++ exceptions (#12445)

This commit is contained in:
Jude Melton-Houghton 2022-09-26 07:23:48 -04:00 committed by GitHub
parent f916398a54
commit 03428d9825
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 105 additions and 4 deletions

@ -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_API lua_State *lua_newthread (lua_State *L) {
lua_State *L1; lua_State *L1;
lua_lock(L); lua_lock(L);

@ -317,7 +317,11 @@ int luaD_precall (lua_State *L, StkId func, int nresults) {
if (L->hookmask & LUA_MASKCALL) if (L->hookmask & LUA_MASKCALL)
luaD_callhook(L, LUA_HOOKCALL, -1); luaD_callhook(L, LUA_HOOKCALL, -1);
lua_unlock(L); 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); lua_lock(L);
if (n < 0) /* yielding? */ if (n < 0) /* yielding? */
return PCRYIELD; return PCRYIELD;

@ -166,6 +166,7 @@ LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) {
setnilvalue(registry(L)); setnilvalue(registry(L));
luaZ_initbuffer(L, &g->buff); luaZ_initbuffer(L, &g->buff);
g->panic = NULL; g->panic = NULL;
g->wrapcf = NULL; /* MINETEST-SPECIFIC CHANGE */
g->gcstate = GCSpause; g->gcstate = GCSpause;
g->rootgc = obj2gco(L); g->rootgc = obj2gco(L);
g->sweepstrgc = 0; g->sweepstrgc = 0;

@ -86,6 +86,7 @@ typedef struct global_State {
int gcpause; /* size of pause between successive GCs */ int gcpause; /* size of pause between successive GCs */
int gcstepmul; /* GC `granularity' */ int gcstepmul; /* GC `granularity' */
lua_CFunction panic; /* to be called in unprotected errors */ lua_CFunction panic; /* to be called in unprotected errors */
lua_CFunctionwrapper wrapcf; /* MINETEST-SPECIFIC CHANGE */
TValue l_registry; TValue l_registry;
struct lua_State *mainthread; struct lua_State *mainthread;
UpVal uvhead; /* head of double-linked list of all open upvalues */ UpVal uvhead; /* head of double-linked list of all open upvalues */

@ -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); 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 ** basic stack manipulation

@ -109,12 +109,14 @@ ScriptApiBase::ScriptApiBase(ScriptingType type):
lua_rawseti(m_luastack, LUA_REGISTRYINDEX, CUSTOM_RIDX_BACKTRACE); lua_rawseti(m_luastack, LUA_REGISTRYINDEX, CUSTOM_RIDX_BACKTRACE);
lua_pop(m_luastack, 1); // pop debug lua_pop(m_luastack, 1); // pop debug
// If we are using LuaJIT add a C++ wrapper function to catch // Add a C++ wrapper function to catch exceptions thrown in Lua -> C++ calls
// exceptions thrown in Lua -> C++ calls
#if USE_LUAJIT #if USE_LUAJIT
lua_pushlightuserdata(m_luastack, (void*) script_exception_wrapper); lua_pushlightuserdata(m_luastack, (void*) script_exception_wrapper);
luaJIT_setmode(m_luastack, -1, LUAJIT_MODE_WRAPCFUNC | LUAJIT_MODE_ON); luaJIT_setmode(m_luastack, -1, LUAJIT_MODE_WRAPCFUNC | LUAJIT_MODE_ON);
lua_pop(m_luastack, 1); lua_pop(m_luastack, 1);
#else
// (This is a custom API from the bundled Lua.)
lua_atccall(m_luastack, script_exception_wrapper);
#endif #endif
// Add basic globals // Add basic globals

@ -19,12 +19,27 @@ with this program; if not, write to the Free Software Foundation, Inc.,
*/ */
#include "test.h" #include "test.h"
#include "config.h"
#include <stdexcept>
extern "C" { extern "C" {
#include <lua.h> #if USE_LUAJIT
#include <luajit.h>
#else
#include <lua.h>
#endif
#include <lauxlib.h> #include <lauxlib.h>
} }
/*
* 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 class TestLua : public TestBase
{ {
public: public:
@ -34,6 +49,7 @@ public:
void runTests(IGameDef *gamedef); void runTests(IGameDef *gamedef);
void testLuaDestructors(); void testLuaDestructors();
void testCxxExceptions();
}; };
static TestLua g_test_instance; static TestLua g_test_instance;
@ -41,10 +57,16 @@ static TestLua g_test_instance;
void TestLua::runTests(IGameDef *gamedef) void TestLua::runTests(IGameDef *gamedef)
{ {
TEST(testLuaDestructors); 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 namespace
{ {
@ -77,3 +99,57 @@ void TestLua::testLuaDestructors()
UASSERT(did_destruct); 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<void*>(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);
}