authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-08-04 22:26:21-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-08-06 22:42:42-07:00
log4395f512c932826360ed9efa1564f4f22693394b
treef15565a27e586c7a34e4f9fb6b68b65714149fd3
parent4d4251c9f95254fe94858a4c2319cbb59d2261d0

resinator: just enough fixes to make it compile

4 files changed, 75 insertions(+), 70 deletions(-)

lib/compiler/resinator/compile.zig+50-48
......@@ -550,7 +550,7 @@ pub const Compiler = struct {
550550 // so get it here to simplify future usage.
551551 const filename_token = node.filename.getFirstToken();
552552
553 const file = self.searchForFile(filename_utf8) catch |err| switch (err) {
553 const file_handle = self.searchForFile(filename_utf8) catch |err| switch (err) {
554554 error.OutOfMemory => |e| return e,
555555 else => |e| {
556556 const filename_string_index = try self.diagnostics.putString(filename_utf8);
......@@ -564,13 +564,15 @@ pub const Compiler = struct {
564564 });
565565 },
566566 };
567 defer file.close();
567 defer file_handle.close();
568 var file_buffer: [2048]u8 = undefined;
569 var file_reader = file_handle.reader(&file_buffer);
568570
569571 if (maybe_predefined_type) |predefined_type| {
570572 switch (predefined_type) {
571573 .GROUP_ICON, .GROUP_CURSOR => {
572574 // Check for animated icon first
573 if (ani.isAnimatedIcon(file.deprecatedReader())) {
575 if (ani.isAnimatedIcon(file_reader.interface.adaptToOldInterface())) {
574576 // Animated icons are just put into the resource unmodified,
575577 // and the resource type changes to ANIICON/ANICURSOR
576578
......@@ -582,18 +584,18 @@ pub const Compiler = struct {
582584 header.type_value.ordinal = @intFromEnum(new_predefined_type);
583585 header.memory_flags = MemoryFlags.defaults(new_predefined_type);
584586 header.applyMemoryFlags(node.common_resource_attributes, self.source);
585 header.data_size = @intCast(try file.getEndPos());
587 header.data_size = @intCast(try file_reader.getSize());
586588
587589 try header.write(writer, self.errContext(node.id));
588 try file.seekTo(0);
589 try writeResourceData(writer, file.deprecatedReader(), header.data_size);
590 try file_reader.seekTo(0);
591 try writeResourceData(writer, &file_reader.interface, header.data_size);
590592 return;
591593 }
592594
593595 // isAnimatedIcon moved the file cursor so reset to the start
594 try file.seekTo(0);
596 try file_reader.seekTo(0);
595597
596 const icon_dir = ico.read(self.allocator, file.deprecatedReader(), try file.getEndPos()) catch |err| switch (err) {
598 const icon_dir = ico.read(self.allocator, file_reader.interface.adaptToOldInterface(), try file_reader.getSize()) catch |err| switch (err) {
597599 error.OutOfMemory => |e| return e,
598600 else => |e| {
599601 return self.iconReadError(
......@@ -671,15 +673,15 @@ pub const Compiler = struct {
671673 try writer.writeInt(u16, entry.type_specific_data.cursor.hotspot_y, .little);
672674 }
673675
674 try file.seekTo(entry.data_offset_from_start_of_file);
675 var header_bytes = file.deprecatedReader().readBytesNoEof(16) catch {
676 try file_reader.seekTo(entry.data_offset_from_start_of_file);
677 var header_bytes = (file_reader.interface.takeArray(16) catch {
676678 return self.iconReadError(
677679 error.UnexpectedEOF,
678680 filename_utf8,
679681 filename_token,
680682 predefined_type,
681683 );
682 };
684 }).*;
683685
684686 const image_format = ico.ImageFormat.detect(&header_bytes);
685687 if (!image_format.validate(&header_bytes)) {
......@@ -802,8 +804,8 @@ pub const Compiler = struct {
802804 },
803805 }
804806
805 try file.seekTo(entry.data_offset_from_start_of_file);
806 try writeResourceDataNoPadding(writer, file.deprecatedReader(), entry.data_size_in_bytes);
807 try file_reader.seekTo(entry.data_offset_from_start_of_file);
808 try writeResourceDataNoPadding(writer, &file_reader.interface, entry.data_size_in_bytes);
807809 try writeDataPadding(writer, full_data_size);
808810
809811 if (self.state.icon_id == std.math.maxInt(u16)) {
......@@ -857,9 +859,9 @@ pub const Compiler = struct {
857859 },
858860 .BITMAP => {
859861 header.applyMemoryFlags(node.common_resource_attributes, self.source);
860 const file_size = try file.getEndPos();
862 const file_size = try file_reader.getSize();
861863
862 const bitmap_info = bmp.read(file.deprecatedReader(), file_size) catch |err| {
864 const bitmap_info = bmp.read(file_reader.interface.adaptToOldInterface(), file_size) catch |err| {
863865 const filename_string_index = try self.diagnostics.putString(filename_utf8);
864866 return self.addErrorDetailsAndFail(.{
865867 .err = .bmp_read_error,
......@@ -921,18 +923,17 @@ pub const Compiler = struct {
921923
922924 header.data_size = bmp_bytes_to_write;
923925 try header.write(writer, self.errContext(node.id));
924 try file.seekTo(bmp.file_header_len);
925 const file_reader = file.deprecatedReader();
926 try writeResourceDataNoPadding(writer, file_reader, bitmap_info.dib_header_size);
926 try file_reader.seekTo(bmp.file_header_len);
927 try writeResourceDataNoPadding(writer, &file_reader.interface, bitmap_info.dib_header_size);
927928 if (bitmap_info.getBitmasksByteLen() > 0) {
928 try writeResourceDataNoPadding(writer, file_reader, bitmap_info.getBitmasksByteLen());
929 try writeResourceDataNoPadding(writer, &file_reader.interface, bitmap_info.getBitmasksByteLen());
929930 }
930931 if (bitmap_info.getExpectedPaletteByteLen() > 0) {
931 try writeResourceDataNoPadding(writer, file_reader, @intCast(bitmap_info.getActualPaletteByteLen()));
932 try writeResourceDataNoPadding(writer, &file_reader.interface, @intCast(bitmap_info.getActualPaletteByteLen()));
932933 }
933 try file.seekTo(bitmap_info.pixel_data_offset);
934 try file_reader.seekTo(bitmap_info.pixel_data_offset);
934935 const pixel_bytes: u32 = @intCast(file_size - bitmap_info.pixel_data_offset);
935 try writeResourceDataNoPadding(writer, file_reader, pixel_bytes);
936 try writeResourceDataNoPadding(writer, &file_reader.interface, pixel_bytes);
936937 try writeDataPadding(writer, bmp_bytes_to_write);
937938 return;
938939 },
......@@ -956,7 +957,7 @@ pub const Compiler = struct {
956957 return;
957958 }
958959 header.applyMemoryFlags(node.common_resource_attributes, self.source);
959 const file_size = try file.getEndPos();
960 const file_size = try file_reader.getSize();
960961 if (file_size > std.math.maxInt(u32)) {
961962 return self.addErrorDetailsAndFail(.{
962963 .err = .resource_data_size_exceeds_max,
......@@ -968,8 +969,9 @@ pub const Compiler = struct {
968969 header.data_size = @intCast(file_size);
969970 try header.write(writer, self.errContext(node.id));
970971
971 var header_slurping_reader = headerSlurpingReader(148, file.deprecatedReader());
972 try writeResourceData(writer, header_slurping_reader.reader(), header.data_size);
972 var header_slurping_reader = headerSlurpingReader(148, file_reader.interface.adaptToOldInterface());
973 var adapter = header_slurping_reader.reader().adaptToNewApi(&.{});
974 try writeResourceData(writer, &adapter.new_interface, header.data_size);
973975
974976 try self.state.font_dir.add(self.arena, FontDir.Font{
975977 .id = header.name_value.ordinal,
......@@ -992,7 +994,7 @@ pub const Compiler = struct {
992994 }
993995
994996 // Fallback to just writing out the entire contents of the file
995 const data_size = try file.getEndPos();
997 const data_size = try file_reader.getSize();
996998 if (data_size > std.math.maxInt(u32)) {
997999 return self.addErrorDetailsAndFail(.{
9981000 .err = .resource_data_size_exceeds_max,
......@@ -1002,7 +1004,7 @@ pub const Compiler = struct {
10021004 // We now know that the data size will fit in a u32
10031005 header.data_size = @intCast(data_size);
10041006 try header.write(writer, self.errContext(node.id));
1005 try writeResourceData(writer, file.deprecatedReader(), header.data_size);
1007 try writeResourceData(writer, &file_reader.interface, header.data_size);
10061008 }
10071009
10081010 fn iconReadError(
......@@ -1250,8 +1252,8 @@ pub const Compiler = struct {
12501252 const data_len: u32 = @intCast(data_buffer.items.len);
12511253 try self.writeResourceHeader(writer, node.id, node.type, data_len, node.common_resource_attributes, self.state.language);
12521254
1253 var data_fbs = std.io.fixedBufferStream(data_buffer.items);
1254 try writeResourceData(writer, data_fbs.reader(), data_len);
1255 var data_fbs: std.Io.Reader = .fixed(data_buffer.items);
1256 try writeResourceData(writer, &data_fbs, data_len);
12551257 }
12561258
12571259 pub fn writeResourceHeader(self: *Compiler, writer: anytype, id_token: Token, type_token: Token, data_size: u32, common_resource_attributes: []Token, language: res.Language) !void {
......@@ -1266,15 +1268,15 @@ pub const Compiler = struct {
12661268 try header.write(writer, self.errContext(id_token));
12671269 }
12681270
1269 pub fn writeResourceDataNoPadding(writer: anytype, data_reader: anytype, data_size: u32) !void {
1270 var limited_reader = std.io.limitedReader(data_reader, data_size);
1271
1272 const FifoBuffer = std.fifo.LinearFifo(u8, .{ .Static = 4096 });
1273 var fifo = FifoBuffer.init();
1274 try fifo.pump(limited_reader.reader(), writer);
1271 pub fn writeResourceDataNoPadding(writer: anytype, data_reader: *std.Io.Reader, data_size: u32) !void {
1272 var adapted = writer.adaptToNewApi();
1273 var buffer: [128]u8 = undefined;
1274 adapted.new_interface.buffer = &buffer;
1275 try data_reader.streamExact(&adapted.new_interface, data_size);
1276 try adapted.new_interface.flush();
12751277 }
12761278
1277 pub fn writeResourceData(writer: anytype, data_reader: anytype, data_size: u32) !void {
1279 pub fn writeResourceData(writer: anytype, data_reader: *std.Io.Reader, data_size: u32) !void {
12781280 try writeResourceDataNoPadding(writer, data_reader, data_size);
12791281 try writeDataPadding(writer, data_size);
12801282 }
......@@ -1339,8 +1341,8 @@ pub const Compiler = struct {
13391341
13401342 try header.write(writer, self.errContext(node.id));
13411343
1342 var data_fbs = std.io.fixedBufferStream(data_buffer.items);
1343 try writeResourceData(writer, data_fbs.reader(), data_size);
1344 var data_fbs: std.Io.Reader = .fixed(data_buffer.items);
1345 try writeResourceData(writer, &data_fbs, data_size);
13441346 }
13451347
13461348 /// Expects `data_writer` to be a LimitedWriter limited to u32, meaning all writes to
......@@ -1732,8 +1734,8 @@ pub const Compiler = struct {
17321734
17331735 try header.write(writer, self.errContext(node.id));
17341736
1735 var data_fbs = std.io.fixedBufferStream(data_buffer.items);
1736 try writeResourceData(writer, data_fbs.reader(), data_size);
1737 var data_fbs: std.Io.Reader = .fixed(data_buffer.items);
1738 try writeResourceData(writer, &data_fbs, data_size);
17371739 }
17381740
17391741 fn writeDialogHeaderAndStrings(
......@@ -2046,8 +2048,8 @@ pub const Compiler = struct {
20462048
20472049 try header.write(writer, self.errContext(node.id));
20482050
2049 var data_fbs = std.io.fixedBufferStream(data_buffer.items);
2050 try writeResourceData(writer, data_fbs.reader(), data_size);
2051 var data_fbs: std.Io.Reader = .fixed(data_buffer.items);
2052 try writeResourceData(writer, &data_fbs, data_size);
20512053 }
20522054
20532055 /// Weight and italic carry over from previous FONT statements within a single resource,
......@@ -2121,8 +2123,8 @@ pub const Compiler = struct {
21212123
21222124 try header.write(writer, self.errContext(node.id));
21232125
2124 var data_fbs = std.io.fixedBufferStream(data_buffer.items);
2125 try writeResourceData(writer, data_fbs.reader(), data_size);
2126 var data_fbs: std.Io.Reader = .fixed(data_buffer.items);
2127 try writeResourceData(writer, &data_fbs, data_size);
21262128 }
21272129
21282130 /// Expects `data_writer` to be a LimitedWriter limited to u32, meaning all writes to
......@@ -2386,8 +2388,8 @@ pub const Compiler = struct {
23862388
23872389 try header.write(writer, self.errContext(node.id));
23882390
2389 var data_fbs = std.io.fixedBufferStream(data_buffer.items);
2390 try writeResourceData(writer, data_fbs.reader(), data_size);
2391 var data_fbs: std.Io.Reader = .fixed(data_buffer.items);
2392 try writeResourceData(writer, &data_fbs, data_size);
23912393 }
23922394
23932395 /// Expects writer to be a LimitedWriter limited to u16, meaning all writes to
......@@ -3321,8 +3323,8 @@ pub const StringTable = struct {
33213323 // we fully control and know are numbers, so they have a fixed size.
33223324 try header.writeAssertNoOverflow(writer);
33233325
3324 var data_fbs = std.io.fixedBufferStream(data_buffer.items);
3325 try Compiler.writeResourceData(writer, data_fbs.reader(), data_size);
3326 var data_fbs: std.Io.Reader = .fixed(data_buffer.items);
3327 try Compiler.writeResourceData(writer, &data_fbs, data_size);
33263328 }
33273329 };
33283330
lib/compiler/resinator/cvtres.zig+19-17
......@@ -105,31 +105,33 @@ pub const ResourceAndSize = struct {
105105
106106pub fn parseResource(allocator: Allocator, reader: anytype, max_size: u64) !ResourceAndSize {
107107 var header_counting_reader = std.io.countingReader(reader);
108 const header_reader = header_counting_reader.reader();
109 const data_size = try header_reader.readInt(u32, .little);
110 const header_size = try header_reader.readInt(u32, .little);
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);
111113 const total_size: u64 = @as(u64, header_size) + data_size;
112114 if (total_size > max_size) return error.ImpossibleSize;
113115
114116 var header_bytes_available = header_size -| 8;
115 var type_reader = std.io.limitedReader(header_reader, header_bytes_available);
116 const type_value = try parseNameOrOrdinal(allocator, type_reader.reader());
117 var type_reader: std.Io.Reader = .fixed(try header_reader.take(header_bytes_available));
118 const type_value = try parseNameOrOrdinal(allocator, &type_reader);
117119 errdefer type_value.deinit(allocator);
118120
119121 header_bytes_available -|= @intCast(type_value.byteLen());
120 var name_reader = std.io.limitedReader(header_reader, header_bytes_available);
121 const name_value = try parseNameOrOrdinal(allocator, name_reader.reader());
122 var name_reader: std.Io.Reader = .fixed(try header_reader.take(header_bytes_available));
123 const name_value = try parseNameOrOrdinal(allocator, &name_reader);
122124 errdefer name_value.deinit(allocator);
123125
124126 const padding_after_name = numPaddingBytesNeeded(@intCast(header_counting_reader.bytes_read));
125 try header_reader.skipBytes(padding_after_name, .{ .buf_size = 3 });
127 try header_reader.discardAll(padding_after_name);
126128
127129 std.debug.assert(header_counting_reader.bytes_read % 4 == 0);
128 const data_version = try header_reader.readInt(u32, .little);
129 const memory_flags: MemoryFlags = @bitCast(try header_reader.readInt(u16, .little));
130 const language: Language = @bitCast(try header_reader.readInt(u16, .little));
131 const version = try header_reader.readInt(u32, .little);
132 const characteristics = try header_reader.readInt(u32, .little);
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);
133135
134136 const header_bytes_read = header_counting_reader.bytes_read;
135137 if (header_size != header_bytes_read) return error.HeaderSizeMismatch;
......@@ -156,10 +158,10 @@ pub fn parseResource(allocator: Allocator, reader: anytype, max_size: u64) !Reso
156158 };
157159}
158160
159pub fn parseNameOrOrdinal(allocator: Allocator, reader: anytype) !NameOrOrdinal {
160 const first_code_unit = try reader.readInt(u16, .little);
161pub fn parseNameOrOrdinal(allocator: Allocator, reader: *std.Io.Reader) !NameOrOrdinal {
162 const first_code_unit = try reader.takeInt(u16, .little);
161163 if (first_code_unit == 0xFFFF) {
162 const ordinal_value = try reader.readInt(u16, .little);
164 const ordinal_value = try reader.takeInt(u16, .little);
163165 return .{ .ordinal = ordinal_value };
164166 }
165167 var name_buf = try std.ArrayListUnmanaged(u16).initCapacity(allocator, 16);
......@@ -167,7 +169,7 @@ pub fn parseNameOrOrdinal(allocator: Allocator, reader: anytype) !NameOrOrdinal
167169 var code_unit = first_code_unit;
168170 while (code_unit != 0) {
169171 try name_buf.append(allocator, std.mem.nativeToLittle(u16, code_unit));
170 code_unit = try reader.readInt(u16, .little);
172 code_unit = try reader.takeInt(u16, .little);
171173 }
172174 return .{ .name = try name_buf.toOwnedSliceSentinel(allocator, 0) };
173175}
lib/compiler/resinator/errors.zig+4-4
......@@ -1078,7 +1078,7 @@ const CorrespondingLines = struct {
10781078 at_eof: bool = false,
10791079 span: SourceMappings.CorrespondingSpan,
10801080 file: std.fs.File,
1081 buffered_reader: *std.Io.Reader,
1081 buffered_reader: std.fs.File.Reader,
10821082 code_page: SupportedCodePage,
10831083
10841084 pub fn init(cwd: std.fs.Dir, err_details: ErrorDetails, line_for_comparison: []const u8, corresponding_span: SourceMappings.CorrespondingSpan, corresponding_file: []const u8) !CorrespondingLines {
......@@ -1099,7 +1099,7 @@ const CorrespondingLines = struct {
10991099 .buffered_reader = undefined,
11001100 .code_page = err_details.code_page,
11011101 };
1102 corresponding_lines.buffered_reader = corresponding_lines.file.reader();
1102 corresponding_lines.buffered_reader = corresponding_lines.file.reader(&.{});
11031103 errdefer corresponding_lines.deinit();
11041104
11051105 var fbs = std.io.fixedBufferStream(&corresponding_lines.line_buf);
......@@ -1107,7 +1107,7 @@ const CorrespondingLines = struct {
11071107
11081108 try corresponding_lines.writeLineFromStreamVerbatim(
11091109 writer,
1110 corresponding_lines.buffered_reader.reader(),
1110 corresponding_lines.buffered_reader.interface.adaptToOldInterface(),
11111111 corresponding_span.start_line,
11121112 );
11131113
......@@ -1150,7 +1150,7 @@ const CorrespondingLines = struct {
11501150
11511151 try self.writeLineFromStreamVerbatim(
11521152 writer,
1153 self.buffered_reader.reader(),
1153 self.buffered_reader.interface.adaptToOldInterface(),
11541154 self.line_num,
11551155 );
11561156
lib/compiler/resinator/ico.zig+2-1
......@@ -18,7 +18,8 @@ pub fn read(allocator: std.mem.Allocator, reader: anytype, max_size: u64) ReadEr
1818 if (empty_reader_errorset) {
1919 return readAnyError(allocator, reader, max_size) catch |err| switch (err) {
2020 error.EndOfStream => error.UnexpectedEOF,
21 else => |e| return e,
21 error.OutOfMemory, error.InvalidHeader, error.InvalidImageType, error.ImpossibleDataSize, error.UnexpectedEOF, error.ReadError => |e| return e,
22 else => return error.ReadError,
2223 };
2324 } else {
2425 return readAnyError(allocator, reader, max_size) catch |err| switch (err) {