Begin compiler

Start of the compiler. The compiler does not directly produce the `.ksm`
binary, but it gives the kRISC instructions to be placed in a binary.
While it is currently far from done, it has output its first program
(with help by manually* assmebling the binary):

```kLang
func main: () -> () {
    print("Hello kOS!");
}
```
which is this in kRISC instructions:

```kRISC
push ARG_MARKER
push "Hello kOS!"
call "", "print"
```
and the test kOS CPU output this:
```kOS Output
Hello kOS!
```

Author: CoderCatGG

src/main.rs

@@ -7,6 +7,8 @@ use clap::Parser;
 
 mod lexer;
 mod parser;
+mod compiler;
+
 
 /// A compiler for kLang
 #[derive(Debug, Parser)]
@@ -108,6 +110,16 @@ fn main() {
 
     LOG.debug(&format!("\nParsed:\n\n{:?}\n", &ast));
 
+    let ksm = match compiler::parse_ast(ast) {
+        Ok(ksm) => ksm,
+        Err(e) => {
+            LOG.surface(&format!("{e}"));
+            std::process::exit(1);
+        }
+    };
+
+    LOG.debug(&format!("\nKSM:\n\n{:?}\n", &ksm));
+    
     todo!("Finish parsing & Compilation");
 }
 

src/parser.rs

@@ -152,7 +152,7 @@ macro_rules! expect_lit_ident {
     };
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub enum Stmt {
     Assembly(String),
     Expr(Expr),
@@ -168,15 +168,15 @@ pub enum Stmt {
     Break(Option<Expr>),
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Function {
-    name: String,
-    input: Vec<(String, Type)>,
-    output: Type,
-    body: Scope,
+    pub name: String,
+    pub input: Vec<(String, Type)>,
+    pub output: Type,
+    pub body: Scope,
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub enum Expr {
     Call {
         name: String,
@@ -196,12 +196,12 @@ pub enum Expr {
     Lit(Lit),
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Scope {
-    statements: Vec<Stmt>,
+    pub statements: Vec<Stmt>,
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub enum Lit {
     I16(i16),
     I32(i32),
@@ -213,7 +213,7 @@ pub enum Lit {
     Identifier(String),
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub enum Type {
     I16,
     I32,
@@ -226,19 +226,19 @@ pub enum Type {
     Identifier(String),
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub struct Constant {
-    name: String,
-    r#type: Type,
-    expr: Expr,
+    pub name: String,
+    pub r#type: Type,
+    pub expr: Expr,
 }
 
 #[derive(Debug)]
 pub struct AST {
-    statements: Vec<(Stmt, (usize, usize))>,
-    consts: Vec<Constant>,
-    macros: Vec<(String, Expr)>,
-    types: Vec<(String, Type)>,
+    pub functions: Vec<Function>,
+    pub consts: Vec<Constant>,
+    pub macros: Vec<(String, Expr)>,
+    pub types: Vec<(String, Type)>,
 }
 
 pub fn parse_tokens(tokens: Vec<DataToken>) -> Result<AST, ParseError> {
@@ -248,8 +248,7 @@ pub fn parse_tokens(tokens: Vec<DataToken>) -> Result<AST, ParseError> {
 }
 
 fn parse_global(tokens: &mut tokenstream!()) -> Result<AST, ParseError> {
-    let mut result: Vec<(Stmt, (usize, usize))> = Vec::new();
-
+    let mut functions: Vec<Function> = Vec::new();
     let mut consts: Vec<Constant> = Vec::new();
     let mut macros: Vec<(String, Expr)> = Vec::new();
     let mut types: Vec<(String, Type)> = Vec::new();
@@ -263,19 +262,15 @@ fn parse_global(tokens: &mut tokenstream!()) -> Result<AST, ParseError> {
                 Token::Const => consts.push(parse_constant(tokens)?),
                 Token::Macro => macros.push(parse_macro(tokens)?),
                 Token::Type => types.push(parse_type_assign(tokens)?),
-                Token::Func => result.push((Stmt::Func(parse_function(tokens)?), t.get_pos())),
+                Token::Func => functions.push(parse_function(tokens)?),
                 _ => return ParseError::new(&tokens.next().unwrap(), ParseErrorReason::UnexpectedToken, "An unexpected token in global scope, allowed tokens: `func`, `const`, `macro` and `type`")
             },
             None => break,
         }
     }
 
-    super::LOG.debug(&format!("\nGot constants: {:?}", consts));
-    super::LOG.debug(&format!("Got macros: {:?}", macros));
-    super::LOG.debug(&format!("Got types: {:?}", types));
-
     Ok(AST {
-        statements: result,
+        functions,
         consts,
         macros,
         types,
@@ -379,6 +374,8 @@ fn parse_function(tokens: &mut tokenstream!()) -> Result<Function, ParseError> {
 
     let body = parse_scope(tokens)?;
 
+    optional!(tokens, Terminator);
+
     Ok(Function {
         name,
         input: inputs,
@@ -462,7 +459,10 @@ fn parse_scope(tokens: &mut tokenstream!()) -> Result<Scope, ParseError> {
                 consume!(tokens, Terminator, "Break must be terminated with `;`, as it is currently a statement");
             },
             Token::Terminator => {super::LOG.explicit(&format!("Stray terminator `;`: {:?}", &tok)); tokens.next();},
-            _ => statements.push(Stmt::Expr(parse_expr(tokens, 0)?))
+            _ => {
+                statements.push(Stmt::Expr(parse_expr(tokens, 0)?));
+                optional!(tokens, Comma);
+            }
         });
     }
 }