Initial commit

aurac/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "aurac"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+aurac_lexer = { path = "../aurac_lexer" }
+aurac_parser = { path = "../aurac_parser" }
+aurac_typechecker = { path = "../aurac_typechecker" }
+aurac_codegen = { path = "../aurac_codegen" }

aurac/src/main.rs

@@ -0,0 +1,66 @@
+use std::env;
+use std::fs;
+use std::process;
+
+use aurac_lexer::lexer::Lexer;
+use aurac_lexer::token::TokenKind;
+use aurac_parser::parser::Parser;
+use aurac_parser::ast::{Program, Decl};
+use aurac_typechecker::checker::TypeChecker;
+use aurac_codegen::ir_gen::IrGenerator;
+
+fn main() {
+    let args: Vec<String> = env::args().collect();
+    if args.len() < 2 {
+        eprintln!("Usage: aurac <file.aura>");
+        process::exit(1);
+    }
+
+    let file_path = &args[1];
+    let source_code = fs::read_to_string(file_path).unwrap_or_else(|err| {
+        eprintln!("Error reading file '{}': {}", file_path, err);
+        process::exit(1);
+    });
+
+    // 1. Lexer Phase
+    let mut lexer = Lexer::new(&source_code);
+    let mut tokens = Vec::new();
+    loop {
+        let tok = lexer.next_token();
+        let is_eof = tok.kind == TokenKind::Eof;
+        tokens.push(tok);
+        if is_eof {
+            break;
+        }
+    }
+
+    // 2. Parser Phase
+    let mut parser = Parser::new(&tokens);
+    let fn_decl = parser.parse_fn_decl().unwrap_or_else(|err| {
+        eprintln!("Syntax Error: {}", err);
+        process::exit(1);
+    });
+
+    let program = Program {
+        decls: vec![Decl::Fn(fn_decl)],
+    };
+
+    // 3. Semantic Analysis / Typechecker Phase
+    let mut checker = TypeChecker::new();
+    if let Err(err) = checker.check_program(&program) {
+        eprintln!("Type Error: {}", err);
+        process::exit(1);
+    }
+
+    // 4. Code Generation Phase (LLVM IR)
+    let mut generator = IrGenerator::new();
+    let ir_code = generator.generate_program(&program);
+
+    // 5. Output
+    println!("{}", ir_code);
+
+    if let Err(err) = fs::write("output.ll", &ir_code) {
+        eprintln!("Error writing 'output.ll': {}", err);
+        process::exit(1);
+    }
+}