lang/src/int_to_str.asm

@@ -104,9 +104,7 @@ int_to_str2:
     test rdi, rdi
     jnz .convert_loop
     mov byte [rsi + r12], '0'
-    inc r13
-    inc r12
-    jmp .reverse
+    jmp .epilogue
 
 .convert_loop:
     mov rax, [rsp + 8]          ; buffer length
@@ -131,7 +129,6 @@ int_to_str2:
     test rdi, rdi
     jnz .convert_loop
 
-.reverse:
     ; Reverse the digits
     mov rdx, r12
     dec r12                     ; last digit index

lang/src/test.m

@@ -0,0 +1 @@
+let fn if

lang/src/vec.asm

@@ -23,7 +23,6 @@ global vec_get_or
 global vec_drop
 global vec_find
 global vec_insert
-global vec_insert_many
 global vec_insert_sorted
 global vec_binary_search_by
 
@@ -483,7 +482,7 @@ vec_find:
 ;; rdi: pointer to Vec struct
 ;; rsi : index
 ;; rdx: pointer to data to insert
-;; fn vec_insert(vec: *mut Vec, index: usize, data: *const T)
+;; fn vec_insert(vec: *mut Vec, index: usize, data: *const T, size: usize)
 vec_insert:
     push rbp
     mov rbp, rsp
@@ -531,65 +530,6 @@ vec_insert:
     pop rbp
     ret
 
-;; rdi: pointer to Vec struct
-;; rsi : index
-;; rdx: pointer to data to insert
-;; rcx: count
-;; define-fn: fn vec_insert_many(vec: *mut BlobVec, index: usize, data: *const u8, count: usize)
-vec_insert_many:
-    push rbp
-    mov rbp, rsp
-    push r12
-    push rbx
-    sub rsp, 0x20
-    mov [rsp], rdi              ; save vec
-    mov [rsp + 8], rsi          ; save index
-    mov [rsp + 0x10], rdx       ; save data ptr
-    mov [rsp + 0x18], rcx       ; save count
-
-    mov rsi, [rdi + 8]
-    add rsi, rcx                ; len + count
-    call vec_try_grow
-
-    mov rbx, [rsp]          ; vec
-    mov rdi, [rbx]          ; vec.data
-    mov rcx, [rbx + 24]     ; item_size
-    mov rdx, [rbx + 8]      ; len
-    sub rdx, [rsp + 8]      ; len - index
-    mov rax, rdx
-    mul rcx                 ; (len - index) * item_size
-    mov r12, rax            ; number of bytes to move
-    mov rsi, [rbx]          ; vec.data
-    mov rax, [rsp + 8]      ; index
-    mov rcx, [rbx + 24]     ; item_size
-    mul rcx                 ; index * item_size
-    add rsi, rax            ; src ptr
-    mov rdi, rsi
-
-    mov rax, [rsp + 0x18]     ; count
-    mul rcx                 ; count * item_size
-    add rdi, rax            ; dst ptr
-    mov rdx, r12            ; number of bytes to move
-    call memmove
-
-    mov rdi, rsi
-    mov rsi, [rsp + 0x10]
-    mov rcx, [rsp + 0x18]     ; count
-    mov rax, [rbx + 24]     ; item_size
-    mul rcx                 ; count * item_size
-    mov rdx, rax
-    call memcpy
-
-    mov rax, [rbx + 8]      ; len
-    add rax, [rsp + 0x18]    ; len += count
-    mov [rbx + 8], rax
-
-    add rsp, 32
-    pop rbx
-    pop r12
-    pop rbp
-    ret
-
 
 ;; rdi: pointer to Vec struct
 ;; rsi: pointer to key

lang/tests/codegen.rs

@@ -66,7 +66,6 @@ fn main() {
                 nodes: util::vec::Vec::new(),
             };
             let expr_id = parser(&mut ast);
-            eprintln!("{}", core::str::from_utf8_unchecked(src));
             eprintln!("Parsed expression ID: {}", expr_id);
             let mut symtable = core::mem::MaybeUninit::<util::defs::SymbolTable>::uninit();
             util::defs::ast_build_symtable(&mut ast, expr_id, &mut symtable);
@@ -77,24 +76,27 @@ fn main() {
 
             let mut codegen = util::defs::CodegenCtx {
                 ast: &mut ast,
-                text: util::vec::Vec::new_with(1024),
+                text: util::vec::Vec::new(),
             };
 
             util::defs::codegen_function(&mut codegen, expr_id);
 
-            eprintln!("Code generation completed.");
-
             println!(
                 "Generated code:\n{}",
-                core::str::from_utf8_unchecked(codegen.text.as_slice())
+                core::str::from_utf8(codegen.text.as_slice()).unwrap()
             );
         };
     }
 
-    print_ast(
-        b"fn main(a: u32) -> void {
-    return 4;
-    }",
-        |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/int_to_str.rs

@@ -12,11 +12,6 @@ fn main() {
     let value = 1234567890isize;
     let mut buffer = [0u8; 32];
     unsafe {
-        let slice = int_to_str2(0, buffer.as_mut_ptr(), buffer.len(), 10);
-        let s = slice.as_str();
-        println!("Integer: {}, String: {}", 0, s);
-        assert_eq!(s, format!("{}", 0));
-
         let slice = int_to_str2(value, buffer.as_mut_ptr(), buffer.len(), 10);
         let s = slice.as_str();
         println!("Integer: {}, String: {}", value, s);

lang/tests/shared/defs.rs

@@ -19,10 +19,7 @@ unsafe extern "C" {
     pub unsafe fn ast_resolve_var_refs(ast: *mut Ast, ctx: *mut SymbolTable, root_index: u64);
     pub unsafe fn get_register_name(reg_idx: u8, width: u8, buffer: *mut u8) -> FFISlice;
     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_function(ast: *const CodegenCtx, func_idx: u64) -> ();
-    pub unsafe fn codegen_expr(ctx: *const CodegenCtx, function_ctx: &FunctionCtx, expr_idx: u64) -> (u64, bool);
-    pub unsafe fn vec_insert_many(vec: *mut BlobVec, index: usize, data: *const u8, count: usize);
     pub unsafe fn vec_extend(vec: *mut BlobVec, elements: *const u8, count: usize) -> ();
 }
 
@@ -53,13 +50,6 @@ pub const TYPE_I32: u8 = 3;
 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_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;
@@ -211,24 +201,6 @@ pub struct CodegenCtx {
     pub text: Vec<u8>,
 }
 
-#[repr(C)]
-#[derive(Debug)]
-pub struct FunctionCtx {
-    pub current_stack_size: u64,
-    pub stack_vars: Vec<(u64, u64)>,
-    pub register_bitset: u16,
-    pub dirtied_register_bitset: u16,
-}
-
-#[repr(C)]
-#[derive(Debug)]
-pub struct Operand {
-    pub kind: u8,
-    pub register_and_width: u8,
-    pub len: u16,
-    pub value: u64,
-}
-
 #[repr(C)]
 #[derive(Debug)]
 pub struct BlobVec {

lang/tests/shared/shared.rs

@@ -160,19 +160,6 @@ pub mod vec {
             }
         }
 
-        pub fn insert_many(&mut self, index: usize, elements: Box<[T]>) {
-            unsafe {
-                let elements =
-                    core::mem::transmute::<Box<[T]>, Box<[core::mem::ManuallyDrop<T>]>>(elements);
-                super::defs::vec_insert_many(
-                    &mut self.vec,
-                    index,
-                    elements.as_ptr() as *const u8,
-                    elements.len(),
-                );
-            }
-        }
-
         pub fn pop(&mut self) -> Option<T> {
             if self.vec.len == 0 {
                 return None;

lang/tests/vec.rs

@@ -113,9 +113,4 @@ fn main() {
     let elements = Box::new([1, 2, 3, 4, 5]);
     vec.extend(elements);
     assert_eq!(vec.as_slice(), &[50, 1, 2, 3, 4, 5]);
-
-    // vec insert_many
-    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]);
 }