Skip to content

Commit 4395f51

Browse files
committed
resinator: just enough fixes to make it compile
1 parent 4d4251c commit 4395f51

File tree

4 files changed

+75
-70
lines changed

4 files changed

+75
-70
lines changed

lib/compiler/resinator/compile.zig

Lines changed: 50 additions & 48 deletions
Original file line numberDiff line numberDiff line change
@@ -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

Lines changed: 19 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -105,31 +105,33 @@ pub const ResourceAndSize = struct {
105105

106106
pub 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,18 +158,18 @@ pub fn parseResource(allocator: Allocator, reader: anytype, max_size: u64) !Reso
156158
};
157159
}
158160

159-
pub fn parseNameOrOrdinal(allocator: Allocator, reader: anytype) !NameOrOrdinal {
160-
const first_code_unit = try reader.readInt(u16, .little);
161+
pub 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);
166168
errdefer name_buf.deinit(allocator);
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

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -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,15 +1099,15 @@ 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);
11061106
const writer = fbs.writer();
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

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -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) {

0 commit comments

Comments
 (0)