build: restore compatibility support again

Commit e214c44 (build: update ZiglingStep to the new API) broke again
the compatibility support for old compilers, due to the use of the
multi-object for loop syntax.

Move the Zig IPC support code to src/ipc.zig.

Use the while statement, instead of the for statement.
This commit is contained in:
Manlio Perillo 2023-04-18 12:22:30 +02:00
parent 9ff7f5ee69
commit b39c7e61ef
2 changed files with 74 additions and 32 deletions

View file

@ -1,6 +1,7 @@
const std = @import("std"); const std = @import("std");
const builtin = @import("builtin"); const builtin = @import("builtin");
const compat = @import("src/compat.zig"); const compat = @import("src/compat.zig");
const ipc = @import("src/ipc.zig");
const tests = @import("test/tests.zig"); const tests = @import("test/tests.zig");
const Build = compat.Build; const Build = compat.Build;
@ -878,8 +879,8 @@ const ZiglingStep = struct {
}); });
defer poller.deinit(); defer poller.deinit();
try sendMessage(child.stdin.?, .update); try ipc.sendMessage(child.stdin.?, .update);
try sendMessage(child.stdin.?, .exit); try ipc.sendMessage(child.stdin.?, .exit);
const Header = std.zig.Server.Message.Header; const Header = std.zig.Server.Message.Header;
var result: ?[]const u8 = null; var result: ?[]const u8 = null;
@ -907,21 +908,7 @@ const ZiglingStep = struct {
return error.ZigVersionMismatch; return error.ZigVersionMismatch;
}, },
.error_bundle => { .error_bundle => {
const EbHdr = std.zig.Server.Message.ErrorBundle; const error_bundle = try ipc.parseErrorBundle(allocator, body);
const eb_hdr = @ptrCast(*align(1) const EbHdr, body);
const extra_bytes =
body[@sizeOf(EbHdr)..][0 .. @sizeOf(u32) * eb_hdr.extra_len];
const string_bytes =
body[@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
for (extra_array, unaligned_extra) |*dst, src| dst.* = src;
const error_bundle: std.zig.ErrorBundle = .{
.string_bytes = try allocator.dupe(u8, string_bytes),
.extra = extra_array,
};
// Print the compiler error bundle now. // Print the compiler error bundle now.
// TODO: use the same ttyconf from the builder. // TODO: use the same ttyconf from the builder.
@ -939,13 +926,8 @@ const ZiglingStep = struct {
sub_prog_node.setName(node_name.items); sub_prog_node.setName(node_name.items);
}, },
.emit_bin_path => { .emit_bin_path => {
const EbpHdr = std.zig.Server.Message.EmitBinPath; const emit_bin = try ipc.parseEmitBinPath(allocator, body);
result = emit_bin.path;
// TODO: add cache support?
//const ebp_hdr = @ptrCast(*align(1) const EbpHdr, body);
//s.result_cached = ebp_hdr.flags.cache_hit;
result = try allocator.dupe(u8, body[@sizeOf(EbpHdr)..]);
}, },
else => {}, // ignore other messages else => {}, // ignore other messages
} }
@ -985,14 +967,6 @@ const ZiglingStep = struct {
} }
}; };
fn sendMessage(file: std.fs.File, tag: std.zig.Client.Message.Tag) !void {
const header: std.zig.Client.Message.Header = .{
.tag = tag,
.bytes_len = 0,
};
try file.writeAll(std.mem.asBytes(&header));
}
// Print a message to stderr. // Print a message to stderr.
const PrintStep = struct { const PrintStep = struct {
step: Step, step: Step,

68
src/ipc.zig Normal file
View file

@ -0,0 +1,68 @@
/// 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));
}