Update skeleton

bin/kecc.rs

@@ -1,12 +1,17 @@
+use std::ffi::OsStr;
+use std::path::Path;
 #[macro_use]
 extern crate clap;
 use clap::{crate_authors, crate_description, crate_version, App};
 
+use lang_c::ast::TranslationUnit;
+
 #[macro_use]
 extern crate kecc;
 
 use kecc::{
-    write, Asmgen, Deadcode, Gvn, Irgen, Mem2reg, Optimize, Parse, SimplifyCfg, Translate, O1,
+    ir, write, Asmgen, Deadcode, Gvn, IrParse, Irgen, Mem2reg, Optimize, Parse, SimplifyCfg,
+    Translate, O1,
 };
 
 fn main() {
@@ -19,7 +24,7 @@ fn main() {
         .get_matches();
 
     let input = matches.value_of("INPUT").unwrap();
-    let unit = ok_or_exit!(Parse::default().translate(&input), 1);
+    let input = Path::new(input);
 
     let output = matches.value_of("output").unwrap_or_else(|| "-");
     let mut output: Box<dyn ::std::io::Write> = if output == "-" {
@@ -28,47 +33,87 @@ fn main() {
         Box::new(ok_or_exit!(::std::fs::File::open(output), 1))
     };
 
+    let ext = input.extension();
+    if ext == Some(OsStr::new("c")) {
+        let input = ok_or_exit!(Parse::default().translate(&input), 1);
+        compile_c(&input, &mut output, &matches);
+    } else if ext == Some(OsStr::new("ir")) {
+        let mut input = ok_or_exit!(IrParse::default().translate(&input), 1);
+        compile_ir(&mut input, &mut output, &matches);
+    } else {
+        panic!("Unsupported file extension: {:?}", ext);
+    }
+}
+
+fn compile_c(
+    input: &TranslationUnit,
+    output: &mut dyn ::std::io::Write,
+    matches: &clap::ArgMatches<'_>,
+) {
     if matches.is_present("parse") {
         return;
     }
 
     if matches.is_present("print") {
-        write(&unit, &mut output).unwrap();
+        write(input, output).unwrap();
         return;
     }
 
-    let mut ir = match Irgen::default().translate(&unit) {
+    let mut ir = match Irgen::default().translate(input) {
         Ok(ir) => ir,
         Err(irgen_error) => {
             println!("{}", irgen_error);
             return;
         }
     };
+
     if matches.is_present("irgen") {
-        write(&ir, &mut output).unwrap();
+        write(&ir, output).unwrap();
+        return;
+    }
+
+    compile_ir(&mut ir, output, matches)
+}
+
+fn compile_ir(
+    input: &mut ir::TranslationUnit,
+    output: &mut dyn ::std::io::Write,
+    matches: &clap::ArgMatches<'_>,
+) {
+    if matches.is_present("irparse") {
+        return;
+    }
+
+    if matches.is_present("irprint") {
+        write(input, output).unwrap();
         return;
     }
 
     if matches.is_present("optimize") {
-        O1::default().optimize(&mut ir);
+        O1::default().optimize(input);
     } else {
         if matches.is_present("simplify-cfg") {
-            SimplifyCfg::default().optimize(&mut ir);
+            SimplifyCfg::default().optimize(input);
         }
 
         if matches.is_present("mem2erg") {
-            Mem2reg::default().optimize(&mut ir);
+            Mem2reg::default().optimize(input);
         }
 
         if matches.is_present("deadcode") {
-            Deadcode::default().optimize(&mut ir);
+            Deadcode::default().optimize(input);
         }
 
         if matches.is_present("gvn") {
-            Gvn::default().optimize(&mut ir);
+            Gvn::default().optimize(input);
         }
     }
 
-    let asm = ok_or_exit!(Asmgen::default().translate(&ir), 1);
-    write(&asm, &mut output).unwrap();
+    if matches.is_present("iroutput") {
+        write(input, output).unwrap();
+        return;
+    }
+
+    let asm = ok_or_exit!(Asmgen::default().translate(input), 1);
+    write(&asm, output).unwrap();
 }