authorgravatar for squeek502@hotmail.comRyan Liptak <squeek502@hotmail.com> 2025-08-06 01:11:00-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-08-07 10:04:52-07:00
log858716aa4d569d280e9e31c91fe804eb2a29ef5d
treeb50d1024075df83edde7bae5a215a11848ad3cf3
parent5a743be6b4ca83d2aab5b69ebbb2e2fd777284bd

resinator: a few more updates/fixes

Just enough to get things working correctly again

4 files changed, 32 insertions(+), 37 deletions(-)

lib/compiler/resinator/cli.zig+7-5
......@@ -1141,6 +1141,8 @@ pub fn parse(allocator: Allocator, args: []const []const u8, diagnostics: *Diagn
11411141 }
11421142 output_format = .res;
11431143 }
1144 } else {
1145 output_format_source = .output_format_arg;
11441146 }
11451147 options.output_source = .{ .filename = try filepathWithExtension(allocator, options.input_source.filename, output_format.?.extension()) };
11461148 } else {
......@@ -1529,21 +1531,21 @@ fn testParseOutput(args: []const []const u8, expected_output: []const u8) !?Opti
15291531 var diagnostics = Diagnostics.init(std.testing.allocator);
15301532 defer diagnostics.deinit();
15311533
1532 var output = std.ArrayList(u8).init(std.testing.allocator);
1534 var output: std.io.Writer.Allocating = .init(std.testing.allocator);
15331535 defer output.deinit();
15341536
15351537 var options = parse(std.testing.allocator, args, &diagnostics) catch |err| switch (err) {
15361538 error.ParseError => {
1537 try diagnostics.renderToWriter(args, output.writer(), .no_color);
1538 try std.testing.expectEqualStrings(expected_output, output.items);
1539 try diagnostics.renderToWriter(args, &output.writer, .no_color);
1540 try std.testing.expectEqualStrings(expected_output, output.getWritten());
15391541 return null;
15401542 },
15411543 else => |e| return e,
15421544 };
15431545 errdefer options.deinit();
15441546
1545 try diagnostics.renderToWriter(args, output.writer(), .no_color);
1546 try std.testing.expectEqualStrings(expected_output, output.items);
1547 try diagnostics.renderToWriter(args, &output.writer, .no_color);
1548 try std.testing.expectEqualStrings(expected_output, output.getWritten());
15471549 return options;
15481550}
15491551
lib/compiler/resinator/cvtres.zig+20-27
......@@ -65,7 +65,7 @@ pub const ParseResOptions = struct {
6565};
6666
6767/// The returned ParsedResources should be freed by calling its `deinit` function.
68pub fn parseRes(allocator: Allocator, reader: anytype, options: ParseResOptions) !ParsedResources {
68pub fn parseRes(allocator: Allocator, reader: *std.Io.Reader, options: ParseResOptions) !ParsedResources {
6969 var resources = ParsedResources.init(allocator);
7070 errdefer resources.deinit();
7171
......@@ -74,7 +74,7 @@ pub fn parseRes(allocator: Allocator, reader: anytype, options: ParseResOptions)
7474 return resources;
7575}
7676
77pub fn parseResInto(resources: *ParsedResources, reader: anytype, options: ParseResOptions) !void {
77pub fn parseResInto(resources: *ParsedResources, reader: *std.Io.Reader, options: ParseResOptions) !void {
7878 const allocator = resources.allocator;
7979 var bytes_remaining: u64 = options.max_size;
8080 {
......@@ -103,45 +103,38 @@ pub const ResourceAndSize = struct {
103103 total_size: u64,
104104};
105105
106pub fn parseResource(allocator: Allocator, reader: anytype, max_size: u64) !ResourceAndSize {
107 var header_counting_reader = std.io.countingReader(reader);
108 var buffer: [1024]u8 = undefined;
109 var header_reader_adapter = header_counting_reader.reader().adaptToNewApi(&buffer);
110 const header_reader = &header_reader_adapter.new_interface;
111 const data_size = try header_reader.takeInt(u32, .little);
112 const header_size = try header_reader.takeInt(u32, .little);
106pub fn parseResource(allocator: Allocator, reader: *std.Io.Reader, max_size: u64) !ResourceAndSize {
107 const data_size = try reader.takeInt(u32, .little);
108 const header_size = try reader.takeInt(u32, .little);
113109 const total_size: u64 = @as(u64, header_size) + data_size;
114110 if (total_size > max_size) return error.ImpossibleSize;
115111
116 var header_bytes_available = header_size -| 8;
117 var type_reader: std.Io.Reader = .fixed(try header_reader.take(header_bytes_available));
118 const type_value = try parseNameOrOrdinal(allocator, &type_reader);
112 const remaining_header_bytes = try reader.take(header_size -| 8);
113 var remaining_header_reader: std.Io.Reader = .fixed(remaining_header_bytes);
114 const type_value = try parseNameOrOrdinal(allocator, &remaining_header_reader);
119115 errdefer type_value.deinit(allocator);
120116
121 header_bytes_available -|= @intCast(type_value.byteLen());
122 var name_reader: std.Io.Reader = .fixed(try header_reader.take(header_bytes_available));
123 const name_value = try parseNameOrOrdinal(allocator, &name_reader);
117 const name_value = try parseNameOrOrdinal(allocator, &remaining_header_reader);
124118 errdefer name_value.deinit(allocator);
125119
126 const padding_after_name = numPaddingBytesNeeded(@intCast(header_counting_reader.bytes_read));
127 try header_reader.discardAll(padding_after_name);
120 const padding_after_name = numPaddingBytesNeeded(@intCast(remaining_header_reader.seek));
121 try remaining_header_reader.discardAll(padding_after_name);
128122
129 std.debug.assert(header_counting_reader.bytes_read % 4 == 0);
130 const data_version = try header_reader.takeInt(u32, .little);
131 const memory_flags: MemoryFlags = @bitCast(try header_reader.takeInt(u16, .little));
132 const language: Language = @bitCast(try header_reader.takeInt(u16, .little));
133 const version = try header_reader.takeInt(u32, .little);
134 const characteristics = try header_reader.takeInt(u32, .little);
123 std.debug.assert(remaining_header_reader.seek % 4 == 0);
124 const data_version = try remaining_header_reader.takeInt(u32, .little);
125 const memory_flags: MemoryFlags = @bitCast(try remaining_header_reader.takeInt(u16, .little));
126 const language: Language = @bitCast(try remaining_header_reader.takeInt(u16, .little));
127 const version = try remaining_header_reader.takeInt(u32, .little);
128 const characteristics = try remaining_header_reader.takeInt(u32, .little);
135129
136 const header_bytes_read = header_counting_reader.bytes_read;
137 if (header_size != header_bytes_read) return error.HeaderSizeMismatch;
130 if (remaining_header_reader.seek != remaining_header_reader.end) return error.HeaderSizeMismatch;
138131
139132 const data = try allocator.alloc(u8, data_size);
140133 errdefer allocator.free(data);
141 try reader.readNoEof(data);
134 try reader.readSliceAll(data);
142135
143136 const padding_after_data = numPaddingBytesNeeded(@intCast(data_size));
144 try reader.skipBytes(padding_after_data, .{ .buf_size = 3 });
137 try reader.discardAll(padding_after_data);
145138
146139 return .{
147140 .resource = .{
lib/compiler/resinator/ico.zig+3-3
......@@ -14,12 +14,12 @@ pub fn read(allocator: std.mem.Allocator, reader: anytype, max_size: u64) ReadEr
1414 // Some Reader implementations have an empty ReadError error set which would
1515 // cause 'unreachable else' if we tried to use an else in the switch, so we
1616 // need to detect this case and not try to translate to ReadError
17 const anyerror_reader_errorset = @TypeOf(reader).Error == anyerror;
1718 const empty_reader_errorset = @typeInfo(@TypeOf(reader).Error).error_set == null or @typeInfo(@TypeOf(reader).Error).error_set.?.len == 0;
18 if (empty_reader_errorset) {
19 if (empty_reader_errorset and !anyerror_reader_errorset) {
1920 return readAnyError(allocator, reader, max_size) catch |err| switch (err) {
2021 error.EndOfStream => error.UnexpectedEOF,
21 error.OutOfMemory, error.InvalidHeader, error.InvalidImageType, error.ImpossibleDataSize, error.UnexpectedEOF, error.ReadError => |e| return e,
22 else => return error.ReadError,
22 else => |e| return e,
2323 };
2424 } else {
2525 return readAnyError(allocator, reader, max_size) catch |err| switch (err) {
lib/compiler/resinator/main.zig+2-2
......@@ -325,8 +325,8 @@ pub fn main() !void {
325325 std.debug.assert(options.output_format == .coff);
326326
327327 // TODO: Maybe use a buffered file reader instead of reading file into memory -> fbs
328 var fbs = std.io.fixedBufferStream(res_data.bytes);
329 break :resources cvtres.parseRes(allocator, fbs.reader(), .{ .max_size = res_data.bytes.len }) catch |err| {
328 var res_reader: std.Io.Reader = .fixed(res_data.bytes);
329 break :resources cvtres.parseRes(allocator, &res_reader, .{ .max_size = res_data.bytes.len }) catch |err| {
330330 // TODO: Better errors
331331 try error_handler.emitMessage(allocator, .err, "unable to parse res from '{s}': {s}", .{ res_stream.name, @errorName(err) });
332332 std.process.exit(1);