make frontend write to a file instead of stdout

Author: robertmuth

FE/Makefile_cc

@@ -112,8 +112,8 @@ PHASE =
 
 $(DIR)/%.cw.assim: %.cw
 	@echo "[assim $@]"
-	$(EMIT_IR) -arch x64 $(PHASE) $< > $@.cc_ast
-	./compiler.py -arch x64 $(PHASE) $< > $@.py_ast
+	$(EMIT_IR) -arch x64 $(PHASE) $<  $@.cc_ast
+	./compiler.py -arch x64 $(PHASE) $< $@.py_ast
 	diff $@.py_ast $@.cc_ast
 
 ############################################################

FE/compiler.cc

@@ -236,7 +236,7 @@ void PhaseLegalize(std::vector<Node>& mods_in_topo_order, TypeCorpus* tc) {
 }
 
 void PhaseEmitCode(const std::vector<Node>& mods_in_topo_order,
-                   const TargetArchConfig& ta) {
+                   const TargetArchConfig& ta, std::ostream* fout) {
   std::unordered_set<std::string> sig_names;
   for (Node mod : mods_in_topo_order) {
     for (Node fun = Node_body_mod(mod); !fun.isnull(); fun = Node_next(fun)) {
@@ -245,7 +245,7 @@ void PhaseEmitCode(const std::vector<Node>& mods_in_topo_order,
         if (sig_names.contains(sig_name)) {
           continue;
         }
-        EmitFunctionHeader(sig_name, "SIGNATURE", Node_x_type(fun));
+        EmitFunctionHeader(sig_name, "SIGNATURE", Node_x_type(fun), fout);
         sig_names.insert(sig_name);
       }
     }
@@ -254,13 +254,13 @@ void PhaseEmitCode(const std::vector<Node>& mods_in_topo_order,
   for (Node mod : mods_in_topo_order) {
     for (Node def = Node_body_mod(mod); !def.isnull(); def = Node_next(def)) {
       if (def.kind() == NT::DefGlobal) {
-        EmitDefGlobal(def, ta);
+        EmitDefGlobal(def, ta, fout);
       }
     }
     for (Node fun = Node_body_mod(mod); !fun.isnull(); fun = Node_next(fun)) {
       if (fun.kind() == NT::DefFun) {
         IdGenIR id_gen;
-        EmitDefFun(fun, ta, &id_gen);
+        EmitDefFun(fun, ta, &id_gen, fout);
       }
     }
   }
@@ -297,11 +297,20 @@ int main(int argc, const char* argv[]) {
   InitParser();
   ts.RecordDuration("after_initialization");
 
-  std::vector<Path> seed_modules;
-  for (int i = arg_start; i < argc; ++i) {
-    seed_modules.push_back(std::filesystem::absolute((argv[i])));
+  if (arg_start + 2 != argc) {
+    std::cout << "Expected exactly one input and one output file\n";
+    return 1;
+  }
+  std::ofstream foutFile;
+  std::ostream* fout = &std::cout;
+  if (argv[argc - 1] != std::string_view("-")) {
+    foutFile.open(argv[argc - 1]);
+    fout = &foutFile;
   }
 
+  std::vector<Path> seed_modules;
+  seed_modules.push_back(std::filesystem::absolute((argv[arg_start])));
+
   ModPool mp = ReadModulesRecursively(sw_stdlib.Value(), seed_modules, true);
   std::set<NT> eliminated_nodes = {NT::Import, NT::ModParam};
   SanityCheckMods("after_parsing", mp.mods_in_topo_order, eliminated_nodes,
@@ -404,7 +413,7 @@ int main(int argc, const char* argv[]) {
   SanityCheckMods("after_name_cleanup", mp.mods_in_topo_order, eliminated_nodes,
                   COMPILE_STAGE::AFTER_DESUGAR, &tc, &ts);
 
-  PhaseEmitCode(mp.mods_in_topo_order, *ta);
+  PhaseEmitCode(mp.mods_in_topo_order, *ta, fout);
   ts.RecordDuration("after_emitting_code");
 
   if (sw_dump_stats.Value()) {

FE/compiler.py

@@ -6,6 +6,7 @@
 import argparse
 import pathlib
 import os
+import sys
 
 from typing import Any, Optional
 
@@ -196,24 +197,24 @@ def PhaseLegalize(mod_topo_order: list[cwast.DefMod], tc: type_corpus.TypeCorpus
             canonicalize.FunRewriteComplexAssignments(fun, tc)
 
 
-def PhaseEmitCode(mod_topo_order: list[cwast.DefMod], ta: type_corpus.TargetArchConfig):
+def PhaseEmitCode(mod_topo_order: list[cwast.DefMod], ta: type_corpus.TargetArchConfig, fp):
     sig_names: set[str] = set()
     for mod in mod_topo_order:
         for fun in mod.body_mod:
             # This is really only needed for signature used by JSRs
             if isinstance(fun, cwast.DefFun):
                 sn = emit_ir.MakeFunSigName(fun.x_type)
                 if sn not in sig_names:
-                    emit_ir.EmitFunctionHeader(sn, "SIGNATURE", fun.x_type)
+                    emit_ir.EmitFunctionHeader(sn, "SIGNATURE", fun.x_type, fp)
                     sig_names.add(sn)
 
     for mod in mod_topo_order:
         for node in mod.body_mod:
             if isinstance(node, cwast.DefGlobal):
-                emit_ir.EmitDefGlobal(node, ta)
+                emit_ir.EmitDefGlobal(node, ta, fp)
         for node in mod.body_mod:
             if isinstance(node, cwast.DefFun):
-                emit_ir.EmitDefFun(node, ta, identifier.IdGenIR())
+                emit_ir.EmitDefFun(node, ta, identifier.IdGenIR(), fp)
 
 
 def main() -> int:
@@ -241,7 +242,8 @@ def main() -> int:
     logging.basicConfig(level=logging.WARN)
     # typify.logger.setLevel(logging.INFO)
     logger.info("Start Parsing")
-    assert len(args.files) == 1
+    assert len(args.files) == 2
+    fout = sys.stdout if args.files[1] == "-" else open(args.files[1], "w")
     fn = args.files[0]
     fn, ext = os.path.splitext(fn)
     assert ext in (".cw", ".cws")
@@ -386,8 +388,7 @@ def main() -> int:
     SanityCheckMods("after_name_cleanup", checker.COMPILE_STAGE.AFTER_DESUGAR,
                     args,
                     mod_topo_order, tc, eliminated_nodes)
-
-    PhaseEmitCode(mod_topo_order, ta)
+    PhaseEmitCode(mod_topo_order, ta, fout)
 
     return 0