Add support for lua.atPanic()

Author: thsackos

README.md

@@ -78,7 +78,7 @@ lua.doString(
 
 | API | Support |
 |---|---|
-| Lua C API (`lua_*`) | 58% available (54/92) | <!-- 58.69% - Add 1.07 per -->
+| Lua C API (`lua_*`) | 58% available (55/92) | <!-- 59.76% - Add 1.07 per -->
 | Auxilary Library (`luaL_*`) | 6% available (3/48) | <!-- Always 2% * n, for n up to 48 -->
 | LuaJIT Extensions | *No plans to implement.* |
 
@@ -106,7 +106,7 @@ pattern has changed, such as using the Zig `init()` function pattern instead of
 
 | C API Symbols | Available in `zig-luajit` |
 |--------------|---------------------------|
-| `lua_atpanic`||
+| `lua_atpanic`| ☑️ `lua.atPanic()` |
 | `lua_call`| ☑️ `lua.call()` |
 | `lua_checkstack`| ☑️ `lua.checkStack()` |
 | `lua_close`| ☑️📢 `lua.deinit()` |

src/lua_api.zig

@@ -4,16 +4,6 @@
 // This file contains brainstorming and draft translations of the C API to Lua.
 
 
-/// Sets a new panic function and returns the old one. If an error happens outside any protected environment,
-/// Lua calls a panic function and then calls exit(EXIT_FAILURE), thus exiting the host application.
-/// Your panic function can avoid this exit by never returning (e.g., doing a long jump).
-/// The panic function can access the error message at the top of the stack.
-///
-/// From: `lua_CFunction lua_atpanic(lua_State *L, lua_CFunction panicf);`
-/// Refer to: https://www.lua.org/manual/5.1/manual.html#lua_atpanic
-/// Stack Behavior: `[-0, +0, -]`
-pub fn atPanic(lua: *Lua, panicf: CFunction) CFunction;
-
 /// Dumps a function as a binary chunk. Receives a Lua function on the top of the stack and produces a
 /// binary chunk that, if loaded again, results in a function equivalent to the one dumped. As it produces
 /// parts of the chunk, lua_dump calls function writer (see https://www.lua.org/manual/5.1/manual.html#lua_Writer)

src/root.zig

@@ -98,6 +98,18 @@ pub const Lua = opaque {
         return if (lua) |p| p else error.OutOfMemory;
     }
 
+    /// Sets a new panic function and returns the old one. If an error happens outside any protected environment,
+    /// Lua calls a panic function and then calls exit(EXIT_FAILURE), thus exiting the host application.
+    /// Your panic function can avoid this exit by never returning (e.g., doing a long jump).
+    /// The panic function can access the error message at the top of the stack.
+    ///
+    /// From: `lua_CFunction lua_atpanic(lua_State *L, lua_CFunction panicf);`
+    /// Refer to: https://www.lua.org/manual/5.1/manual.html#lua_atpanic
+    /// Stack Behavior: `[-0, +0, -]`
+    pub fn atPanic(lua: *Lua, f: ?CFunction) ?CFunction {
+        return @ptrCast(c.lua_atpanic(asState(lua), @ptrCast(f)));
+    }
+
     /// Returns the memory-allocation function and user data configured in the given lua instance.
     /// If userdata is not null, Lua internally saves the user data pointer passed to `lua_newstate`.
     ///
@@ -1120,8 +1132,8 @@ pub const Lua = opaque {
     /// From: `int lua_cpcall(lua_State *L, lua_CFunction func, void *ud);`
     /// Refer to: https://www.lua.org/manual/5.1/manual.html#lua_cpcall
     /// Stack Behavior: `[-0, +(0|1), -]`
-    pub fn protectedCallCFunction(lua: *Lua, func: CFunction, ud: ?*anyopaque) ProtectedCallError!void {
-        const res = c.lua_cpcall(asState(lua), @ptrCast(func), ud);
+    pub fn protectedCallCFunction(lua: *Lua, f: CFunction, ud: ?*anyopaque) ProtectedCallError!void {
+        const res = c.lua_cpcall(asState(lua), @ptrCast(f), ud);
         assert(Status.is_status(res)); // Expected the status to be one of the "thread status" values defined in lua.h
 
         return parseCallStatus(res);
@@ -2062,3 +2074,22 @@ test "proctected call for c functions" {
     try std.testing.expectError(Lua.CallError.Runtime, actual);
     try std.testing.expectEqualSlices(u8, "EXPECTED ERROR 123", try lua.toLString(-1));
 }
+
+fn newPanicFunction(lua: *Lua) callconv(.c) i32 {
+    _ = lua;
+    return 0;
+}
+
+test "override error function with atpanic" {
+    const lua = try Lua.init(std.testing.allocator);
+    defer lua.deinit();
+
+    // This test case is actually kind of useless, I don't want to hack doing a long jump into these tests
+    // to avoid application exit. So we will just call the function and make sure the application doesn't
+    // crash. But it's not really testing that the panic function gets called in any way right now.
+
+    const actual = lua.atPanic(newPanicFunction);
+    try std.testing.expect(actual == null);
+    const new = lua.atPanic(actual);
+    try std.testing.expect(new.? == newPanicFunction);
+}