Add C++ RAII scaffolding to handle API unwinding

In order to support C++ RAII classes in the functions exposed in the API
to Lua this change also introduces a new assertion `LExpect` functioning
like the existing `LAssert` but instead of directly transferring control
to Lua it pushes the message on the Lua stack and throws a C++ exception
to unwind the C++ call stack. For this scheme the convenience macros
`SG_LUA_CPP_FUN_BEGIN(Name)` and `SG_LUA_CPP_FUN_END()` wrap the
function entrypoint and perform the second phase of assertion processing
when needed.

Author: zao

ui_api.cpp

@@ -95,6 +95,52 @@ static ui_main_c* GetUIPtr(lua_State* L)
 	return ui;
 }
 
+// ===============
+// C++ scaffolding
+// ===============
+
+/*
+* ui->LAssert transfers control immediately out of the function without destroying
+* any C++ objects. To support RAII this scaffolding serves as a landing pad for
+* ui->LExpect, to transfer control to Lua but only after the call stack has been
+* unwound with normal C++ exception semantics.
+* 
+* Example use site:
+* SG_LUA_FUN_BEGIN(DoTheThing)
+* {
+*   ui_main_c* ui = GetUIPtr(L);
+*	auto foo = std::make_shared<Foo>();
+*   ui->LExpect(L, lua_gettop(L) >= 1), "Usage: DoTheThing(x)");
+*   ui->LExpect(L, lua_isstring(L, 1), "DoTheThing() argument 1: expected string, got %s", luaL_typename(L, 1));
+*	return 0;
+* }
+* SG_LUA_FUN_END()
+*/
+
+#ifdef _WIN32
+#define SG_NOINLINE __declspec(noinline)
+#else
+#define SG_NOINLINE [[gnu::noinline]]
+#endif
+#define SG_NORETURN [[noreturn]]
+
+SG_NORETURN static void LuaErrorWrapper(lua_State* L)
+{
+	lua_error(L);
+}
+
+#define SG_LUA_CPP_FUN_BEGIN(Name)                                 \
+static int l_##Name(lua_State* L) {                                \
+	int (*fun)(lua_State*) = [](lua_State* L) SG_NOINLINE -> int { \
+		try
+
+#define SG_LUA_CPP_FUN_END()                          \
+		catch (ui_expectationFailed_s) { return -1; } \
+    };                                                \
+	int rc = fun(L);                                  \
+	if (rc < 0) { LuaErrorWrapper(L); }               \
+	return rc; }
+
 // =========
 // Callbacks
 // =========
@@ -272,6 +318,38 @@ static int l_imgHandleImageSize(lua_State* L)
 	return 2;
 }
 
+class ui_luaReader_c {
+public:
+	ui_luaReader_c(ui_main_c* ui, lua_State* L, std::string funName) : ui(ui), L(L), funName(funName) {}
+
+	// Always zero terminated as all regular strings are terminated in Lua.
+	std::string_view ArgToString(int k) {
+		ui->LExpect(L, lua_isstring(L, k), "%s() argument %d: expected string, got %s",
+			funName.c_str(), k, luaL_typename(L, k));
+		return lua_tostring(L, k);
+	}
+
+	void ArgCheckTable(int k) {
+		ui->LExpect(L, lua_istable(L, k), "%s() argument %d: expected table, got %s",
+			funName.c_str(), k, luaL_typename(L, k));
+	}
+
+	void ArgCheckNumber(int k) {
+		ui->LExpect(L, lua_isnumber(L, k), "%s() argument %d: expected number, got %s",
+			funName.c_str(), k, luaL_typename(L, k));
+	}
+
+	void ValCheckNumber(int k, char const* ctx) {
+		ui->LExpect(L, lua_isnumber(L, k), "%s() %s: expected number, got %s",
+			funName.c_str(), ctx, k, luaL_typename(L, k));
+	}
+
+private:
+	ui_main_c* ui;
+	lua_State* L;
+	std::string funName;
+};
+
 // =========
 // Rendering
 // =========

ui_main.cpp

@@ -95,6 +95,17 @@ void ui_main_c::LAssert(lua_State* L, int cond, const char* fmt, ...)
 	}
 }
 
+void ui_main_c::LExpect(lua_State* L, int cond, const char* fmt, ...)
+{
+	if (!cond) {
+		va_list va;
+		va_start(va, fmt);
+		lua_pushvfstring(L, fmt, va);
+		va_end(va);
+		throw ui_expectationFailed_s{};
+	}
+}
+
 int ui_main_c::IsUserData(lua_State* L, int index, const char* metaName)
 {
 	if (lua_type(L, index) != LUA_TUSERDATA || lua_getmetatable(L, index) == 0) {

ui_main.h

@@ -8,6 +8,8 @@
 // Classes
 // =======
 
+struct ui_expectationFailed_s {};
+
 // UI Manager
 class ui_main_c: public ui_IMain {
 public:
@@ -53,7 +55,8 @@ class ui_main_c: public ui_IMain {
 	void	ScriptInit();
 	void	ScriptShutdown();
 
-	void	LAssert(lua_State* L, int cond, const char* fmt, ...);
+	void	LAssert(lua_State* L, int cond, const char* fmt, ...); // Non-local return to Lua code on failure
+	void	LExpect(lua_State* L, int cond, const char* fmt, ...); // Throws ui_expectationFailed_s on failure, message on Lua stack
 	int		IsUserData(lua_State* L, int index, const char* metaName);
 	int		PushCallback(const char* name);
 	void	PCall(int narg, int nret);