tricu

io_v2_core_probe.zig (5456B)

---

 //! Test-only executable: compiled source against the private core, no native IO
 //! facilities. This is not the tricu-zig CLI or a compiler execution backend.
 const std = @import("std");
 const Arena = @import("arena.zig").Arena;
 const P = @import("io_v2_protocol.zig");
 const C = @import("codecs.zig");
 const Core = @import("io_v2_core.zig");
 const bundle = @import("bundle.zig");
 const reduce = @import("reduce.zig");
 pub fn main(init: std.process.Init) !void {
     return mainFor(Core.UnsupportedHost, init);
 }
 pub fn mainFor(comptime Host: type, init: std.process.Init) !void {
     const args = try init.minimal.args.toSlice(init.arena.allocator());
     if (args.len < 3) return error.ExpectedBundleAndExport;
     const bytes = try std.Io.Dir.cwd().readFileAlloc(init.io, args[1], init.gpa, .limited(10 * 1024 * 1024));
     defer init.gpa.free(bytes);
     var arena = Arena.init(init.gpa);
     defer arena.deinit();
     var root = try bundle.loadBundleExport(&arena, bytes, args[2]);
     for (args[3..]) |argument| {
         const value = if (std.mem.startsWith(u8, argument, "tree-file:")) blk: {
             const raw = try std.Io.Dir.cwd().readFileAlloc(init.io, argument[10..], init.gpa, .limited(10 * 1024 * 1024));
             defer init.gpa.free(raw);
             break :blk try parseRaw(&arena, raw);
         } else if (std.mem.startsWith(u8, argument, "text:")) try @import("source_text.zig").fromUtf8(&arena, argument[5..]) else try C.ofNumber(&arena, try std.fmt.parseUnsigned(u64, argument, 10));
         root = try arena.allocApp(root, value);
     }
     try arena.roots.append(init.gpa, root);
     arena.gc_enabled = true;
     try arena.setGcPolicy(128, 1);
     const r: P.Reader = .{ .arena = &arena, .fuel = std.math.maxInt(u64) };
     const envelope = try r.pair(root) orelse return error.InvalidEnvelope;
     var name = envelope.first;
     for ("tricuIO") |ch| {
         const cell = try r.pair(name) orelse return error.InvalidEnvelope;
         if (try r.nat(cell.first, 7) != @as(?u64, ch)) return error.InvalidEnvelope;
         name = cell.second;
     }
     if (try r.node(name) != .leaf) return error.InvalidEnvelope;
     const body = try r.pair(envelope.second) orelse return error.InvalidEnvelope;
     if (try r.nat(body.first, 16) != @as(?u64, 2)) return error.UnsupportedVersion;
     // Drop the input envelope; private run will root the current computation.
     arena.roots.clearRetainingCapacity();
     var host: Host = .{};
     const outcome = try Core.runWithHost(Host, &host, &arena, body.second, 1, std.math.maxInt(u64));
     if (outcome.kind != .completed) {
         var error_output = std.Io.File.stderr().writer(init.io, &.{});
         try error_output.interface.writeAll(if (outcome.kind == .failed) "failed (payload not forced)\n" else "cancelled (reason not forced)\n");
         try error_output.flush();
         std.process.exit(1);
     }
     try arena.roots.append(init.gpa, outcome.value);
     var stack: std.ArrayList(u32) = .empty;
     defer stack.deinit(init.gpa);
     try stack.append(init.gpa, outcome.value);
     var buffer: [4096]u8 = undefined;
     var output = std.Io.File.stdout().writer(init.io, &buffer);
     var count: usize = 0;
     while (stack.pop()) |id| {
         count += 1;
         if (count > 1048576) return error.ResultLimit;
         const node = arena.get(try reduce.reduce(id, &arena, 1_000_000)).*;
         switch (node) {
             .leaf => try output.interface.writeByte('0'),
             .stem => |s| {
                 try output.interface.writeByte('1');
                 try stack.append(init.gpa, s.child);
             },
             .fork => |f| {
                 try output.interface.writeByte('2');
                 try stack.appendSlice(init.gpa, &.{ f.right, f.left });
             },
             .app => unreachable,
         }
     }
     try output.interface.writeByte('\n');
     try output.flush();
 }
 
 // Exact raw constructor tree (0/1/2 bytes), parsed without recursion or ignored
 // trailing roots. Private source controls can pass NUL and malformed scalar data.
 fn parseRaw(arena: *Arena, bytes: []const u8) !u32 {
     var stack: std.ArrayList(u32) = .empty;
     defer stack.deinit(arena.allocator);
     var at = bytes.len;
     while (at != 0) {
         at -= 1;
         const node: @import("tree.zig").Node = switch (bytes[at]) {
             0 => .leaf,
             1 => .{ .stem = .{ .child = stack.pop() orelse return error.InvalidRawTree } },
             2 => .{ .fork = .{ .left = stack.pop() orelse return error.InvalidRawTree, .right = stack.pop() orelse return error.InvalidRawTree } },
             else => return error.InvalidRawTree,
         };
         try stack.append(arena.allocator, try arena.alloc(node));
     }
     if (stack.items.len != 1) return error.InvalidRawTree;
     return stack.items[0];
 }
 
 test "private raw argument parser is exact, iterative and preserves constructor order" {
     const t = std.testing;
     var a = Arena.init(t.allocator);
     defer a.deinit();
     const root = try parseRaw(&a, &.{ 2, 1, 0, 0 });
     const node = a.get(root).fork;
     try t.expect(a.get(node.left).* == .stem and a.get(node.right).* == .leaf);
     for ([_][]const u8{ &.{}, &.{ 0, 0 }, &.{1}, &.{ 2, 0 }, &.{3}, "0" }) |raw| try t.expectError(error.InvalidRawTree, parseRaw(&a, raw));
     const deep = try t.allocator.alloc(u8, 100001);
     defer t.allocator.free(deep);
     @memset(deep, 1);
     deep[deep.len - 1] = 0;
     _ = try parseRaw(&a, deep);
 }