Parser Push

Author: TheDevConnor

LPBS/ast.lx

@@ -3,6 +3,7 @@
 @use "string" as string
 
 pub const NodeKind -> enum {
+  NODE_PROGRAM,
   NODE_NUMBER,
   NODE_BINARY,
   NODE_UNARY,
@@ -11,6 +12,11 @@ pub const NodeKind -> enum {
 
 pub const ASTNode -> struct { type: int };
 
+pub const Program -> struct {
+  base: ASTNode,
+  nodes: *ASTNode,
+};
+
 pub const Number -> struct {
   base: ASTNode,
   value: int
@@ -34,27 +40,14 @@ pub const Group -> struct {
   expr: *ASTNode
 };
 
-#takes_ownership
-pub const free_ast -> fn (node: *ASTNode) void {
-  if (node == cast<*ASTNode>(0)) { 
-      return; 
-  }
-
-  if (node.type == NodeKind::NODE_NUMBER) { 
-      // nothing inside to free
-  } elif (node.type == NodeKind::NODE_BINARY) {
-    let bin_node: *Binary = cast<*Binary>(node);
-    free_ast(bin_node.left);
-    free_ast(bin_node.right);
-  } elif (node.type == NodeKind::NODE_UNARY) {
-    let unary_node: *Unary = cast<*Unary>(node);
-    free_ast(unary_node.operand);
-  } elif (node.type == NodeKind::NODE_GROUP) {
-    let group_node: *Group = cast<*Group>(node);
-    free_ast(group_node.expr);
-  }
+#returns_ownership
+pub const create_program_node -> fn (nodes: *ASTNode) *ASTNode {
+  let node: *Program = cast<*Program>(alloc(sizeof<Program>));
+  let base_node: *ASTNode = cast<*ASTNode>(node);  
 
-  free(node);
+  base_node.type = NodeKind::NODE_PROGRAM;
+  node.nodes = nodes;
+  return cast<*ASTNode>(node);
 }
 
 #returns_ownership
@@ -100,10 +93,39 @@ pub const create_group_node -> fn (expr: *ASTNode) *ASTNode {
   return cast<*ASTNode>(node);
 }
 
+#takes_ownership
+pub const free_ast -> fn (node: *ASTNode) void {
+  if (node == cast<*ASTNode>(0)) { 
+      return; 
+  }
+
+  if (node.type == NodeKind::NODE_PROGRAM) {
+    let program_node: *Program = cast<*Program>(node);
+    free_ast(program_node.nodes);
+  } elif (node.type == NodeKind::NODE_NUMBER) { 
+      // nothing inside to free
+  } elif (node.type == NodeKind::NODE_BINARY) {
+    let bin_node: *Binary = cast<*Binary>(node);
+    free_ast(bin_node.left);
+    free_ast(bin_node.right);
+  } elif (node.type == NodeKind::NODE_UNARY) {
+    let unary_node: *Unary = cast<*Unary>(node);
+    free_ast(unary_node.operand);
+  } elif (node.type == NodeKind::NODE_GROUP) {
+    let group_node: *Group = cast<*Group>(node);
+    free_ast(group_node.expr);
+  }
+
+  free(node);
+}
+
 pub const print_ast -> fn (node: *ASTNode) void {
   if (node == cast<*ASTNode>(0)) { return; }
 
-  if (node.type == NodeKind::NODE_NUMBER) { 
+  if (node.type == NodeKind::NODE_PROGRAM) {
+    let program_node: *Program = cast<*Program>(node);
+    print_ast(program_node.nodes);
+  } elif (node.type == NodeKind::NODE_NUMBER) { 
     let num_node: *Number = cast<*Number>(node);
     output(num_node.value);
   } elif (node.type == NodeKind::NODE_BINARY) {
@@ -128,19 +150,4 @@ pub const print_ast -> fn (node: *ASTNode) void {
     print_ast(group_node.expr);
     output(")");
   }
-}
-
-pub const main -> fn () int {
-  let node: *ASTNode = create_unary_node('-', 
-                       create_group_node(
-                          create_binary_node('*', 
-                          create_binary_node('+', 
-                              create_number_node(5), 
-                              create_number_node(3)), 
-                          create_number_node(2))));
-  print_ast(node);
-  output("\n");
-  free_ast(node);
-    
-  return 0;
 }

LPBS/main.lx

@@ -3,6 +3,8 @@
 @use "string" as string
 @use "lexer" as lexer
 @use "parser" as psr
+@use "time" as time
+@use "ast" as ast
 @use "io" as io
 
 #takes_ownership
@@ -12,28 +14,17 @@ const clean_up -> fn (path: *char, lex: *Token) void {
 }
 
 pub const main -> fn () int {
-  let path: *char = 
-        io::read_file("/home/connor/Projects/Luma/LPBS/build.lmb");
-  let lex: *Token = lexer::scan(path);
-  
-  // output("Token count: ");
-  // output(lex.size);
-  // output("\n");
-  // 
-  // loop [i: int = 0](i < lex.size) : (++i) {
-  //   let tk: Token = lex.list[i];
-  //   output("i: ", i, " Token ");
-  //   output(tk.type);
-  //   output(": ");
-  //   output(tk.value);
-  //   output("\n");
-  // }
+  let speed: Timer = time::timer_start();
 
-  let parser: Parser;
-  psr::init_parser(&parser, lex);
+  let path: *char = "/home/TheDevConnor/Luma/LPBS/build.lmb";
+  let file: *char = io::read_file(path);
+  let lex: *Token = lexer::scan(file);
 
-  output(psr::peek(&parser, 45).value, "\n");
+  let parser: *ASTNode = psr::parse(lex, path);
 
-  clean_up(path, lex);
+  clean_up(file, lex);
+
+  let elapsed: int = time::timer_elapsed_ms(speed);
+  output("Took ", elapsed, "ms\n");
   return 0;
 }

LPBS/parser.lx

@@ -1,6 +1,7 @@
 @module "parser"
 
 @use "lexer" as lexer
+@use "ast" as ast
 
 const BindingPower -> enum {
   BP_NONE,        /**< No binding power */
@@ -31,7 +32,7 @@ pub const Parser -> struct {
   pos: int,
 };
 
-pub const init_parser -> fn (psr: *Parser, tks: *Token) void {
+pub const init_parser -> fn (psr: *Parser, tks: *Token, path: *char) void {
   psr.path = path;
   psr.tks = tks;
   psr.pos = 0;
@@ -41,6 +42,11 @@ pub const peek -> fn (psr: *Parser, index: int) Token {
   return psr.tks.list[index];
 }
 
-pub const parse -> fn (tks: *Token, path: *char) void {
-  
+pub const parse -> fn (tks: *Token, path: *char) *ASTNode {
+  let psr: Parser;
+  init_parser(&psr, tks, path);
+
+  output(peek(&psr, 10).value, "\n");
+
+  return cast<*ASTNode>(0); 
 }