From 699f877bd51bc93717c76573a61a7b5598f1bd82 Mon Sep 17 00:00:00 2001 From: Manlio Perillo Date: Fri, 19 May 2023 15:28:20 +0200 Subject: [PATCH] build: remove `ZiglingStep.eval` Remove the `ZiglingStep.eval` method and the src/ipc.zig source code. Use `Step.evalZigProcess`, instead. This greatly simplifies the code. Print the error messages and error bundle in `ZiglingStep.make`, both in case of error and success. Additionally, remove the `ZiglingStep.is_testing` field, since it is no longer necessary. --- build.zig | 180 +++++----------------------------------------------- src/ipc.zig | 68 -------------------- 2 files changed, 17 insertions(+), 231 deletions(-) delete mode 100644 src/ipc.zig diff --git a/build.zig b/build.zig index 46a260d..2e25217 100644 --- a/build.zig +++ b/build.zig @@ -1,7 +1,6 @@ const std = @import("std"); const builtin = @import("builtin"); const compat = @import("src/compat.zig"); -const ipc = @import("src/ipc.zig"); const tests = @import("test/tests.zig"); const Build = compat.Build; @@ -195,10 +194,6 @@ const ZiglingStep = struct { work_path: []const u8, mode: Mode, - is_testing: bool = false, - result_messages: []const u8 = "", - result_error_bundle: std.zig.ErrorBundle = std.zig.ErrorBundle.empty, - pub fn create( b: *Build, exercise: Exercise, @@ -232,6 +227,8 @@ const ZiglingStep = struct { } const exe_path = self.compile(prog_node) catch { + self.printErrors(); + if (self.exercise.hint) |hint| print("\n{s}Ziglings hint: {s}{s}", .{ bold_text, hint, reset_text }); @@ -240,12 +237,17 @@ const ZiglingStep = struct { }; self.run(exe_path, prog_node) catch { + self.printErrors(); + if (self.exercise.hint) |hint| print("\n{s}Ziglings hint: {s}{s}", .{ bold_text, hint, reset_text }); self.help(); std.os.exit(2); }; + + // Print possible warning/debug messages. + self.printErrors(); } fn run(self: *ZiglingStep, exe_path: []const u8, _: *std.Progress.Node) !void { @@ -381,153 +383,7 @@ const ZiglingStep = struct { zig_args.append("--listen=-") catch @panic("OOM"); - const argv = zig_args.items; - var code: u8 = undefined; - const exe_path = self.eval(argv, &code, prog_node) catch |err| { - self.printErrors(); - - switch (err) { - error.FileNotFound => { - print("{s}{s}: Unable to spawn the following command: file not found{s}\n", .{ - red_text, self.exercise.main_file, reset_text, - }); - dumpArgs(argv); - }, - error.ExitCodeFailure => { - print("{s}{s}: The following command exited with error code {}:{s}\n", .{ - red_text, self.exercise.main_file, code, reset_text, - }); - dumpArgs(argv); - }, - error.ProcessTerminated => { - print("{s}{s}: The following command terminated unexpectedly:{s}\n", .{ - red_text, self.exercise.main_file, reset_text, - }); - dumpArgs(argv); - }, - error.ZigIPCError => { - // Commenting this out for now. It always shows up when compilation fails. - //print("{s}{s}: The following command failed to communicate the compilation result:{s}\n", .{ - // red_text, self.exercise.main_file, reset_text, - //}); - //dumpArgs(argv); - }, - else => { - print("{s}{s}: Unexpected error: {s}{s}\n", .{ - red_text, self.exercise.main_file, @errorName(err), reset_text, - }); - dumpArgs(argv); - }, - } - - return err; - }; - self.printErrors(); - - return exe_path; - } - - // Code adapted from `std.Build.execAllowFail and `std.Build.Step.evalZigProcess`. - pub fn eval( - self: *ZiglingStep, - argv: []const []const u8, - out_code: *u8, - prog_node: *std.Progress.Node, - ) ![]const u8 { - assert(argv.len != 0); - const b = self.step.owner; - const allocator = b.allocator; - - var child = Child.init(argv, allocator); - child.env_map = b.env_map; - child.stdin_behavior = .Pipe; - child.stdout_behavior = .Pipe; - child.stderr_behavior = .Pipe; - - try child.spawn(); - - var poller = std.io.poll(allocator, enum { stdout, stderr }, .{ - .stdout = child.stdout.?, - .stderr = child.stderr.?, - }); - defer poller.deinit(); - - try ipc.sendMessage(child.stdin.?, .update); - try ipc.sendMessage(child.stdin.?, .exit); - - const Header = std.zig.Server.Message.Header; - var result: ?[]const u8 = null; - - var node_name: std.ArrayListUnmanaged(u8) = .{}; - defer node_name.deinit(allocator); - var sub_prog_node = prog_node.start("", 0); - defer sub_prog_node.end(); - - const stdout = poller.fifo(.stdout); - - poll: while (true) { - while (stdout.readableLength() < @sizeOf(Header)) { - if (!(try poller.poll())) break :poll; - } - const header = stdout.reader().readStruct(Header) catch unreachable; - while (stdout.readableLength() < header.bytes_len) { - if (!(try poller.poll())) break :poll; - } - const body = stdout.readableSliceOfLen(header.bytes_len); - - switch (header.tag) { - .zig_version => { - if (!std.mem.eql(u8, builtin.zig_version_string, body)) - return error.ZigVersionMismatch; - }, - .error_bundle => { - self.result_error_bundle = try ipc.parseErrorBundle(allocator, body); - }, - .progress => { - node_name.clearRetainingCapacity(); - try node_name.appendSlice(allocator, body); - sub_prog_node.setName(node_name.items); - }, - .emit_bin_path => { - const emit_bin = try ipc.parseEmitBinPath(allocator, body); - result = emit_bin.path; - }, - else => {}, // ignore other messages - } - - stdout.discard(body.len); - } - - const stderr = poller.fifo(.stderr); - if (stderr.readableLength() > 0) { - self.result_messages = try stderr.toOwnedSlice(); - } - - // Send EOF to stdin. - child.stdin.?.close(); - child.stdin = null; - - // Keep the errors compatible with std.Build.execAllowFail. - const term = try child.wait(); - switch (term) { - .Exited => |code| { - if (code != 0) { - out_code.* = @truncate(u8, code); - - return error.ExitCodeFailure; - } - }, - .Signal, .Stopped, .Unknown => |code| { - out_code.* = @truncate(u8, code); - - return error.ProcessTerminated; - }, - } - - if (self.is_testing) { - return "ok"; - } - return result orelse return error.ZigIPCError; + return try self.step.evalZigProcess(zig_args.items, prog_node); } fn help(self: *ZiglingStep) void { @@ -548,27 +404,25 @@ const ZiglingStep = struct { fn printErrors(self: *ZiglingStep) void { resetLine(); - // Print the additional log and verbose messages. - // TODO: use colors? - if (self.result_messages.len > 0) print("{s}", .{self.result_messages}); + // Display error/warning messages. + if (self.step.result_error_msgs.items.len > 0) { + for (self.step.result_error_msgs.items) |msg| { + print("{s}error: {s}{s}\n", .{ red_text, reset_text, msg }); + } + } - // Print the compiler errors. + // Render compile errors at the bottom of the terminal. // TODO: use the same ttyconf from the builder. const ttyconf: std.debug.TTY.Config = if (use_color_escapes) .escape_codes else .no_color; - if (self.result_error_bundle.errorMessageCount() > 0) { - self.result_error_bundle.renderToStdErr(.{ .ttyconf = ttyconf }); + if (self.step.result_error_bundle.errorMessageCount() > 0) { + self.step.result_error_bundle.renderToStdErr(.{ .ttyconf = ttyconf }); } } }; -fn dumpArgs(args: []const []const u8) void { - for (args) |arg| print("{s} ", .{arg}); - print("\n", .{}); -} - /// Clears the entire line and move the cursor to column zero. /// Used for clearing the compiler and build_runner progress messages. fn resetLine() void { diff --git a/src/ipc.zig b/src/ipc.zig deleted file mode 100644 index 9eaaa13..0000000 --- a/src/ipc.zig +++ /dev/null @@ -1,68 +0,0 @@ -/// Client side support for Zig IPC. -const std = @import("std"); -const debug = std.debug; -const fs = std.fs; -const mem = std.mem; - -const Allocator = mem.Allocator; -const Client = std.zig.Client; -const ErrorBundle = std.zig.ErrorBundle; -const Server = std.zig.Server; - -/// This data structure must be kept in sync with zig.Server.Message.EmitBinPath. -const EmitBinPath = struct { - flags: Flags, - path: []const u8, - - pub const Flags = Server.Message.EmitBinPath.Flags; - - pub fn deinit(self: *EmitBinPath, allocator: Allocator) void { - allocator.free(self.path); - self.* = undefined; - } -}; - -pub fn parseErrorBundle(allocator: Allocator, data: []const u8) !ErrorBundle { - const EbHdr = Server.Message.ErrorBundle; - const eb_hdr = @ptrCast(*align(1) const EbHdr, data); - const extra_bytes = - data[@sizeOf(EbHdr)..][0 .. @sizeOf(u32) * eb_hdr.extra_len]; - const string_bytes = - data[@sizeOf(EbHdr) + extra_bytes.len ..][0..eb_hdr.string_bytes_len]; - - // TODO: use @ptrCast when the compiler supports it - const unaligned_extra = std.mem.bytesAsSlice(u32, extra_bytes); - const extra_array = try allocator.alloc(u32, unaligned_extra.len); - // TODO: use @memcpy when it supports slices - // - // Don't use the "multi-object for loop" syntax, in - // order to avoid a syntax error with old Zig compilers. - var i: usize = 0; - while (i < extra_array.len) : (i += 1) { - extra_array[i] = unaligned_extra[i]; - } - - return .{ - .string_bytes = try allocator.dupe(u8, string_bytes), - .extra = extra_array, - }; -} - -pub fn parseEmitBinPath(allocator: Allocator, data: []const u8) !EmitBinPath { - const EbpHdr = Server.Message.EmitBinPath; - const ebp_hdr = @ptrCast(*align(1) const EbpHdr, data); - const path = try allocator.dupe(u8, data[@sizeOf(EbpHdr)..]); - - return .{ - .flags = ebp_hdr.flags, - .path = path, - }; -} - -pub fn sendMessage(file: fs.File, tag: Client.Message.Tag) !void { - const header: Client.Message.Header = .{ - .tag = tag, - .bytes_len = 0, - }; - try file.writeAll(mem.asBytes(&header)); -}