Fixed some small tc issues that are now fixed

Author: TheDevConnor

LPBS/ast.lx

@@ -168,53 +168,4 @@ pub const free_stmt -> fn (node: *Stmt) void {
   }
 
   free(node);
-}
-
-pub const print_expr -> fn (node: *Expr) void {
-  if (node == cast<*Expr>(0)) { return; }
-  
-  if (node.type == ExprKind::EXPR_NUMBER) { 
-    let num_node: *Number = cast<*Number>(node);
-    output(num_node.value);
-  } elif (node.type == ExprKind::EXPR_IDENT) {
-    let ident_node: *Ident = cast<*Ident>(node);
-    output(ident_node.name);
-  } elif (node.type == ExprKind::EXPR_STRING) {
-    let str_node: *StringLit = cast<*StringLit>(node);
-    output("''", str_node.value, "''");
-  } elif (node.type == ExprKind::EXPR_BINARY) {
-    let bin_node: *Binary = cast<*Binary>(node);
-    let binop: *char = string::from_char(bin_node.op);
-    defer { free(binop); }
-
-    output("(");
-    print_expr(bin_node.left);
-    output(" ", binop, " ");
-    print_expr(bin_node.right);
-    output(")");
-  } elif (node.type == ExprKind::EXPR_UNARY) {
-    let unary_node: *Unary = cast<*Unary>(node);
-    let unop: *char = string::from_char(unary_node.op);
-    defer { free(unop); }
-
-    output(unop);
-    print_expr(unary_node.operand);
-  } elif (node.type == ExprKind::EXPR_GROUP) {
-    let group_node: *Group = cast<*Group>(node);
-
-    output("(");
-    print_expr(group_node.expr);
-    output(")");
-  }
-}
-
-pub const print_stmt -> fn (node: *Stmt) void {
-  if (node == cast<*Stmt>(0)) { return; }
-  
-  if (node.type == StmtKind::STMT_PROGRAM) {
-    let program_node: *Program = cast<*Program>(node);
-    print_expr(program_node.nodes);
-  }
-
-  output("\n");
-}
+}

LPBS/ast_helper.lx

@@ -0,0 +1,53 @@
+@module "ast_helper"
+
+@use "string" as string
+@use "ast" as ast
+
+pub const print_expr -> fn (node: *Expr) void {
+  if (node == cast<*Expr>(0)) { return; }
+  
+  if (node.type == ast::ExprKind::EXPR_NUMBER) { 
+    let num_node: *Number = cast<*Number>(node);
+    output(num_node.value);
+  } elif (node.type == ast::ExprKind::EXPR_IDENT) {
+    let ident_node: *Ident = cast<*Ident>(node);
+    output(ident_node.name);
+  } elif (node.type == ast::ExprKind::EXPR_STRING) {
+    let str_node: *StringLit = cast<*StringLit>(node);
+    output("''", str_node.value, "''");
+  } elif (node.type == ast::ExprKind::EXPR_BINARY) {
+    let bin_node: *Binary = cast<*Binary>(node);
+    let binop: *char = string::from_char(bin_node.op);
+    defer { free(binop); }
+
+    output("(");
+    print_expr(bin_node.left);
+    output(" ", binop, " ");
+    print_expr(bin_node.right);
+    output(")");
+  } elif (node.type == ast::ExprKind::EXPR_UNARY) {
+    let unary_node: *Unary = cast<*Unary>(node);
+    let unop: *char = string::from_char(unary_node.op);
+    defer { free(unop); }
+
+    output(unop);
+    print_expr(unary_node.operand);
+  } elif (node.type == ast::ExprKind::EXPR_GROUP) {
+    let group_node: *Group = cast<*Group>(node);
+
+    output("(");
+    print_expr(group_node.expr);
+    output(")");
+  }
+}
+
+pub const print_stmt -> fn (node: *Stmt) void {
+  if (node == cast<*Stmt>(0)) { return; }
+  
+  if (node.type == ast::StmtKind::STMT_PROGRAM) {
+    let program_node: *Program = cast<*Program>(node);
+    print_expr(program_node.nodes);
+  }
+
+  output("\n");
+}

LPBS/main.lx

@@ -1,29 +1,24 @@
 @module "main"
 
-@use "string" as string
+@use "ast_helper" as ast_helper
 @use "lexer" as lexer
 @use "parser" as psr
 @use "time" as time
 @use "ast" as ast
 @use "io" as io
 
-#takes_ownership
-const clean_up -> fn (path: *char, lex: *Token) void {
-  free(path);
-  lexer::free_tokens(lex);
-}
-
 pub const main -> fn () int {
   let speed: Timer = time::timer_start();
 
   let path: *char = "/home/TheDevConnor/Luma/LPBS/build.lmb";
   let file: *char = io::read_file(path);
-  let lex: *lexer::Token = lexer::scan(file);
+  let lex: *Token = lexer::scan(file);
 
-  let parser: *ast::Stmt = psr::parse(lex, path);
-  ast::print_stmt(parser);
+  let parser: *Stmt = psr::parse(lex, path);
+  ast_helper::print_stmt(parser);
 
-  clean_up(file, lex);
+  free(file);
+  lexer::free_tokens(lex);
   ast::free_stmt(parser);
 
   let elapsed: int = time::timer_elapsed_ms(speed);

LPBS/parser.lx

@@ -29,25 +29,25 @@ const BindingPower -> enum {
 };
 
 pub const Parser -> struct {
-  tks: *lexer::Token,
+  tks: *Token,
   path: *char,
   pos: int,
 
-  init_parser -> fn (tks: *lexer::Token, path: *char) void {
+  init_parser -> fn (tks: *Token, path: *char) void {
     self.path = path;
     self.tks = tks;
     self.pos = 0;
   },
 };
 
-// TODO: Add in resolution types for namespaces/modules ex: *ast::Expr, ast::NodeType,
+// TODO: Add in resolution types for namespaces/modules ex: *Expr, ast::NodeType,
 // TODO: and fix the types for the module system for enums and structs with it.
 
 const at_end  -> fn (psr: *Parser) int { return cast<int>(psr.pos >= psr.tks.size); }
-const peek    -> fn (psr: *Parser) lexer::Token {  return psr.tks.list[psr.pos]; }
+const peek    -> fn (psr: *Parser) Token {  return psr.tks.list[psr.pos]; }
 const advance -> fn (psr: *Parser) void { psr.pos = psr.pos + 1; }
 
-const parse_expr -> fn (psr: *Parser, bp: int) *ast::Expr;
+const parse_expr -> fn (psr: *Parser, bp: int) *Expr;
 
 const get_infix_bp -> fn (token_type: int) int {
   switch (token_type) {
@@ -57,8 +57,8 @@ const get_infix_bp -> fn (token_type: int) int {
   }
 }
 
-const parse_literal -> fn (psr: *Parser) *ast::Expr {
-  let tok: lexer::Token = peek(psr);
+const parse_literal -> fn (psr: *Parser) *Expr {
+  let tok: Token = peek(psr);
 
   switch (tok.type) {
     0 -> { //number
@@ -83,15 +83,15 @@ const parse_literal -> fn (psr: *Parser) *ast::Expr {
   }
 }
 
-const nud -> fn (psr: *Parser) *ast::Expr {
-  let tok: lexer::Token = peek(psr);
+const nud -> fn (psr: *Parser) *Expr {
+  let tok: Token = peek(psr);
 
   switch (tok.type) {
     0, 1, 2 -> { return parse_literal(psr); } //number, ident, string
     6 -> { //(
       advance(psr);
-      let expr: *ast::Expr = parse_expr(psr, BindingPower::BP_NONE);
-      let next_tok: lexer::Token = peek(psr);
+      let expr: *Expr = parse_expr(psr, BindingPower::BP_NONE);
+      let next_tok: Token = peek(psr);
       if (next_tok.type != 7) { //)
         output("Expected closing parenthesis\n");
         return cast<*Expr>(0);
@@ -102,37 +102,37 @@ const nud -> fn (psr: *Parser) *ast::Expr {
     16, 17 -> { //+, -
       let op: *char = tok.value;
       advance(psr);
-      let right: *ast::Expr = parse_expr(psr, BindingPower::BP_UNARY);
+      let right: *Expr = parse_expr(psr, BindingPower::BP_UNARY);
       return ast::create_unary_node(op[0], right);
     }
     _ -> {
       output("Unexpected token in prefix position\n");
-      return cast<*ast::Expr>(0);
+      return cast<*Expr>(0);
     }
   }
 }
 
-const led -> fn (psr: *Parser, left: *ast::Expr, token: lexer::Token) *ast::Expr {
+const led -> fn (psr: *Parser, left: *Expr, token: Token) *Expr {
   switch (token.type) {
     12, 13, 16, 17, 18, 19 -> { //==, !=, +, -, *, / 
       let op: *char = psr.tks.list[psr.pos].value; 
       advance(psr);
-      let right: *ast::Expr = parse_expr(psr, get_infix_bp(token.type));
+      let right: *Expr = parse_expr(psr, get_infix_bp(token.type));
       return ast::create_binary_node(op[0], left, right);
     }
     _ -> {
       output("Unexpected token in infix position\n");
-      return cast<*ast::Expr>(0);
+      return cast<*Expr>(0);
     }
   }
 }
 
-const parse_expr -> fn (psr: *Parser, bp: int) *ast::Expr {
-  let left: *ast::Expr = nud(psr);
+const parse_expr -> fn (psr: *Parser, bp: int) *Expr {
+  let left: *Expr = nud(psr);
 
   // Inline the led logic here
   loop (at_end(psr) == 0 && bp < get_infix_bp(peek(psr).type)) {
-    let tok: lexer::Token = peek(psr);
+    let tok: Token = peek(psr);
     let next_bp: int = get_infix_bp(tok.type);
 
     left = led(psr, left, tok);
@@ -141,11 +141,11 @@ const parse_expr -> fn (psr: *Parser, bp: int) *ast::Expr {
   return left;
 }
 
-pub const parse -> fn (tks: *lexer::Token, path: *char) *ast::Stmt {
+pub const parse -> fn (tks: *Token, path: *char) *Stmt {
   let psr: Parser;
   psr.init_parser(tks, path);
 
-  let node: *ast::Expr = parse_expr(&psr, BindingPower::BP_NONE);
+  let node: *Expr = parse_expr(&psr, BindingPower::BP_NONE);
 
   return ast::create_program_node(node); 
 }