refactor: make room for loading and outputting pre-compiled files

src/main.zig

@@ -1,6 +1,10 @@
 const std = @import("std");
 const ink = @import("ink");
+const Ast = ink.Ast;
+const AstGen = ink.AstGen;
+const Ir = ink.Ir;
 const Story = ink.Story;
+const Compilation = ink.Compilation;
 const fatal = std.process.fatal;
 
 var stdin_buffer: [4096]u8 align(std.heap.page_size_min) = undefined;
@@ -8,6 +12,32 @@ 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 ArgsIterator = struct {
+    args: []const []const u8,
+    index: usize = 0,
+
+    pub fn next(iter: *ArgsIterator) ?[]const u8 {
+        if (iter.index >= iter.args.len) return null;
+        defer iter.index += 1;
+        return iter.args[iter.index];
+    }
+
+    pub fn nextOrFatal(iter: *ArgsIterator) []const u8 {
+        if (iter.index >= iter.args.len) {
+            fatal("expected parameter after {s}", .{iter.args[iter.index - 1]});
+        }
+        defer iter.index += 1;
+        return iter.args[iter.index];
+    }
+};
+
+const FileExtension = enum {
+    /// Ink source file.
+    ink,
+    /// Pre-compiled source file.
+    inkc,
+};
+
 pub fn main() !void {
     const gpa = debug_allocator.allocator();
     defer _ = debug_allocator.deinit();
@@ -31,7 +61,7 @@ fn mainArgs(
     args_list: []const [:0]const u8,
 ) !void {
     var source_path: ?[]const u8 = null;
-    var arg_index: usize = 1;
+    var output_path: ?[]const u8 = null;
     var compile_only: bool = false;
     var dump_ast: bool = false;
     var dump_ir: bool = false;
@@ -40,8 +70,11 @@ fn mainArgs(
     var use_stdin: bool = false;
     var use_color: bool = false;
 
-    while (arg_index < args_list.len) : (arg_index += 1) {
-        const arg = args_list[arg_index];
+    var args_iter: ArgsIterator = .{
+        .args = args_list[1..],
+    };
+
+    while (args_iter.next()) |arg| {
         if (std.mem.startsWith(u8, arg, "-")) {
             if (std.mem.eql(u8, arg, "--stdin")) {
                 use_stdin = true;
@@ -57,6 +90,9 @@ fn mainArgs(
                 dump_trace = true;
             } else if (std.mem.eql(u8, arg, "--use-color")) {
                 use_color = true;
+            } else if (std.mem.eql(u8, arg, "--output")) {
+                const next_arg = args_iter.nextOrFatal();
+                output_path = next_arg;
             } else {
                 fatal("invalid parameter: '{s}'", .{arg});
             }
@@ -82,32 +118,74 @@ fn mainArgs(
         };
     };
 
-    const stdout = std.fs.File.stdout();
-    var stdout_writer = stdout.writer(&stdout_buffer);
-
     const stderr = std.fs.File.stderr();
     var stderr_writer = stderr.writer(&stderr_buffer);
+    const io_w = &stderr_writer.interface;
+    const stack_size = 128;
 
-    var story = Story.fromSourceBytes(gpa, source_bytes, .{
-        .filename = filename,
-        .error_writer = &stderr_writer.interface,
-        .dump_writer = &stdout_writer.interface,
-        .dump_use_color = use_color,
-        .dump_ast = dump_ast,
-        .dump_ir = dump_ir,
-    }) catch |err| switch (err) {
-        //error.LoadFailed => std.process.exit(1),
-        else => |e| return e,
+    const file_ext: FileExtension = f: {
+        const bytes = std.fs.path.extension(filename);
+        if (std.mem.eql(u8, bytes, ".ink")) break :f .ink;
+        if (std.mem.eql(u8, bytes, ".inkc")) break :f .inkc;
+        return error.InvalidFileExtension;
     };
-    defer story.deinit();
+    switch (file_ext) {
+        .ink => {
+            var tree = try Ast.parse(gpa, arena, source_bytes, filename, 0);
+            defer tree.deinit(gpa);
 
-    if (dump_trace) {
-        story.dump_writer = &stderr_writer.interface;
+            var ir = try AstGen.generate(gpa, &tree);
+            defer ir.deinit(gpa);
+
+            var errors: std.ArrayListUnmanaged(Compilation.Error) = .empty;
+            defer errors.deinit(gpa);
+
+            if (dump_ast) {
+                try io_w.writeAll("=== AST ===\n");
+                try tree.render(gpa, io_w, .{
+                    .use_color = use_color,
+                });
+                try io_w.flush();
+            }
+            if (dump_ir) {
+                try io_w.writeAll("=== IR ===\n");
+                try ir.render(io_w);
+                try io_w.flush();
+            }
+
+            var cu = Compilation.build(gpa, tree, ir, &errors) catch |err| switch (err) {
+                else => |e| return e,
+            };
+            defer cu.deinit();
+
+            if (cu.hasCompileErrors()) {
+                for (cu.errors.items) |err| {
+                    try cu.renderError(io_w, err);
+                }
+            } else if (output_path) |_| {
+                return error.NotImplemented;
+            } else {
+                var story: Story = try .fromCompilation(gpa, &cu, .{
+                    .stack_size = stack_size,
+                });
+                defer story.deinit();
+                if (dump_story) {
+                    try story.dump(io_w);
+                }
+                if (dump_trace) {
+                    story.dump_writer = io_w;
+                }
+                return if (!compile_only) run(gpa, &story);
+            }
+        },
+        .inkc => {
+            var story: Story = try .fromCachedCompilation(gpa, source_bytes, .{
+                .stack_size = stack_size,
+            });
+            defer story.deinit();
+            return if (!compile_only) run(gpa, &story);
+        },
     }
-    if (dump_story) {
-        try story.dump(&stdout_writer.interface);
-    }
-    return if (!compile_only) run(gpa, &story);
 }
 
 fn run(_: std.mem.Allocator, story: *Story) !void {