move arg processing to main

build/TranslateC.zig

@@ -145,14 +145,15 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
 
     const sub_path = b.pathJoin(&.{ "o", &digest, out_name });
     const sub_path_dirname = std.fs.path.dirname(sub_path).?;
+    const out_path = try b.cache_root.join(b.allocator, &.{sub_path});
 
     b.cache_root.handle.makePath(sub_path_dirname) catch |err| {
         return step.fail("unable to make path '{}{s}': {s}", .{
             b.cache_root, sub_path_dirname, @errorName(err),
         });
     };
     try argv_list.append("-o");
-    try argv_list.append(sub_path);
+    try argv_list.append(out_path);
 
     var child = std.process.Child.init(argv_list.items, b.allocator);
     child.cwd = b.build_root.path;
@@ -184,6 +185,6 @@ fn make(step: *Step, options: Step.MakeOptions) !void {
         },
     }
 
-    translate_c.output_file.path = try b.cache_root.join(b.allocator, &.{sub_path});
+    translate_c.output_file.path = out_path;
     try man.writeManifest();
 }

src/Translator.zig

@@ -437,37 +437,8 @@ fn warn(c: *Context, scope: *Scope, loc: TokenIndex, comptime format: []const u8
 pub fn translate(
     gpa: mem.Allocator,
     comp: *aro.Compilation,
-    args: []const []const u8,
+    tree: aro.Tree,
 ) !std.zig.Ast {
-    try comp.addDefaultPragmaHandlers();
-    comp.langopts.setEmulatedCompiler(aro.target_util.systemCompiler(comp.target));
-
-    var driver: aro.Driver = .{ .comp = comp };
-    defer driver.deinit();
-
-    var macro_buf = std.ArrayList(u8).init(gpa);
-    defer macro_buf.deinit();
-
-    assert(!try driver.parseArgs(std.io.null_writer, macro_buf.writer(), args));
-    assert(driver.inputs.items.len == 1);
-    const source = driver.inputs.items[0];
-
-    const builtin_macros = try comp.generateBuiltinMacros(.include_system_defines, null);
-    const user_macros = try comp.addSourceFromBuffer("<command line>", macro_buf.items);
-
-    var pp = try aro.Preprocessor.initDefault(comp);
-    defer pp.deinit();
-
-    try pp.preprocessSources(&.{ source, builtin_macros, user_macros });
-
-    var tree = try pp.parse();
-    defer tree.deinit();
-
-    // Workaround for https://github.com/Vexu/arocc/issues/603
-    for (comp.diagnostics.list.items) |msg| {
-        if (msg.kind == .@"error" or msg.kind == .@"fatal error") return error.ParsingFailed;
-    }
-
     const mapper = tree.comp.string_interner.getFastTypeMapper(tree.comp.gpa) catch tree.comp.string_interner.getSlowTypeMapper();
     defer mapper.deinit(tree.comp.gpa);
 

src/main.zig

@@ -1,7 +1,9 @@
 const std = @import("std");
+const assert = std.debug.assert;
 const aro = @import("aro");
 const Translator = @import("Translator.zig");
 
+// TODO cleanup and handle errors more gracefully
 pub fn main() !void {
     var arena_instance = std.heap.ArenaAllocator.init(std.heap.page_allocator);
     defer arena_instance.deinit();
@@ -12,17 +14,50 @@ pub fn main() !void {
 
     const args = try std.process.argsAlloc(arena);
 
-    var aro_comp = aro.Compilation.init(gpa, std.fs.cwd());
-    defer aro_comp.deinit();
+    var comp = aro.Compilation.init(gpa, std.fs.cwd());
+    defer comp.deinit();
 
-    var tree = Translator.translate(gpa, &aro_comp, args) catch |err| switch (err) {
-        error.ParsingFailed, error.FatalError => renderErrorsAndExit(&aro_comp),
-        error.OutOfMemory => return error.OutOfMemory,
-        error.StreamTooLong => std.zig.fatal("An input file was larger than 4GiB", .{}),
-    };
-    defer tree.deinit(gpa);
+    try comp.addDefaultPragmaHandlers();
+    comp.langopts.setEmulatedCompiler(aro.target_util.systemCompiler(comp.target));
 
-    const formatted = try tree.render(arena);
+    var driver: aro.Driver = .{ .comp = &comp };
+    defer driver.deinit();
+
+    var macro_buf = std.ArrayList(u8).init(gpa);
+    defer macro_buf.deinit();
+
+    assert(!try driver.parseArgs(std.io.null_writer, macro_buf.writer(), args));
+    assert(driver.inputs.items.len == 1);
+    const source = driver.inputs.items[0];
+
+    const builtin_macros = try comp.generateBuiltinMacros(.include_system_defines, null);
+    const user_macros = try comp.addSourceFromBuffer("<command line>", macro_buf.items);
+
+    var pp = try aro.Preprocessor.initDefault(&comp);
+    defer pp.deinit();
+
+    try pp.preprocessSources(&.{ source, builtin_macros, user_macros });
+
+    var c_tree = try pp.parse();
+    defer c_tree.deinit();
+
+    // Workaround for https://github.com/Vexu/arocc/issues/603
+    for (comp.diagnostics.list.items) |msg| {
+        if (msg.kind == .@"error" or msg.kind == .@"fatal error") return renderErrorsAndExit(&comp);
+    }
+
+    var zig_tree = try Translator.translate(gpa, &comp, c_tree);
+    defer zig_tree.deinit(gpa);
+
+    const formatted = try zig_tree.render(arena);
+    if (driver.output_name) |path| blk: {
+        if (std.mem.eql(u8, path, "-")) break :blk;
+        const out_file = try std.fs.cwd().createFile(path, .{});
+        defer out_file.close();
+
+        try out_file.writeAll(formatted);
+        return std.process.cleanExit();
+    }
     try std.io.getStdOut().writeAll(formatted);
     return std.process.cleanExit();
 }