tricu

c_abi.zig (15933B)

---

 const std = @import("std");
 const wasm = @import("builtin").target.cpu.arch == .wasm32;
 const tree = @import("tree.zig");
 const Arena = @import("arena.zig").Arena;
 const reduce = @import("reduce.zig");
 const codecs = @import("codecs.zig");
 const kernel = @import("kernel.zig");
 const bundle = @import("bundle.zig");
 const io_driver = @import("io_driver.zig");
 const handles = @import("handles.zig");
 const Handle = handles.Handle;
 
 // Keep these values synchronized with include/arboricx.h.
 const Status = enum(c_int) {
     ok = 0,
     invalid_handle = 1,
     out_of_memory = 2,
     fuel_exhausted = 3,
     type_mismatch = 4,
     invalid_data = 5,
     io_error = 6,
     handle_exhausted = 7,
 };
 fn status(err: anyerror) Status {
     return switch (err) {
         error.InvalidHandle => .invalid_handle,
         error.OutOfMemory => .out_of_memory,
         error.FuelExhausted => .fuel_exhausted,
         error.HandleExhausted => .handle_exhausted,
         else => .invalid_data,
     };
 }
 
 pub const ArbCtx = struct {
     gpa: std.mem.Allocator,
     arena: Arena,
     kernel_root: u32,
     handles: handles.Table = .{},
 
     fn prepare(self: *ArbCtx) !void {
         self.arena.roots.clearRetainingCapacity();
         try self.arena.roots.append(self.gpa, self.kernel_root);
         try self.handles.appendRoots(&self.arena);
     }
     fn publish(self: *ArbCtx, node: u32, out: *Handle) Status {
         const handle = self.handles.create(self.gpa, node) catch |err| return status(err);
         out.* = handle;
         return .ok;
     }
     // Multi-output operations publish atomically: never leak half a pair.
     fn publishPair(self: *ArbCtx, a: u32, b: u32, out_a: *Handle, out_b: *Handle) Status {
         const ha = self.handles.create(self.gpa, a) catch |err| return status(err);
         const hb = self.handles.create(self.gpa, b) catch |err| {
             self.handles.release(ha) catch unreachable;
             return status(err);
         };
         out_a.* = ha;
         out_b.* = hb;
         return .ok;
     }
 };
 
 export fn arb_abi_version() u32 {
     return 2;
 }
 export fn arboricx_init() ?*ArbCtx {
     const gpa = if (wasm) std.heap.wasm_allocator else std.heap.smp_allocator;
     const ptr = gpa.create(ArbCtx) catch return null;
     ptr.* = .{ .gpa = gpa, .arena = Arena.init(gpa), .kernel_root = undefined };
     ptr.kernel_root = kernel.loadKernel(&ptr.arena) catch {
         ptr.arena.deinit();
         gpa.destroy(ptr);
         return null;
     };
     ptr.arena.gc_enabled = true;
     return ptr;
 }
 export fn arboricx_free(ctx: *ArbCtx) void {
     ctx.handles.deinit(ctx.gpa);
     ctx.arena.deinit();
     ctx.gpa.destroy(ctx);
 }
 export fn arboricx_free_buf(ctx: *ArbCtx, ptr: [*]u8, len: usize) void {
     ctx.gpa.free(ptr[0..len]);
 }
 export fn arb_release(ctx: *ArbCtx, handle: Handle) Status {
     ctx.handles.release(handle) catch |err| return status(err);
     return .ok;
 }
 export fn arb_retain(ctx: *ArbCtx, handle: Handle, out: *Handle) Status {
     const node = ctx.handles.get(handle) catch |err| return status(err);
     return ctx.publish(node, out);
 }
 export fn arb_set_gc_policy(ctx: *ArbCtx, minimum: u32, multiplier: u32) Status {
     ctx.arena.setGcPolicy(minimum, multiplier) catch |err| return status(err);
     return .ok;
 }
 export fn arb_collect(ctx: *ArbCtx) Status {
     ctx.prepare() catch |err| return status(err);
     ctx.arena.collect(&.{}) catch |err| return status(err);
     return .ok;
 }
 export fn arb_leaf(ctx: *ArbCtx, out: *Handle) Status {
     return ctx.publish(ctx.arena.alloc(.leaf) catch |err| return status(err), out);
 }
 export fn arb_stem(ctx: *ArbCtx, child: Handle, out: *Handle) Status {
     const child_node = ctx.handles.get(child) catch |err| return status(err);
     const node = ctx.arena.alloc(.{ .stem = .{ .child = child_node } }) catch |err| return status(err);
     return ctx.publish(node, out);
 }
 export fn arb_fork(ctx: *ArbCtx, left: Handle, right: Handle, out: *Handle) Status {
     const left_node = ctx.handles.get(left) catch |err| return status(err);
     const right_node = ctx.handles.get(right) catch |err| return status(err);
     const node = ctx.arena.alloc(.{ .fork = .{ .left = left_node, .right = right_node } }) catch |err| return status(err);
     return ctx.publish(node, out);
 }
 export fn arb_app(ctx: *ArbCtx, func: Handle, arg: Handle, out: *Handle) Status {
     const func_node = ctx.handles.get(func) catch |err| return status(err);
     const arg_node = ctx.handles.get(arg) catch |err| return status(err);
     const node = ctx.arena.alloc(.{ .app = .{ .func = func_node, .arg = arg_node } }) catch |err| return status(err);
     return ctx.publish(node, out);
 }
 export fn arb_is_leaf(ctx: *ArbCtx, root: Handle, out: *c_int) Status {
     const node = ctx.handles.get(root) catch |err| return status(err);
     out.* = if (ctx.arena.get(node).* == .leaf) 1 else 0;
     return .ok;
 }
 export fn arb_is_stem(ctx: *ArbCtx, root: Handle, out: *c_int) Status {
     const node = ctx.handles.get(root) catch |err| return status(err);
     out.* = if (ctx.arena.get(node).* == .stem) 1 else 0;
     return .ok;
 }
 export fn arb_is_fork(ctx: *ArbCtx, root: Handle, out: *c_int) Status {
     const node = ctx.handles.get(root) catch |err| return status(err);
     out.* = if (ctx.arena.get(node).* == .fork) 1 else 0;
     return .ok;
 }
 export fn arb_is_app(ctx: *ArbCtx, root: Handle, out: *c_int) Status {
     const node = ctx.handles.get(root) catch |err| return status(err);
     out.* = if (ctx.arena.get(node).* == .app) 1 else 0;
     return .ok;
 }
 export fn arb_get_stem_child(ctx: *ArbCtx, root: Handle, out_child: *Handle) Status {
     const idx = ctx.handles.get(root) catch |err| return status(err);
     const node = ctx.arena.get(idx).*;
     if (node != .stem) return .type_mismatch;
     return ctx.publish(node.stem.child, out_child);
 }
 export fn arb_get_fork_children(ctx: *ArbCtx, root: Handle, out_left: *Handle, out_right: *Handle) Status {
     const idx = ctx.handles.get(root) catch |err| return status(err);
     const node = ctx.arena.get(idx).*;
     if (node != .fork) return .type_mismatch;
     return ctx.publishPair(node.fork.left, node.fork.right, out_left, out_right);
 }
 export fn arb_get_app_func_arg(ctx: *ArbCtx, root: Handle, out_func: *Handle, out_arg: *Handle) Status {
     const idx = ctx.handles.get(root) catch |err| return status(err);
     const node = ctx.arena.get(idx).*;
     if (node != .app) return .type_mismatch;
     return ctx.publishPair(node.app.func, node.app.arg, out_func, out_arg);
 }
 export fn arb_reduce(ctx: *ArbCtx, root: Handle, fuel: u64, out: *Handle) Status {
     const node = ctx.handles.get(root) catch |err| return status(err);
     ctx.prepare() catch |err| return status(err);
     const result = reduce.reduce(node, &ctx.arena, fuel) catch |err| return status(err);
     return ctx.publish(result, out);
 }
 export fn arb_of_number(ctx: *ArbCtx, n: u64, out: *Handle) Status {
     return ctx.publish(codecs.ofNumber(&ctx.arena, n) catch |err| return status(err), out);
 }
 export fn arb_of_string(ctx: *ArbCtx, s: [*:0]const u8, out: *Handle) Status {
     return ctx.publish(codecs.ofString(&ctx.arena, std.mem.sliceTo(s, 0)) catch |err| return status(err), out);
 }
 export fn arb_of_bytes(ctx: *ArbCtx, bytes: [*]const u8, len: usize, out: *Handle) Status {
     return ctx.publish(codecs.ofBytes(&ctx.arena, bytes[0..len]) catch |err| return status(err), out);
 }
 export fn arb_of_list(ctx: *ArbCtx, items: [*]const Handle, len: usize, out: *Handle) Status {
     const nodes = ctx.gpa.alloc(u32, len) catch |err| return status(err);
     defer ctx.gpa.free(nodes);
     for (items[0..len], nodes) |h, *node| node.* = ctx.handles.get(h) catch |err| return status(err);
     return ctx.publish(codecs.ofList(&ctx.arena, nodes) catch |err| return status(err), out);
 }
 export fn arb_to_number(ctx: *ArbCtx, root: Handle, out: *u64) Status {
     const node = ctx.handles.get(root) catch |err| return status(err);
     ctx.prepare() catch |err| return status(err);
     const value = (codecs.toNumber(&ctx.arena, node) catch |err| return status(err)) orelse return .type_mismatch;
     out.* = value;
     return .ok;
 }
 export fn arb_to_bool(ctx: *ArbCtx, root: Handle, out: *c_int) Status {
     const node = ctx.handles.get(root) catch |err| return status(err);
     ctx.prepare() catch |err| return status(err);
     const value = (codecs.toBool(&ctx.arena, node) catch |err| return status(err)) orelse return .type_mismatch;
     out.* = if (value) 1 else 0;
     return .ok;
 }
 export fn arb_to_string(ctx: *ArbCtx, root: Handle, out_ptr: **u8, out_len: *usize) Status {
     const node = ctx.handles.get(root) catch |err| return status(err);
     ctx.prepare() catch |err| return status(err);
     const value = (codecs.toString(&ctx.arena, node) catch |err| return status(err)) orelse return .type_mismatch;
     out_ptr.* = @ptrCast(value.ptr);
     out_len.* = value.len;
     return .ok;
 }
 export fn arb_to_bytes(ctx: *ArbCtx, root: Handle, out_ptr: **u8, out_len: *usize) Status {
     return arb_to_string(ctx, root, out_ptr, out_len);
 }
 export fn arb_unwrap_result(ctx: *ArbCtx, root: Handle, out_ok: *c_int, out_value: *Handle, out_rest: *Handle) Status {
     const node = ctx.handles.get(root) catch |err| return status(err);
     ctx.prepare() catch |err| return status(err);
     const r = (codecs.unwrapResult(&ctx.arena, node) catch |err| return status(err)) orelse return .type_mismatch;
     const result = ctx.publishPair(r.value, r.rest, out_value, out_rest);
     if (result == .ok) out_ok.* = if (r.ok) 1 else 0;
     return result;
 }
 export fn arb_unwrap_host_value(ctx: *ArbCtx, root: Handle, out_tag: *u64, out_payload: *Handle) Status {
     const node = ctx.handles.get(root) catch |err| return status(err);
     ctx.prepare() catch |err| return status(err);
     const hv = (codecs.unwrapHostValue(&ctx.arena, node) catch |err| return status(err)) orelse return .type_mismatch;
     const result = ctx.publish(hv.payload, out_payload);
     if (result == .ok) out_tag.* = hv.tag;
     return result;
 }
 pub const arb_io_perms_t = extern struct { allow_read_all: c_int, allow_write_all: c_int };
 export fn arb_run_io(ctx: *ArbCtx, program: Handle, perms: ?*const arb_io_perms_t, out: *Handle) Status {
     if (wasm) return .io_error; // Native IO is unavailable in the browser prototype.
     const node = ctx.handles.get(program) catch |err| return status(err);
     ctx.prepare() catch |err| return status(err);
     const zig_perms = if (perms) |p| io_driver.IOPerms{
         .allow_read_all = p.allow_read_all != 0,
         .allow_write_all = p.allow_write_all != 0,
     } else io_driver.IOPerms{};
     const result = io_driver.runIO(ctx.gpa, &ctx.arena, node, zig_perms) catch |err| return switch (err) {
         error.OutOfMemory => .out_of_memory,
         error.FuelExhausted => .fuel_exhausted,
         else => .io_error,
     };
     return ctx.publish(result, out);
 }
 export fn arb_kernel_root(ctx: *ArbCtx, out: *Handle) Status {
     return ctx.publish(ctx.kernel_root, out);
 }
 export fn arb_load_bundle(ctx: *ArbCtx, bytes: [*]const u8, len: usize, name: [*:0]const u8, out: *Handle) Status {
     return ctx.publish(bundle.loadBundleExport(&ctx.arena, bytes[0..len], std.mem.sliceTo(name, 0)) catch |err| return status(err), out);
 }
 export fn arb_load_bundle_default(ctx: *ArbCtx, bytes: [*]const u8, len: usize, out: *Handle) Status {
     return ctx.publish(bundle.loadBundleDefaultRoot(&ctx.arena, bytes[0..len]) catch |err| return status(err), out);
 }
 
 // WASM-only host scratch buffers; not additions to the native C ABI.
 comptime {
     if (wasm) {
         @export(&hostAlloc, .{ .name = "arb_host_alloc" });
         @export(&hostFree, .{ .name = "arb_host_free" });
         @export(&hostOfText, .{ .name = "arb_host_of_text" });
         @export(&hostToText, .{ .name = "arb_host_to_text" });
         @export(&hostPreview, .{ .name = "arb_host_preview" });
         @export(&hostReduceUnbounded, .{ .name = "arb_host_reduce_unbounded" });
         @export(&hostSnapshotUnbounded, .{ .name = "arb_host_snapshot_unbounded" });
         @export(&hostPreviewUnbounded, .{ .name = "arb_host_preview_unbounded" });
         @export(&hostStats, .{ .name = "arb_host_stats" });
     }
 }
 // 8-byte alignment permits u64 ABI output parameters.
 fn hostAlloc(len: usize) callconv(.c) ?[*]align(8) u8 {
     const allocator = if (wasm) std.heap.wasm_allocator else std.heap.smp_allocator;
     const bytes = allocator.alignedAlloc(u8, .@"8", len) catch return null;
     return bytes.ptr;
 }
 fn hostFree(ptr: [*]align(8) u8, len: usize) callconv(.c) void {
     const allocator = if (wasm) std.heap.wasm_allocator else std.heap.smp_allocator;
     allocator.free(ptr[0..len]);
 }
 
 // Browser text is a list of Unicode scalars, never a list of UTF-8 bytes.
 fn hostOfText(ctx: *ArbCtx, ptr: [*]const u8, len: usize, limit: usize, out: *Handle) callconv(.c) Status {
     const view = std.unicode.Utf8View.init(ptr[0..len]) catch return .invalid_data;
     var iter = view.iterator();
     var count: usize = 0;
     while (iter.nextCodepoint()) |_| {
         if (count == limit) return .invalid_data;
         count += 1;
     }
     return ctx.publish(@import("source_text.zig").fromUtf8(&ctx.arena, ptr[0..len]) catch |err| return status(err), out);
 }
 fn hostToText(ctx: *ArbCtx, root: Handle, limit: usize, out_ptr: **u8, out_len: *usize) callconv(.c) Status {
     const node = ctx.handles.get(root) catch |err| return status(err);
     ctx.prepare() catch |err| return status(err);
     const bytes = @import("source_text.zig").toUtf8UnboundedWork(&ctx.arena, node, limit) catch |err| return status(err);
     out_ptr.* = @ptrCast(bytes.ptr);
     out_len.* = bytes.len;
     return .ok;
 }
 // Diagnostic counts, not byte/RSS limits; useful for repeated-session checks.
 fn hostStats(ctx: *ArbCtx, slots: *u32, owned: *u32, nodes: *u32, live: *u32) callconv(.c) Status {
     slots.* = @intCast(ctx.handles.slots.items.len);
     owned.* = 0;
     for (ctx.handles.slots.items) |slot| {
         if (slot.node != null) owned.* += 1;
     }
     nodes.* = ctx.arena.len();
     live.* = @intCast(ctx.arena.last_live);
     return .ok;
 }
 
 fn hostPreview(ctx: *ArbCtx, root: Handle, limit: u32, fuel: u64, out_ptr: **u8, out_len: *usize) callconv(.c) Status {
     const node = ctx.handles.get(root) catch |err| return status(err);
     ctx.prepare() catch |err| return status(err);
     const bytes = @import("preview.zig").capture(&ctx.arena, node, limit, fuel) catch |err| return status(err);
     out_ptr.* = @ptrCast(bytes.ptr);
     out_len.* = bytes.len;
     return .ok;
 }
 
 // Browser work is cancellable by Worker termination, not an implicit fuel cap.
 fn hostReduceUnbounded(ctx: *ArbCtx, root: Handle, out: *Handle) callconv(.c) Status {
     const node = ctx.handles.get(root) catch |err| return status(err);
     ctx.prepare() catch |err| return status(err);
     const result = reduce.reduceUnbounded(node, &ctx.arena) catch |err| return status(err);
     return ctx.publish(result, out);
 }
 fn hostPreviewUnbounded(ctx: *ArbCtx, root: Handle, limit: u32, out_ptr: **u8, out_len: *usize) callconv(.c) Status {
     const node = ctx.handles.get(root) catch |err| return status(err);
     ctx.prepare() catch |err| return status(err);
     const bytes = @import("preview.zig").captureUnboundedWork(&ctx.arena, node, limit) catch |err| return status(err);
     out_ptr.* = @ptrCast(bytes.ptr);
     out_len.* = bytes.len;
     return .ok;
 }
 
 // Full bounded result transport, distinct from the 256-node preview API.
 fn hostSnapshotUnbounded(ctx: *ArbCtx, root: Handle, limit: u32, out_ptr: **u8, out_len: *usize) callconv(.c) Status {
     const node = ctx.handles.get(root) catch |err| return status(err);
     ctx.prepare() catch |err| return status(err);
     const bytes = @import("preview.zig").snapshotUnboundedWork(&ctx.arena, node, limit) catch |err| return status(err);
     out_ptr.* = @ptrCast(bytes.ptr);
     out_len.* = bytes.len;
     return .ok;
 }