Update to Zig 0.14.1 including ManagedIter

build.zig

@@ -12,11 +12,13 @@ pub fn build(b: *std.Build) void {
 
     compiled_capstone.getEmittedIncludeTree().addStepDependencies(&compiled_capstone.step);
     const capstone_c = b.addTranslateC(.{
-        .root_source_file = compiled_capstone.getEmittedIncludeTree().path(b, "capstone/capstone.h"),
+        .root_source_file = compiled_capstone.getEmittedIncludeTree().path(b, "capstone.h"),
         .target = target,
         .optimize = optimize,
         .link_libc = true,
     });
+    // expose it for headers...
+    const capstone_c_mod = capstone_c.createModule();
 
     const mod = b.addModule("capstone-bindings-zig", .{
         .root_source_file = b.path("capstone.zig"),
@@ -25,7 +27,7 @@ pub fn build(b: *std.Build) void {
         .imports = &.{
             .{
                 .name = "capstone-c",
-                .module = capstone_c.createModule(),
+                .module = capstone_c_mod,
             },
         },
     });
@@ -34,13 +36,16 @@ pub fn build(b: *std.Build) void {
     mod.addIncludePath(compiled_capstone.getEmittedIncludeTree());
 
     const mod_test = b.addTest(.{
-        .root_source_file = mod.root_source_file.?,
+        .root_source_file = b.path("src/tests.zig"),
         .target = target,
         .optimize = optimize,
     });
     mod_test.step.dependOn(&compiled_capstone.step);
 
-    mod_test.root_module.addImport("capstone-c", capstone_c.createModule());
+    mod_test.root_module.addImport("capstone-c", capstone_c_mod);
+    mod_test.addLibraryPath(compiled_capstone.getEmittedBin().dirname());
+    mod_test.linkLibrary(capstone.artifact("capstone"));
+    mod_test.addIncludePath(compiled_capstone.getEmittedIncludeTree());
 
     const run_lib_tests = b.addRunArtifact(mod_test);
     const test_step = b.step("test", "Run the library tests");

build.zig.zon

@@ -1,12 +1,13 @@
 .{
-    .name = "capstone-bindings-zig",
+    .name = .capstone_bindings_zig,
     .version = "5.0.1",
+    .fingerprint = 0x52b01062163ea867,
     .minimum_zig_version = "0.14.0",
 
     .dependencies = .{
         .capstone = .{
-            .url = "git+https://github.com/allyourcodebase/capstone.git#5.0.1-1",
-            .hash = "1220f284ea55271b5b68edb4471d10c622e5d5c220dd342c6e96ff50d3b801f46486",
+            .url = "git+https://github.com/allyourcodebase/capstone.git?ref=main#6035a194bea8472c463345b86c3ef9333490ecfe",
+            .hash = "capstone-5.0.1-tmNUgTRHAAC1nFVy0colCWwUSRm05SWdD-4kU5MK4ZpH",
         },
     },
 

capstone.zig

@@ -1,6 +1,9 @@
 const impl = @import("src/impl.zig");
 pub const Iter = impl.Iter;
+pub const IterManaged = impl.IterManaged;
 pub const Handle = impl.Handle;
+pub const Detail = impl.insn.Detail;
+pub const Insn = impl.insn.Insn;
 pub const version = impl.version;
 pub const support = impl.support;
 pub const open = impl.open;
@@ -42,3 +45,7 @@ const enums = @import("src/enums.zig");
 pub const Arch = enums.Arch;
 pub const Mode = enums.Mode;
 pub const Type = enums.Type;
+
+pub const ManagedHandle = @import("src/ManagedHandle.zig");
+
+pub const c = @import("capstone-c");

src/ManagedHandle.zig

@@ -0,0 +1,136 @@
+const builtin = @import("builtin");
+const std = @import("std");
+
+const cs = @import("capstone-c");
+
+const err = @import("error.zig");
+const insn = @import("insn.zig");
+const setup = @import("setup.zig");
+const enums = @import("enums.zig");
+const impl = @import("impl.zig");
+
+const iter = @import("iter.zig");
+
+const Iter = iter.Iter;
+const IterManaged = iter.IterManaged;
+
+native: impl.Handle,
+
+// To avoid heap allocations...
+const TmpStorage = blk: {
+    if (builtin.single_threaded) {
+        break :blk struct {
+            var detail: insn.Detail = std.mem.zeroes(insn.Detail);
+            var ins: insn.Insn = std.mem.zeroes(insn.Insn);
+            fn getIns() *insn.Insn {
+                ins.detail = &detail;
+                return &ins;
+            }
+        };
+    } else {
+        break :blk struct {
+            threadlocal var detail: insn.Detail = std.mem.zeroes(insn.Detail);
+            threadlocal var ins: insn.Insn = std.mem.zeroes(insn.Insn);
+            fn getIns() *insn.Insn {
+                ins.detail = &detail;
+                return &ins;
+            }
+        };
+    }
+};
+
+const Self = @This();
+
+pub const Options = struct {
+    /// Assembly output syntax
+    syntax: enums.Syntax = .DEFAULT,
+    /// Break down instruction structure into details
+    detail: bool = false,
+    /// Skip data when disassembling. Then engine is in SKIPDATA mode.
+    skipdata: bool = false,
+    /// Customize instruction mnemonic
+    /// Must be valid till the handle is closed if set.
+    mnemonic: []const MnemonicOption = &.{},
+    /// print immediate operands in unsigned form
+    unsigned: bool = false,
+    /// ARM, prints branch immediates without offset.
+    no_branch_offset: bool = false,
+
+    /// cs_opt_mnem
+    pub const MnemonicOption = extern struct {
+        id: c_uint,
+        mnemonic: [*:0]const u8,
+    };
+};
+
+pub fn init(arch: enums.Arch, mode: enums.Mode, options: Options) !Self {
+    const handle = try impl.open(arch, mode);
+
+    if (options.syntax != .DEFAULT) {
+        try impl.option(handle, .SYNTAX, @intFromEnum(options.syntax));
+    }
+
+    if (options.detail) {
+        try impl.option(handle, .DETAIL, cs.CS_OPT_ON);
+    }
+
+    if (options.skipdata) {
+        try impl.option(handle, .SKIPDATA, cs.CS_OPT_ON);
+    }
+
+    if (options.unsigned) {
+        try impl.option(handle, .UNSIGNED, cs.CS_OPT_ON);
+    }
+
+    if (options.no_branch_offset) {
+        try impl.option(handle, .NO_BRANCH_OFFSET, cs.CS_OPT_ON);
+    }
+
+    if (options.mnemonic.len > 0) {
+        try impl.option(handle, .MNEMONIC, @intFromPtr(options.mnemonic.ptr));
+    }
+
+    return Self{ .native = handle };
+}
+
+/// Allocates using the cs_malloc function or the user defined one which is set through cs_option/setup.initCapstone(Manually).
+/// Should be freed using cs_free, capstone provided free function or the user defined one if set through option.
+pub fn disasm(self: Self, code: []const u8, address: usize, count: usize) err.CapstoneError![]insn.Insn {
+    return impl.disasm(self.native, code, address, count);
+}
+
+/// Copies using zig user-land allocator and frees the cs_malloc'd memory.
+pub fn disasmAlloc(self: Self, allocator: std.mem.Allocator, code: []const u8, address: usize, count: usize) ![]insn.Insn {
+    const disass = try impl.disasm(self.native, code, address, count);
+    defer impl.free(disass);
+    return allocator.dupe(insn.Insn, disass);
+}
+
+/// Uses global/threadlocal storage to avoid heap allocations for the single Insn struct.
+pub fn disasmIter(self: Self, code: []const u8, address: u64) Iter {
+    return Iter.init(self.native, code, address, @ptrCast(TmpStorage.getIns()));
+}
+
+pub fn deinit(self: *Self) void {
+    impl.close(&self.native) catch |e| {
+        std.debug.print("Failed to close handle: {any}\n", .{impl.strerror(e)});
+    };
+}
+
+test "with options" {
+    const code = "\x75\x14";
+
+    var handle = try init(.X86, .@"64", .{
+        .syntax = .INTEL,
+        .detail = true,
+        .mnemonic = &.{.{ .id = cs.X86_INS_JNE, .mnemonic = "jnz" }},
+    });
+    defer handle.deinit();
+
+    const disass = try handle.disasm(code, 0x1000, 0);
+    defer impl.free(disass);
+
+    try std.testing.expectEqual(1, disass.len);
+    try std.testing.expect(disass[0].detail != null);
+    try std.testing.expectEqualStrings("jnz", disass[0].mnemonic[0..3]);
+}

src/enums.zig

@@ -111,3 +111,12 @@ pub const Type = enum(cs.cs_opt_type) {
     UNSIGNED,
     NO_BRANCH_OFFSET,
 };
+
+pub const Syntax = enum(cs.cs_opt_value) {
+    DEFAULT = 0,
+    INTEL,
+    ATT,
+    NOREGNAME,
+    MASM,
+    MOTOROLA,
+};

src/impl.zig

@@ -4,8 +4,10 @@ pub const err = @import("error.zig");
 pub const insn = @import("insn.zig");
 pub const setup = @import("setup.zig");
 pub const enums = @import("enums.zig");
+const iter = @import("iter.zig");
 
-pub const Iter = @import("iter.zig").Iter;
+pub const Iter = iter.Iter;
+pub const IterManaged = iter.IterManaged;
 pub const Handle = cs.csh;
 
 pub fn version(major: ?*c_int, minor: ?*c_int) err.CapstoneError!void {
@@ -69,25 +71,14 @@ pub fn malloc(handle: Handle) [*]insn.Insn {
 }
 
 /// Same as the normal Variant, but does the allocation for you.
-pub fn disasmIterManaged(handle: Handle, code: []const u8, address: u64) Iter {
-    const ins = malloc(handle);
-    return Iter{
-        .handle = handle,
-        .code = code,
-        .address = address,
-        .insn = ins,
-    };
+pub fn disasmIterManaged(handle: Handle, code: []const u8, address: u64) IterManaged {
+    return IterManaged.init(handle, code, address);
 }
 
 /// Return an Iter object
 /// Does not yet consume any element.
 pub fn disasmIter(handle: Handle, code: []const u8, address: u64, ins: [*]insn.Insn) Iter {
-    return Iter{
-        .handle = handle,
-        .code = code,
-        .address = address,
-        .insn = ins,
-    };
+    return Iter.init(handle, code, address, ins);
 }
 
 pub fn regName(handle: Handle, reg_id: c_uint) [*:0]const u8 {
@@ -138,4 +129,5 @@ test {
     @import("std").testing.refAllDecls(@import("error.zig"));
     @import("std").testing.refAllDecls(@import("insn.zig"));
     @import("std").testing.refAllDecls(@import("setup.zig"));
+    @import("std").testing.refAllDecls(@import("ManagedHandle.zig"));
 }

src/insn.zig

@@ -8,7 +8,9 @@ pub const Detail = extern struct {
     groups: [8]u8,
     groups_count: u8,
     writeback: bool,
-    arch: arch.Arch,
+    arch: Arch,
+
+    pub const Arch = arch.Arch;
 };
 
 pub const Insn = extern struct {

src/iter.zig

@@ -3,13 +3,26 @@ const cs = @import("capstone-c");
 const Insn = @import("insn.zig").Insn;
 const Handle = cs.csh;
 
-// The Iterator for traversing the disassembler
+/// The Iterator for traversing the disassembler
 pub const Iter = struct {
     handle: Handle,
     code: []const u8,
+    original_code: []const u8,
+    original_address: u64,
     address: u64,
     insn: [*]Insn,
 
+    pub fn init(handle: Handle, code: []const u8, address: u64, insn: [*]Insn) Iter {
+        return Iter{
+            .handle = handle,
+            .code = code,
+            .original_code = code,
+            .original_address = address,
+            .address = address,
+            .insn = insn,
+        };
+    }
+
     // Consumes the iterator and goes to the next
     pub fn next(self: *Iter) ?*Insn {
         if (cs.cs_disasm_iter(self.handle, @ptrCast(&self.code.ptr), @ptrCast(&self.code.len), &self.address, @ptrCast(self.insn))) {
@@ -21,13 +34,36 @@ pub const Iter = struct {
         }
     }
 
-    // Clean up the iter
-    pub fn deinit(self: Iter) void {
-        cs.cs_free(@ptrCast(self.insn), 1);
+    pub fn reset(self: *Iter) void {
+        self.address = self.original_address;
+        self.code = self.original_code;
+    }
+};
+
+/// The Iterator for traversing the disassembler, but **allocates** space using capstone malloc.
+pub const IterManaged = struct {
+    inner: Iter,
+    insn: [*]Insn,
+
+    pub fn init(handle: Handle, code: []const u8, address: u64) IterManaged {
+        const insn: [*]Insn = @ptrCast(cs.cs_malloc(handle));
+        return .{
+            .inner = Iter.init(handle, code, address, insn),
+            .insn = insn,
+        };
+    }
+
+    // Consumes the iterator and goes to the next
+    pub fn next(self: *IterManaged) ?*Insn {
+        return self.inner.next();
     }
 
-    /// Returns the current address
-    pub fn address(self: Iter) u64 {
-        return self.address;
+    pub fn reset(self: *IterManaged) void {
+        self.inner.reset();
+    }
+
+    // Clean up the iter
+    pub fn deinit(self: IterManaged) void {
+        cs.cs_free(@ptrCast(self.insn), 1);
     }
 };