From d9f0a044171175fa6bd7c8bf08e89b310fa0bd42 Mon Sep 17 00:00:00 2001 From: Brett Broadhurst Date: Tue, 31 Mar 2026 16:42:02 -0600 Subject: [PATCH] feat: loading stories from source files --- src/Story.zig | 60 ++++++++++++++++++++++++++++++++++++++----------- src/compile.zig | 2 +- src/main.zig | 49 +++++++--------------------------------- src/root.zig | 12 ++++++++++ 4 files changed, 68 insertions(+), 55 deletions(-) diff --git a/src/Story.zig b/src/Story.zig index fa0bcf8..fc10de3 100644 --- a/src/Story.zig +++ b/src/Story.zig @@ -6,6 +6,7 @@ const AstGen = @import("AstGen.zig"); const Module = @import("compile.zig").Module; pub const Object = @import("Story/Object.zig"); const Dumper = @import("Story/Dumper.zig"); +const ink = @import("root.zig"); const assert = std.debug.assert; const Story = @This(); @@ -845,20 +846,20 @@ pub fn selectChoiceIndex(story: *Story, index: usize) !void { _ = story.arena.reset(.retain_capacity); } -pub const LoadOptions = struct { - dump_writer: ?*std.Io.Writer = null, - error_writer: *std.Io.Writer, - use_color: bool = true, - dump_ast: bool = false, - dump_ir: bool = false, - dump_trace: bool = false, -}; - pub fn dump(story: *Story, writer: *std.Io.Writer) !void { return Dumper.dump(story, writer); } -pub fn loadFromString( +pub const LoadOptions = struct { + filename: []const u8, + error_writer: *std.Io.Writer, + dump_writer: ?*std.Io.Writer = null, + dump_use_color: bool = true, + dump_ast: bool = false, + dump_ir: bool = false, +}; + +pub fn fromSourceBytes( gpa: std.mem.Allocator, source_bytes: [:0]const u8, options: LoadOptions, @@ -870,9 +871,9 @@ pub fn loadFromString( var comp = try Module.compile(gpa, arena, .{ .source_bytes = source_bytes, - .filename = "", + .filename = options.filename, .dump_writer = options.dump_writer, - .dump_use_color = options.use_color, + .dump_use_color = options.dump_use_color, .dump_ast = options.dump_ast, .dump_ir = options.dump_ir, }); @@ -897,7 +898,7 @@ pub fn loadFromString( .gpa = gpa, .arena = .init(gpa), .can_advance = false, - .dump_writer = if (options.dump_trace) options.dump_writer else null, + .dump_writer = null, .stack = eval_stack_ptr, .call_stack = call_stack_ptr, }; @@ -909,3 +910,36 @@ pub fn loadFromString( } return story; } + +var read_buffer: [4096]u8 align(std.heap.page_size_min) = undefined; + +pub const LoadFileOptions = struct { + error_writer: *std.Io.Writer, +}; + +pub fn readSourceFile( + gpa: std.mem.Allocator, + filename: []const u8, + options: LoadFileOptions, +) !Story { + // FIXME: Temporary until 0.16.x + var arena_allocator = std.heap.ArenaAllocator.init(gpa); + defer arena_allocator.deinit(); + + const arena = arena_allocator.allocator(); + const source_bytes: [:0]const u8 = s: { + var f = try std.fs.cwd().openFile(filename, .{}); + defer f.close(); + + var file_reader: std.fs.File.Reader = f.reader(&read_buffer); + break :s try ink.readSourceFileToEndAlloc(arena, &file_reader); + }; + return Story.fromSourceBytes(gpa, source_bytes, .{ + .filename = filename, + .error_writer = options.error_writer, + .dump_writer = null, + .dump_use_color = false, + .dump_ast = false, + .dump_ir = false, + }); +} diff --git a/src/compile.zig b/src/compile.zig index f657f63..83cbfa1 100644 --- a/src/compile.zig +++ b/src/compile.zig @@ -332,7 +332,7 @@ pub const Module = struct { pub const Options = struct { source_bytes: [:0]const u8, - filename: [:0]const u8, + filename: []const u8, dump_writer: ?*std.Io.Writer = null, dump_ast: bool = false, dump_ir: bool = false, diff --git a/src/main.zig b/src/main.zig index 27cb5ca..01d0d7d 100644 --- a/src/main.zig +++ b/src/main.zig @@ -7,7 +7,6 @@ var stdin_buffer: [4096]u8 align(std.heap.page_size_min) = undefined; var stdout_buffer: [4096]u8 align(std.heap.page_size_min) = undefined; var stderr_buffer: [4096]u8 align(std.heap.page_size_min) = undefined; var debug_allocator: std.heap.DebugAllocator(.{}) = .init; -const max_src_size = std.math.maxInt(u32); pub fn main() !void { const gpa = debug_allocator.allocator(); @@ -78,7 +77,7 @@ fn mainArgs( defer if (source_path != null) f.close(); var file_reader: std.fs.File.Reader = f.reader(&stdin_buffer); - break :s readSourceFile(arena, &file_reader) catch |err| { + break :s ink.readSourceFileToEndAlloc(arena, &file_reader) catch |err| { fatal("unable to load file '{s}': {s}", .{ filename, @errorName(err) }); }; }; @@ -89,21 +88,24 @@ fn mainArgs( const stderr = std.fs.File.stderr(); var stderr_writer = stderr.writer(&stderr_buffer); - var story = Story.loadFromString(gpa, source_bytes, .{ + var story = Story.fromSourceBytes(gpa, source_bytes, .{ + .filename = filename, .error_writer = &stderr_writer.interface, .dump_writer = &stdout_writer.interface, - .use_color = use_color, + .dump_use_color = use_color, .dump_ast = dump_ast, .dump_ir = dump_ir, - .dump_trace = dump_trace, }) catch |err| switch (err) { //error.LoadFailed => std.process.exit(1), else => |e| return e, }; defer story.deinit(); + if (dump_trace) { + story.dump_writer = &stderr_writer.interface; + } if (dump_story) { - try story.dump(&stderr_writer.interface); + try story.dump(&stdout_writer.interface); } return if (!compile_only) run(gpa, &story); } @@ -135,38 +137,3 @@ fn run(_: std.mem.Allocator, story: *Story) !void { } } } - -fn readSourceFile(gpa: std.mem.Allocator, file_reader: *std.fs.File.Reader) ![:0]u8 { - var buffer: std.ArrayListUnmanaged(u8) = .empty; - defer buffer.deinit(gpa); - - if (file_reader.getSize()) |size| { - const casted_size = std.math.cast(u32, size) orelse return error.StreamTooLong; - try buffer.ensureTotalCapacityPrecise(gpa, casted_size + 1); - } else |_| {} - - try file_reader.interface.appendRemaining(gpa, &buffer, .limited(max_src_size)); - - const unsupported_boms = [_][]const u8{ - "\xff\xfe\x00\x00", // UTF-32 little endian - "\xfe\xff\x00\x00", // UTF-32 big endian - "\xfe\xff", // UTF-16 big endian - }; - for (unsupported_boms) |bom| { - if (std.mem.startsWith(u8, buffer.items, bom)) { - return error.UnsupportedEncoding; - } - } - if (std.mem.startsWith(u8, buffer.items, "\xff\xfe")) { - if (buffer.items.len % 2 != 0) { - return error.InvalidEncoding; - } - return std.unicode.utf16LeToUtf8AllocZ(gpa, @ptrCast(@alignCast(buffer.items))) catch |err| switch (err) { - error.DanglingSurrogateHalf => error.UnsupportedEncoding, - error.ExpectedSecondSurrogateHalf => error.UnsupportedEncoding, - error.UnexpectedSecondSurrogateHalf => error.UnsupportedEncoding, - else => |e| return e, - }; - } - return buffer.toOwnedSliceSentinel(gpa, 0); -} diff --git a/src/root.zig b/src/root.zig index c70b41c..0090fac 100644 --- a/src/root.zig +++ b/src/root.zig @@ -1,7 +1,19 @@ +const std = @import("std"); const tokenizer = @import("tokenizer.zig"); pub const Story = @import("Story.zig"); pub const Ast = @import("Ast.zig"); +pub const max_src_size = std.math.maxInt(u32); + +// std.zig.readSourceFileToEndAlloc leaks in 0.15.2. +// Use an arena allocator for now. +pub fn readSourceFileToEndAlloc( + gpa: std.mem.Allocator, + file_reader: *std.fs.File.Reader, +) ![:0]u8 { + return std.zig.readSourceFileToEndAlloc(gpa, file_reader); +} + test { _ = tokenizer; _ = Ast;