1 files changed, 71 insertions, 58 deletions

diff --git a/src/main.c b/src/main.c
index 0e453c6..1ede868 100644
--- a/src/main.c
+++ b/src/main.c
@@ -12,7 +12,49 @@
 // TODO: unions
 // TODO: embed (binary file) and include (source file)
 // TODO: revisit ast parsing for pointers and arrays (I think I'm missing corner
-// cases).
+//       cases):
+//           []Int vs Int[], @sym vs sym@. On the right dereference, on the left
+//           declaration or taking the address/reference of a variable. Similar
+//           to what Odin does.
+//           let a: @Int            ; pointer to int
+//           let b: @@Int           ; pointer to pointer to int (etc.)
+//           let c: [123]Int        ; static array  -> @Int
+//           let m: [32][32]Int     ; multi-dimensional-arrays
+//           let d: []Int           ; slice / view  -> struct Slice { u8* mem ; sz size ; }
+//           let e: [...]Int        ; dynamic array -> struct DArry { u8* mem ; sz size ; sz cap ; }
+//           let f: [123]@Int       ; static array of int pointers [](@Int)
+//           let g: @[123]Int       ; pointer to a static array of integers @([123]Int)
+//           let h: #[Str:Int]      ; Hash map of string keys and integer values
+//           let i: #[Str:@Int]     ; Hash map of string keys and pointers to integer
+//           let j: #[@Str:Int]     ; Hash map of string pointers to integers
+//           let k: @#[Str:Int]     ; Pointer to a hash map of string to ints
+//           let l: (Int Int : Int) ; Function pointer ==  @(fun(Int,Int):Int)
+// TODO: constexpr or const expressions could be evaluated with the bytecode
+//       interpreter if we are performing compilation.
+// TODO: "first class functions" via function pointers
+// TODO: convenient function calls per data type instead of methods:
+//      fun add(a: int, b: int): int a + b
+//      add(12, 34) == 12.add(34)
+//      concat(str, str): str
+//      "hello ".concat("world") ; "hello world"
+// TODO: structs and user defined types
+// TODO: constant folding
+// TODO: casting on demand (1:u16, 0x123:ptr, "hi":int ??? how to deal with
+//       unsafe casts?)
+// TODO: extract table generation from compiler into the semantic analyzer,
+//       compiler should only focus on translating things to bytecode/linear ir.
+// TODO: sizeof function doesn't work well for arrays and variables.
+// TODO: store more parameters for variables, for example
+// TODO: don't allow overwriting default types with other symbols within a scope
+//      {
+//           let Int = 0.0
+//      }
+// TODO: This shouldn't be possible
+//     let b = 4
+//     let a: [32]U8 = @b
+// TODO: Properly reference and dereference multiple chains of arrays:
+// let a: [32][32]Int ; The size is not correct at the moment for this.
+// a[1][2] ?
 
 typedef enum ExecMode {
     RUN_NORMAL,
@@ -44,6 +86,9 @@ process_file(Str path) {
     sz errors = 0;
 
     // Lexer.
+#if DEBUG == 1
+    println("lexing...");
+#endif
     Scanner scanner = {.str = file.data};
     Token *tokens = NULL;
     Token tok = {0};
@@ -67,6 +112,9 @@ process_file(Str path) {
     }
 
     // Parser.
+#if DEBUG == 1
+    println("parsing...");
+#endif
     Parser parser = {
         .tokens = tokens,
         .storage = &lexer_arena,
@@ -80,9 +128,6 @@ process_file(Str path) {
         println("ROOT: %d", ctr++);
 #endif
         parse_expr(&parser, PREC_LOW);
-        if (parser.panic) {
-            break;
-        }
     }
     parse_consume(&parser, TOK_EOF, cstr("expected end of file"));
     if (parser.err) {
@@ -94,6 +139,9 @@ process_file(Str path) {
     }
 
     // Semantic analysis.
+#if DEBUG == 1
+    println("semantic analysis...");
+#endif
     Analyzer analyzer = (Analyzer){
         .storage = &lexer_arena,
         .file_name = path,
@@ -163,66 +211,31 @@ process_file(Str path) {
     }
 #endif
 
-    // TODO: Type checking.
-
     // Compile roots.
+#if DEBUG == 1
+    println("compilation...");
+#endif
     Arena bytecode_arena = arena_create(LEXER_MEM, os_allocator);
-    Chunk chunk = {.file_name = path, .storage = &bytecode_arena};
-    array_zero(chunk.constants, 256, &bytecode_arena);
-    array_zero(chunk.code, 0xffff, &bytecode_arena);
-    sz n_roots = array_size(parser.nodes);
-    CompResult res = {0};
-    for (sz i = 0; i < n_roots; i++) {
-        // The parser stores the root nodes as a stack.
-        Node *root = parser.nodes[i];
-        res = compile_expr(&chunk, root);
-        if (res.type == COMP_ERR) {
-            eprintln("compilation error...");
-            exit(EXIT_FAILURE);
-        }
-    }
-    sz res_reg = 0;
-    switch (res.type) {
-        case COMP_CONST: {
-            res_reg = chunk.reg_idx++;
-            Instruction inst =
-                (Instruction){.op = OP_LD64K, .dst = res_reg, .a = res.idx};
-            array_push(chunk.code, inst, chunk.storage);
-        } break;
-        case COMP_REG: {
-            res_reg = res.idx;
-        } break;
-        default: break;
-    }
-    // After we are done move the last result to r0 for printing.
-    Instruction halt = (Instruction){.op = OP_HALT, .dst = res_reg};
-    array_push(chunk.code, halt, &bytecode_arena);
-
-    if (chunk.const_idx >= 256) {
-        eprintln("too many constants on chunk %s", chunk.id);
-        exit(EXIT_FAILURE);
-    }
-    if (chunk.str_idx >= 256) {
-        eprintln("too many strings on chunk %s", chunk.id);
-        exit(EXIT_FAILURE);
-    }
-    if (chunk.reg_idx >= 256) {
-        eprintln("too many registers used on chunk %s", chunk.id);
-        exit(EXIT_FAILURE);
-    }
-
-    disassemble_chunk(chunk);
+    Compiler compiler = {
+        .file_name = path,
+        .storage = &bytecode_arena,
+        .integer_types = analyzer.integer_types,
+        .float_types = analyzer.float_types,
+        .numeric_types = analyzer.numeric_types,
+        .lab_pre = -1,
+        .lab_post = -1,
+    };
+    bytecode_compiler(&compiler, parser);
+    disassemble_chunk(compiler.main_chunk);
 
     // Run bytecode on VM.
     VM vm = {0};
-    vm_init(&vm, &chunk);
-    // println("VM REGISTERS BEFORE:\n%{Mem}",
-    //         &(Array){.mem = (u8 *)&vm.regs, sizeof(vm.regs)});
+    vm_init(&vm, &compiler.main_chunk);
     vm_run(&vm);
-    // println("VM REGISTERS AFTER:\n%{Mem}",
-    //         &(Array){.mem = (u8 *)&vm.regs, sizeof(vm.regs)});
-    // println("VM MEMORY AFTER:\n%{Mem}",
-    //         &(Array){.mem = (u8 *)&vm.stack, sizeof(vm.stack)});
+#if DEBUG == 1
+    println("MEMORY:\n%{Mem}",
+            &(Array){.mem = (u8 *)&vm.stack, sizeof(vm.stack)});
+#endif
 
 #if DEBUG == 1
     println("Space used: %{Arena}", &lexer_arena);