Add support for lua.getHook(), lua.getHookMask(), lua.getHookCount(); fix example project (#10)

Author: thsackos

README.md

@@ -87,7 +87,7 @@ you.
 |-----------------------------|---------------------------------------|
 | Lua C API (`lua_*`)         | 🎉 100% coverage<sup>†</sup> (92/92)  |
 | Auxilary Library (`luaL_*`) | 🤩 100% coverage (48/48)              |
-| Debug API (`lua_Debug`)     | 32% coverage (4/12)                   |
+| Debug API (`lua_Debug`)     | 56% coverage (7/12)                   |
 | LuaJIT Extensions           | *No plans to implement.*              |
 
 *†: Coroutine yield/resume is not yet part of the public `zig-luajit` Zig API, see [#6][ISSUE-6].*
@@ -279,9 +279,9 @@ This section describes the current status of Zig language bindings ("the Zig API
 | C API Symbol               | Available in `zig-luajit`           |
 |----------------------------|-------------------------------------|
 | `lua_getinfo`              | ☑️ `lua.getInfo()`                   |
-| `lua_gethookcount`         ||
-| `lua_gethookmask`          ||
-| `lua_gethook`              ||
+| `lua_gethookcount`         | ☑️ `lua.getHookCount()`              |
+| `lua_gethookmask`          | ☑️ `lua.getHookMask()`               |
+| `lua_gethook`              | ☑️ `lua.getHook()`                   |
 | `lua_getlocal`             ||
 | `lua_getstack`             | ☑️ `lua.getStack()`                  |
 | `lua_getupvalue`           ||

examples/simple-repl/build.zig.zon

@@ -3,8 +3,7 @@
     .version = "0.0.0",
     .dependencies = .{
         .luajit = .{
-            .url = "git+https://github.com/sackosoft/zig-luajit#acadbe23b91afc429eb8a39ffbf8db0845dcc4e4",
-            .hash = "12202f16fd460b199280f3c6191002c3c69843bf388622da671fbd16f3fcc5d045e4",
+            .path = "../.."
         },
     },
     .paths = .{

examples/simple-repl/main.zig

@@ -17,17 +17,21 @@ pub fn main() !void {
     const stdin = std.io.getStdIn();
     const stdout = std.io.getStdOut();
 
-    var buf: [1024]u8 = undefined;
+    var buf: [1025]u8 = undefined;
+    const read_slice = buf[0..1024];
 
     while (true) {
         try stdout.writeAll("> ");
 
-        const input = try stdin.reader().readUntilDelimiter(&buf, '\n');
+        const input = try stdin.reader().readUntilDelimiter(read_slice, '\n');
         if (input.len == 0) continue;
 
         if (std.mem.eql(u8, input, "exit")) break;
 
-        lua.doString(input) catch |err| {
+        buf[input.len] = 0;
+        const actual = buf[0..input.len :0];
+
+        lua.doString(actual) catch |err| {
             std.debug.print("Error: {}\n", .{err});
             continue;
         };

src/root.zig

@@ -2939,6 +2939,8 @@ pub const Lua = opaque {
     pub const HookMask = packed struct(u32) {
         /// Used as the `mask` parameter to `setHook()` in order to disable a hook.
         pub const disabled: HookMask = .{};
+        pub const call_only: HookMask = .{ .on_call = true };
+        pub const call_and_return: HookMask = .{ .on_call = true, .on_return = true };
 
         /// Indicates that the hook function should be invoked when the Lua runtime calls a function.
         on_call: bool = false,
@@ -2984,9 +2986,37 @@ pub const Lua = opaque {
     /// Refer to: https://www.lua.org/manual/5.1/manual.html#lua_sethook
     /// Stack Behavior: `[-0, +0, -]`
     pub fn setHook(lua: *Lua, f: HookFunction, mask: HookMask, count: i32) void {
+        assert(count >= 0);
         const res = c.lua_sethook(asState(lua), @ptrCast(f), @bitCast(mask), count);
         assert(1 == res);
     }
+
+    /// Returns the current hook function.
+    ///
+    /// From: `lua_Hook lua_gethook(lua_State *L);`
+    /// Refer to: https://www.lua.org/manual/5.1/manual.html#lua_gethook
+    /// Stack Behavior: `[-0, +0, -]`
+    pub fn getHook(lua: *Lua) ?HookFunction {
+        return @ptrCast(c.lua_gethook(asState(lua)));
+    }
+
+    /// Returns the current hook count.
+    ///
+    /// From: `int lua_gethookcount(lua_State *L);`
+    /// Refer to: https://www.lua.org/manual/5.1/manual.html#lua_gethookcount
+    /// Stack Behavior: `[-0, +0, -]`
+    pub fn getHookCount(lua: *Lua) i32 {
+        return c.lua_gethookcount(asState(lua));
+    }
+
+    /// Returns the current hook mask.
+    ///
+    /// From: `int lua_gethookmask(lua_State *L);`
+    /// Refer to: https://www.lua.org/manual/5.1/manual.html#lua_gethookmask
+    /// Stack Behavior: `[-0, +0, -]`
+    pub fn getHookMask(lua: *Lua) HookMask {
+        return @bitCast(c.lua_gethookmask(asState(lua)));
+    }
 };
 
 test "Lua can be initialized with an allocator" {
@@ -5658,3 +5688,70 @@ test "setHook() can be used register a callback to intercept function calls" {
     try std.testing.expect(lua.isInteger(-1));
     try std.testing.expectEqual(1, try lua.toIntegerStrict(-1));
 }
+
+test "getHook() can be used check the current hook function" {
+    const lua = try Lua.init(std.testing.allocator);
+    defer lua.deinit();
+
+    const T = struct {
+        fn hook(l: *Lua, info: *Lua.DebugInfo) callconv(.c) void {
+            _ = l;
+            _ = info;
+        }
+    };
+
+    lua.setHook(T.hook, .{ .on_call = true }, 0);
+    try std.testing.expectEqual(T.hook, lua.getHook());
+}
+
+test "getHookMask() can be used check the current hook function subscription" {
+    const lua = try Lua.init(std.testing.allocator);
+    defer lua.deinit();
+
+    const T = struct {
+        fn hook(l: *Lua, info: *Lua.DebugInfo) callconv(.c) void {
+            _ = l;
+            _ = info;
+        }
+    };
+
+    const e1 = Lua.HookMask{};
+    lua.setHook(T.hook, e1, 0);
+    try std.testing.expectEqual(e1, lua.getHookMask());
+
+    const e2 = Lua.HookMask{ .on_call = true };
+    lua.setHook(T.hook, e2, 0);
+    try std.testing.expectEqual(e2, lua.getHookMask());
+
+    const e3 = Lua.HookMask{ .on_call = true, .on_return = true };
+    lua.setHook(T.hook, e3, 0);
+    try std.testing.expectEqual(e3, lua.getHookMask());
+
+    const e4 = Lua.HookMask{ .on_line = true };
+    lua.setHook(T.hook, e4, 0);
+    try std.testing.expectEqual(e4, lua.getHookMask());
+
+    const e5 = Lua.HookMask{ .on_call = true, .on_return = true, .on_line = true, .on_count = true };
+    lua.setHook(T.hook, e5, 0);
+    try std.testing.expectEqual(e5, lua.getHookMask());
+}
+
+test "getHookCount() can be used check the current hook function count" {
+    const lua = try Lua.init(std.testing.allocator);
+    defer lua.deinit();
+
+    const T = struct {
+        fn hook(l: *Lua, info: *Lua.DebugInfo) callconv(.c) void {
+            _ = l;
+            _ = info;
+        }
+    };
+
+    const e1 = 0;
+    lua.setHook(T.hook, Lua.HookMask.call_and_return, 0);
+    try std.testing.expectEqual(e1, lua.getHookCount());
+
+    const e2 = 42;
+    lua.setHook(T.hook, Lua.HookMask.call_and_return, 42);
+    try std.testing.expectEqual(e2, lua.getHookCount());
+}