feat: loading stories from source files

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 = "<STDIN>",
+        .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,
+    });
+}

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,

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);
-}

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;