Commit 5a743be6b4
Changed files (4)
lib
compiler
lib/compiler/resinator/compile.zig
@@ -550,7 +550,7 @@ pub const Compiler = struct {
// so get it here to simplify future usage.
const filename_token = node.filename.getFirstToken();
- const file = self.searchForFile(filename_utf8) catch |err| switch (err) {
+ const file_handle = self.searchForFile(filename_utf8) catch |err| switch (err) {
error.OutOfMemory => |e| return e,
else => |e| {
const filename_string_index = try self.diagnostics.putString(filename_utf8);
@@ -564,13 +564,15 @@ pub const Compiler = struct {
});
},
};
- defer file.close();
+ defer file_handle.close();
+ var file_buffer: [2048]u8 = undefined;
+ var file_reader = file_handle.reader(&file_buffer);
if (maybe_predefined_type) |predefined_type| {
switch (predefined_type) {
.GROUP_ICON, .GROUP_CURSOR => {
// Check for animated icon first
- if (ani.isAnimatedIcon(file.deprecatedReader())) {
+ if (ani.isAnimatedIcon(file_reader.interface.adaptToOldInterface())) {
// Animated icons are just put into the resource unmodified,
// and the resource type changes to ANIICON/ANICURSOR
@@ -582,18 +584,18 @@ pub const Compiler = struct {
header.type_value.ordinal = @intFromEnum(new_predefined_type);
header.memory_flags = MemoryFlags.defaults(new_predefined_type);
header.applyMemoryFlags(node.common_resource_attributes, self.source);
- header.data_size = @intCast(try file.getEndPos());
+ header.data_size = @intCast(try file_reader.getSize());
try header.write(writer, self.errContext(node.id));
- try file.seekTo(0);
- try writeResourceData(writer, file.deprecatedReader(), header.data_size);
+ try file_reader.seekTo(0);
+ try writeResourceData(writer, &file_reader.interface, header.data_size);
return;
}
// isAnimatedIcon moved the file cursor so reset to the start
- try file.seekTo(0);
+ try file_reader.seekTo(0);
- const icon_dir = ico.read(self.allocator, file.deprecatedReader(), try file.getEndPos()) catch |err| switch (err) {
+ const icon_dir = ico.read(self.allocator, file_reader.interface.adaptToOldInterface(), try file_reader.getSize()) catch |err| switch (err) {
error.OutOfMemory => |e| return e,
else => |e| {
return self.iconReadError(
@@ -671,15 +673,15 @@ pub const Compiler = struct {
try writer.writeInt(u16, entry.type_specific_data.cursor.hotspot_y, .little);
}
- try file.seekTo(entry.data_offset_from_start_of_file);
- var header_bytes = file.deprecatedReader().readBytesNoEof(16) catch {
+ try file_reader.seekTo(entry.data_offset_from_start_of_file);
+ var header_bytes = (file_reader.interface.takeArray(16) catch {
return self.iconReadError(
error.UnexpectedEOF,
filename_utf8,
filename_token,
predefined_type,
);
- };
+ }).*;
const image_format = ico.ImageFormat.detect(&header_bytes);
if (!image_format.validate(&header_bytes)) {
@@ -802,8 +804,8 @@ pub const Compiler = struct {
},
}
- try file.seekTo(entry.data_offset_from_start_of_file);
- try writeResourceDataNoPadding(writer, file.deprecatedReader(), entry.data_size_in_bytes);
+ try file_reader.seekTo(entry.data_offset_from_start_of_file);
+ try writeResourceDataNoPadding(writer, &file_reader.interface, entry.data_size_in_bytes);
try writeDataPadding(writer, full_data_size);
if (self.state.icon_id == std.math.maxInt(u16)) {
@@ -857,9 +859,9 @@ pub const Compiler = struct {
},
.BITMAP => {
header.applyMemoryFlags(node.common_resource_attributes, self.source);
- const file_size = try file.getEndPos();
+ const file_size = try file_reader.getSize();
- const bitmap_info = bmp.read(file.deprecatedReader(), file_size) catch |err| {
+ const bitmap_info = bmp.read(file_reader.interface.adaptToOldInterface(), file_size) catch |err| {
const filename_string_index = try self.diagnostics.putString(filename_utf8);
return self.addErrorDetailsAndFail(.{
.err = .bmp_read_error,
@@ -921,18 +923,17 @@ pub const Compiler = struct {
header.data_size = bmp_bytes_to_write;
try header.write(writer, self.errContext(node.id));
- try file.seekTo(bmp.file_header_len);
- const file_reader = file.deprecatedReader();
- try writeResourceDataNoPadding(writer, file_reader, bitmap_info.dib_header_size);
+ try file_reader.seekTo(bmp.file_header_len);
+ try writeResourceDataNoPadding(writer, &file_reader.interface, bitmap_info.dib_header_size);
if (bitmap_info.getBitmasksByteLen() > 0) {
- try writeResourceDataNoPadding(writer, file_reader, bitmap_info.getBitmasksByteLen());
+ try writeResourceDataNoPadding(writer, &file_reader.interface, bitmap_info.getBitmasksByteLen());
}
if (bitmap_info.getExpectedPaletteByteLen() > 0) {
- try writeResourceDataNoPadding(writer, file_reader, @intCast(bitmap_info.getActualPaletteByteLen()));
+ try writeResourceDataNoPadding(writer, &file_reader.interface, @intCast(bitmap_info.getActualPaletteByteLen()));
}
- try file.seekTo(bitmap_info.pixel_data_offset);
+ try file_reader.seekTo(bitmap_info.pixel_data_offset);
const pixel_bytes: u32 = @intCast(file_size - bitmap_info.pixel_data_offset);
- try writeResourceDataNoPadding(writer, file_reader, pixel_bytes);
+ try writeResourceDataNoPadding(writer, &file_reader.interface, pixel_bytes);
try writeDataPadding(writer, bmp_bytes_to_write);
return;
},
@@ -956,7 +957,7 @@ pub const Compiler = struct {
return;
}
header.applyMemoryFlags(node.common_resource_attributes, self.source);
- const file_size = try file.getEndPos();
+ const file_size = try file_reader.getSize();
if (file_size > std.math.maxInt(u32)) {
return self.addErrorDetailsAndFail(.{
.err = .resource_data_size_exceeds_max,
@@ -968,8 +969,9 @@ pub const Compiler = struct {
header.data_size = @intCast(file_size);
try header.write(writer, self.errContext(node.id));
- var header_slurping_reader = headerSlurpingReader(148, file.deprecatedReader());
- try writeResourceData(writer, header_slurping_reader.reader(), header.data_size);
+ var header_slurping_reader = headerSlurpingReader(148, file_reader.interface.adaptToOldInterface());
+ var adapter = header_slurping_reader.reader().adaptToNewApi(&.{});
+ try writeResourceData(writer, &adapter.new_interface, header.data_size);
try self.state.font_dir.add(self.arena, FontDir.Font{
.id = header.name_value.ordinal,
@@ -992,7 +994,7 @@ pub const Compiler = struct {
}
// Fallback to just writing out the entire contents of the file
- const data_size = try file.getEndPos();
+ const data_size = try file_reader.getSize();
if (data_size > std.math.maxInt(u32)) {
return self.addErrorDetailsAndFail(.{
.err = .resource_data_size_exceeds_max,
@@ -1002,7 +1004,7 @@ pub const Compiler = struct {
// We now know that the data size will fit in a u32
header.data_size = @intCast(data_size);
try header.write(writer, self.errContext(node.id));
- try writeResourceData(writer, file.deprecatedReader(), header.data_size);
+ try writeResourceData(writer, &file_reader.interface, header.data_size);
}
fn iconReadError(
@@ -1250,8 +1252,8 @@ pub const Compiler = struct {
const data_len: u32 = @intCast(data_buffer.items.len);
try self.writeResourceHeader(writer, node.id, node.type, data_len, node.common_resource_attributes, self.state.language);
- var data_fbs = std.io.fixedBufferStream(data_buffer.items);
- try writeResourceData(writer, data_fbs.reader(), data_len);
+ var data_fbs: std.Io.Reader = .fixed(data_buffer.items);
+ try writeResourceData(writer, &data_fbs, data_len);
}
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 {
try header.write(writer, self.errContext(id_token));
}
- pub fn writeResourceDataNoPadding(writer: anytype, data_reader: anytype, data_size: u32) !void {
- var limited_reader = std.io.limitedReader(data_reader, data_size);
-
- const FifoBuffer = std.fifo.LinearFifo(u8, .{ .Static = 4096 });
- var fifo = FifoBuffer.init();
- try fifo.pump(limited_reader.reader(), writer);
+ pub fn writeResourceDataNoPadding(writer: anytype, data_reader: *std.Io.Reader, data_size: u32) !void {
+ var adapted = writer.adaptToNewApi();
+ var buffer: [128]u8 = undefined;
+ adapted.new_interface.buffer = &buffer;
+ try data_reader.streamExact(&adapted.new_interface, data_size);
+ try adapted.new_interface.flush();
}
- pub fn writeResourceData(writer: anytype, data_reader: anytype, data_size: u32) !void {
+ pub fn writeResourceData(writer: anytype, data_reader: *std.Io.Reader, data_size: u32) !void {
try writeResourceDataNoPadding(writer, data_reader, data_size);
try writeDataPadding(writer, data_size);
}
@@ -1339,8 +1341,8 @@ pub const Compiler = struct {
try header.write(writer, self.errContext(node.id));
- var data_fbs = std.io.fixedBufferStream(data_buffer.items);
- try writeResourceData(writer, data_fbs.reader(), data_size);
+ var data_fbs: std.Io.Reader = .fixed(data_buffer.items);
+ try writeResourceData(writer, &data_fbs, data_size);
}
/// Expects `data_writer` to be a LimitedWriter limited to u32, meaning all writes to
@@ -1732,8 +1734,8 @@ pub const Compiler = struct {
try header.write(writer, self.errContext(node.id));
- var data_fbs = std.io.fixedBufferStream(data_buffer.items);
- try writeResourceData(writer, data_fbs.reader(), data_size);
+ var data_fbs: std.Io.Reader = .fixed(data_buffer.items);
+ try writeResourceData(writer, &data_fbs, data_size);
}
fn writeDialogHeaderAndStrings(
@@ -2046,8 +2048,8 @@ pub const Compiler = struct {
try header.write(writer, self.errContext(node.id));
- var data_fbs = std.io.fixedBufferStream(data_buffer.items);
- try writeResourceData(writer, data_fbs.reader(), data_size);
+ var data_fbs: std.Io.Reader = .fixed(data_buffer.items);
+ try writeResourceData(writer, &data_fbs, data_size);
}
/// Weight and italic carry over from previous FONT statements within a single resource,
@@ -2121,8 +2123,8 @@ pub const Compiler = struct {
try header.write(writer, self.errContext(node.id));
- var data_fbs = std.io.fixedBufferStream(data_buffer.items);
- try writeResourceData(writer, data_fbs.reader(), data_size);
+ var data_fbs: std.Io.Reader = .fixed(data_buffer.items);
+ try writeResourceData(writer, &data_fbs, data_size);
}
/// Expects `data_writer` to be a LimitedWriter limited to u32, meaning all writes to
@@ -2386,8 +2388,8 @@ pub const Compiler = struct {
try header.write(writer, self.errContext(node.id));
- var data_fbs = std.io.fixedBufferStream(data_buffer.items);
- try writeResourceData(writer, data_fbs.reader(), data_size);
+ var data_fbs: std.Io.Reader = .fixed(data_buffer.items);
+ try writeResourceData(writer, &data_fbs, data_size);
}
/// Expects writer to be a LimitedWriter limited to u16, meaning all writes to
@@ -3321,8 +3323,8 @@ pub const StringTable = struct {
// we fully control and know are numbers, so they have a fixed size.
try header.writeAssertNoOverflow(writer);
- var data_fbs = std.io.fixedBufferStream(data_buffer.items);
- try Compiler.writeResourceData(writer, data_fbs.reader(), data_size);
+ var data_fbs: std.Io.Reader = .fixed(data_buffer.items);
+ try Compiler.writeResourceData(writer, &data_fbs, data_size);
}
};
lib/compiler/resinator/cvtres.zig
@@ -105,31 +105,33 @@ pub const ResourceAndSize = struct {
pub fn parseResource(allocator: Allocator, reader: anytype, max_size: u64) !ResourceAndSize {
var header_counting_reader = std.io.countingReader(reader);
- const header_reader = header_counting_reader.reader();
- const data_size = try header_reader.readInt(u32, .little);
- const header_size = try header_reader.readInt(u32, .little);
+ var buffer: [1024]u8 = undefined;
+ var header_reader_adapter = header_counting_reader.reader().adaptToNewApi(&buffer);
+ const header_reader = &header_reader_adapter.new_interface;
+ const data_size = try header_reader.takeInt(u32, .little);
+ const header_size = try header_reader.takeInt(u32, .little);
const total_size: u64 = @as(u64, header_size) + data_size;
if (total_size > max_size) return error.ImpossibleSize;
var header_bytes_available = header_size -| 8;
- var type_reader = std.io.limitedReader(header_reader, header_bytes_available);
- const type_value = try parseNameOrOrdinal(allocator, type_reader.reader());
+ var type_reader: std.Io.Reader = .fixed(try header_reader.take(header_bytes_available));
+ const type_value = try parseNameOrOrdinal(allocator, &type_reader);
errdefer type_value.deinit(allocator);
header_bytes_available -|= @intCast(type_value.byteLen());
- var name_reader = std.io.limitedReader(header_reader, header_bytes_available);
- const name_value = try parseNameOrOrdinal(allocator, name_reader.reader());
+ var name_reader: std.Io.Reader = .fixed(try header_reader.take(header_bytes_available));
+ const name_value = try parseNameOrOrdinal(allocator, &name_reader);
errdefer name_value.deinit(allocator);
const padding_after_name = numPaddingBytesNeeded(@intCast(header_counting_reader.bytes_read));
- try header_reader.skipBytes(padding_after_name, .{ .buf_size = 3 });
+ try header_reader.discardAll(padding_after_name);
std.debug.assert(header_counting_reader.bytes_read % 4 == 0);
- const data_version = try header_reader.readInt(u32, .little);
- const memory_flags: MemoryFlags = @bitCast(try header_reader.readInt(u16, .little));
- const language: Language = @bitCast(try header_reader.readInt(u16, .little));
- const version = try header_reader.readInt(u32, .little);
- const characteristics = try header_reader.readInt(u32, .little);
+ const data_version = try header_reader.takeInt(u32, .little);
+ const memory_flags: MemoryFlags = @bitCast(try header_reader.takeInt(u16, .little));
+ const language: Language = @bitCast(try header_reader.takeInt(u16, .little));
+ const version = try header_reader.takeInt(u32, .little);
+ const characteristics = try header_reader.takeInt(u32, .little);
const header_bytes_read = header_counting_reader.bytes_read;
if (header_size != header_bytes_read) return error.HeaderSizeMismatch;
@@ -156,10 +158,10 @@ pub fn parseResource(allocator: Allocator, reader: anytype, max_size: u64) !Reso
};
}
-pub fn parseNameOrOrdinal(allocator: Allocator, reader: anytype) !NameOrOrdinal {
- const first_code_unit = try reader.readInt(u16, .little);
+pub fn parseNameOrOrdinal(allocator: Allocator, reader: *std.Io.Reader) !NameOrOrdinal {
+ const first_code_unit = try reader.takeInt(u16, .little);
if (first_code_unit == 0xFFFF) {
- const ordinal_value = try reader.readInt(u16, .little);
+ const ordinal_value = try reader.takeInt(u16, .little);
return .{ .ordinal = ordinal_value };
}
var name_buf = try std.ArrayListUnmanaged(u16).initCapacity(allocator, 16);
@@ -167,7 +169,7 @@ pub fn parseNameOrOrdinal(allocator: Allocator, reader: anytype) !NameOrOrdinal
var code_unit = first_code_unit;
while (code_unit != 0) {
try name_buf.append(allocator, std.mem.nativeToLittle(u16, code_unit));
- code_unit = try reader.readInt(u16, .little);
+ code_unit = try reader.takeInt(u16, .little);
}
return .{ .name = try name_buf.toOwnedSliceSentinel(allocator, 0) };
}
lib/compiler/resinator/errors.zig
@@ -1078,7 +1078,7 @@ const CorrespondingLines = struct {
at_eof: bool = false,
span: SourceMappings.CorrespondingSpan,
file: std.fs.File,
- buffered_reader: *std.Io.Reader,
+ buffered_reader: std.fs.File.Reader,
code_page: SupportedCodePage,
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 {
.buffered_reader = undefined,
.code_page = err_details.code_page,
};
- corresponding_lines.buffered_reader = corresponding_lines.file.reader();
+ corresponding_lines.buffered_reader = corresponding_lines.file.reader(&.{});
errdefer corresponding_lines.deinit();
var fbs = std.io.fixedBufferStream(&corresponding_lines.line_buf);
@@ -1107,7 +1107,7 @@ const CorrespondingLines = struct {
try corresponding_lines.writeLineFromStreamVerbatim(
writer,
- corresponding_lines.buffered_reader.reader(),
+ corresponding_lines.buffered_reader.interface.adaptToOldInterface(),
corresponding_span.start_line,
);
@@ -1150,7 +1150,7 @@ const CorrespondingLines = struct {
try self.writeLineFromStreamVerbatim(
writer,
- self.buffered_reader.reader(),
+ self.buffered_reader.interface.adaptToOldInterface(),
self.line_num,
);
lib/compiler/resinator/ico.zig
@@ -18,7 +18,8 @@ pub fn read(allocator: std.mem.Allocator, reader: anytype, max_size: u64) ReadEr
if (empty_reader_errorset) {
return readAnyError(allocator, reader, max_size) catch |err| switch (err) {
error.EndOfStream => error.UnexpectedEOF,
- else => |e| return e,
+ error.OutOfMemory, error.InvalidHeader, error.InvalidImageType, error.ImpossibleDataSize, error.UnexpectedEOF, error.ReadError => |e| return e,
+ else => return error.ReadError,
};
} else {
return readAnyError(allocator, reader, max_size) catch |err| switch (err) {