lang/src/ast.asm

@@ -193,7 +193,6 @@ parse_args:
     mov rdx, 0                  ; drop = None
     mov rcx, 16                 ; capacity
     call vec_init_with
-    nop
 
 .loop:
     mov dil, TOKEN_RPARENS
@@ -555,11 +554,8 @@ parse_statement:
     jnz .let
     mov dil, TOKEN_LBRACE
     call peek_expect_token      ; parse_block expects lbrace to still be there
-    test rax, rax
     jnz .block
-    mov rdi, [rsp]              ; Ast
-    call parse_expr
-    jmp .epilogue
+    jmp .panic
 
 .block:
     mov rdi, [rsp]              ; Ast
@@ -754,11 +750,6 @@ parse_prefix_expr:
     mov rdi, [rsp]              ; Ast
     call parse_prefix_expr
 
-    mov rdi, [rsp]              ; Ast
-    mov rsi, rax                ; expr
-    ; mov rdx, rdx              ; placeness
-    call ast_place_to_value
-
     mov qword [rsp + 8], AST_DEREF ; AstNode.kind
     mov [rsp + 16], rax            ; AstNode.data
     mov qword [rsp + 24], 0        ; AstNode.extra

lang/tests/ast.rs

@@ -12,7 +12,7 @@ unsafe extern "C" {
     unsafe fn tokeniser_init_buf(bytes: *const u8, len: usize) -> ();
 }
 
-use util::defs::{parse_func, Ast};
+use util::defs::{parse_expr, parse_func, Ast, AstNode};
 
 fn main() {
     unsafe {
@@ -20,6 +20,8 @@ fn main() {
     }
     println!("Bump allocator initialized.");
 
+    let src = b"3 + 4";
+
     fn print_ast(src: &[u8], parser: impl FnOnce(&mut Ast) -> u64) {
         unsafe {
             tokeniser_init_buf(src.as_ptr(), src.len());
@@ -58,57 +60,50 @@ fn main() {
         };
     }
 
-    //     print_ast(
-    //         b"fn main() -> void { return 1 * 2 + 3 * 4; }",
-    //         |ast| unsafe { parse_func(ast) },
-    //     );
-
-    //     print_ast(b"3 + 4", |ast| unsafe { parse_expr(ast) });
-    //     print_ast(b"fn main() -> void { return 1 + 2; }", |ast| unsafe {
-    //         parse_func(ast)
-    //     });
-    //     print_ast(
-    //         b"fn main() -> void { ;;;return (1 + (2)); }",
-    //         |ast| unsafe { parse_func(ast) },
-    //     );
-    //     print_ast(
-    //         b"fn main() -> void { return (1 + (2 * 3)) / 4; }",
-    //         |ast| unsafe { parse_func(ast) },
-    //     );
-    //     print_ast(b"fn main() -> void { return 1 + 2 * 3; }", |ast| unsafe {
-    //         parse_func(ast)
-    //     });
-
-    //     print_ast(b"fn main() -> void { let x: u32 = 4; }", |ast| unsafe {
-    //         parse_func(ast)
-    //     });
-    //     print_ast(
-    //         b"fn main(a: u32) -> void { let x: u32 = a + 4; }",
-    //         |ast| unsafe { parse_func(ast) },
-    //     );
-    //     print_ast(
-    //         b"fn main(a: u32) -> void {
-    //     let y: u32 = a + 4;
-    //     let y: *u32 = &y;
-    //     return *y;
-    //     }",
-    //         |ast| unsafe { parse_func(ast) },
-    //     );
-    //     print_ast(
-    //         b"fn main(a: u32) -> void {
-    // let y: u32 = a + 4;
-    // {
-    //   let y: u32 = 10;
-    // }
-    // let y: *u32 = &y;
-    // return *y;
-    // }",
-    //         |ast| unsafe { parse_func(ast) },
-    //     );
     print_ast(
-        b"fn main(a: *u32, b: u32) -> void {
-*a = b;
-a = &b;
+        b"fn main() -> void { return 1 * 2 + 3 * 4; }",
+        |ast| unsafe { parse_func(ast) },
+    );
+
+    print_ast(b"3 + 4", |ast| unsafe { parse_expr(ast) });
+    print_ast(b"fn main() -> void { return 1 + 2; }", |ast| unsafe {
+        parse_func(ast)
+    });
+    print_ast(
+        b"fn main() -> void { ;;;return (1 + (2)); }",
+        |ast| unsafe { parse_func(ast) },
+    );
+    print_ast(
+        b"fn main() -> void { return (1 + (2 * 3)) / 4; }",
+        |ast| unsafe { parse_func(ast) },
+    );
+    print_ast(b"fn main() -> void { return 1 + 2 * 3; }", |ast| unsafe {
+        parse_func(ast)
+    });
+
+    print_ast(b"fn main() -> void { let x: u32 = 4; }", |ast| unsafe {
+        parse_func(ast)
+    });
+    print_ast(
+        b"fn main(a: u32) -> void { let x: u32 = a + 4; }",
+        |ast| unsafe { parse_func(ast) },
+    );
+    print_ast(
+        b"fn main(a: u32) -> void {
+    let y: u32 = a + 4;
+    let y: *u32 = &y;
+    return *y;
+    }",
+        |ast| unsafe { parse_func(ast) },
+    );
+    print_ast(
+        b"fn main(a: u32) -> void {
+let y: u32 = a + 4;
+{
+  let y: u32 = 10;
+}
+let y: *u32 = &y;
+return *y;
 }",
         |ast| unsafe { parse_func(ast) },
     );

lang/tests/bump.rs

@@ -56,7 +56,6 @@ fn main() {
 
     #[repr(align(256))]
     struct AlignedType {
-        #[allow(dead_code)]
         data: [u8; 512],
     }
     let aligned = Box::new_in(AlignedType { data: [0; 512] }, BumpAllocator);

lang/tests/codegen.rs

@@ -6,7 +6,7 @@ mod util;
 #[path = "shared/ast_debug.rs"]
 mod ast_debug;
 
-use util::defs::{parse_func, Ast};
+use util::defs::{parse_func, Ast, AstNode};
 
 unsafe extern "C" {
     unsafe fn bump_init();
@@ -93,8 +93,7 @@ fn main() {
 
     print_ast(
         b"fn main(a: u32) -> void {
-let b: *u32 = &a;
-    return 5 + *b;
+    return 2 * 3 + 4 * 5;
     }",
         |ast| unsafe { parse_func(ast) },
     );

lang/tests/shared/defs.rs

@@ -21,7 +21,6 @@ unsafe extern "C" {
     pub unsafe fn stackvar_cmp(a: *const (u64, u64), b: *const (u64, u64)) -> i32;
     pub unsafe fn codegen_allocate_register(ctx: *mut FunctionCtx) -> u8;
     pub unsafe fn codegen_allocate_place(ctx: *mut FunctionCtx, width: u16) -> Operand;
-    pub unsafe fn codegen_allocate_stack_value(ctx: *mut FunctionCtx, width: u16) -> Operand;
     pub unsafe fn codegen_allocate_value(ctx: *mut FunctionCtx, width: u16) -> Operand;
     pub unsafe fn codegen_free_operand(ctx: *mut FunctionCtx, operand: *const Operand) -> ();
     pub unsafe fn codegen_function(ast: *const CodegenCtx, func_idx: u64) -> ();
@@ -59,18 +58,12 @@ pub const TYPE_U32: u8 = 4;
 pub const TYPE_STR: u8 = 5;
 pub const TYPE_POINTER: u8 = 6;
 pub const OPERAND_REGISTER: u32 = 1;
-pub const OPERAND_RBP_VALUE: u32 = 2;
-pub const OPERAND_RBP_PVALUE: u32 = 3;
-pub const OPERAND_ADDRESS_VALUE: u32 = 4;
-pub const OPERAND_LAST_VALUE: u32 = 5;
-pub const OPERAND_RBP_OFFSET: u32 = 6;
-pub const OPERAND_ADDRESS_PLACE: u32 = 7;
-pub const OPERAND_REGISTER_PLACE: u32 = 8;
-pub const OPERAND_RBP_PLACE: u32 = 9;
-pub const OPERAND_LAST_PLACE: u32 = 10;
-pub const OPERAND_IMMEDIATE: u32 = 11;
-pub const OPERAND_CONSTANT: u32 = 12;
-pub const OPERAND_LABEL: u32 = 13;
+pub const OPERAND_RBP_OFFSET: u32 = 2;
+pub const OPERAND_RSP_OFFSET: u32 = 3;
+pub const OPERAND_ADDRESS: u32 = 4;
+pub const OPERAND_IMMEDIATE: u32 = 5;
+pub const OPERAND_CONSTANT: u32 = 6;
+pub const OPERAND_LABEL: u32 = 7;
 pub const TOKEN_EOF: u8 = 0;
 pub const TOKEN_LET: u8 = 1;
 pub const TOKEN_IF: u8 = 2;
@@ -254,8 +247,7 @@ pub struct FunctionCtx {
 #[derive(Debug)]
 pub struct Operand {
     pub kind: u8,
-    pub register: u8,
-    pub width: u16,
+    pub register_and_width: u8,
     pub len: u16,
     pub value: u64,
 }

lang/tests/shared/shared.rs

@@ -278,7 +278,7 @@ pub mod vec {
             }
         }
 
-        pub fn insert_sorted<F>(&mut self, elem: T, mut cmp: F) -> Result<usize, usize>
+        pub fn insert_sorted<F>(&self, elem: T, mut cmp: F) -> Result<usize, usize>
         where
             F: FnMut(&T, &T) -> i32,
         {

lang/tests/vec.rs

@@ -118,18 +118,4 @@ fn main() {
     let elements = Box::new([6, 7, 8]);
     vec.insert_many(2, elements);
     assert_eq!(vec.as_slice(), &[50, 1, 6, 7, 8, 2, 3, 4, 5]);
-
-    let mut vec = Vec::<u32>::new_with(100);
-    assert_eq!(vec.len(), 0);
-    _ = vec.insert_sorted(5, cmp);
-    assert_eq!(vec.len(), 1);
-    assert_eq!(vec.as_slice(), &[5]);
-
-    _ = vec.insert_sorted(2, cmp);
-    assert_eq!(vec.len(), 2);
-    assert_eq!(vec.as_slice(), &[2, 5]);
-
-    _ = vec.insert_sorted(7, cmp);
-    assert_eq!(vec.len(), 3);
-    assert_eq!(vec.as_slice(), &[2, 5, 7]);
 }