1 files changed, 44 insertions, 52 deletions

diff --git a/src/main.c b/src/main.c
index 618d325..65c05ff 100644
--- a/src/main.c
+++ b/src/main.c
@@ -12,7 +12,26 @@
 // 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).
+// TODO: fix semantics for the following expression:
+//      let b = int
+// a type shouldn't be a valid symbol name
+// TODO: consider making all tye types PascalCase: Int F64 Str...
+// TODO: add a `const` keyword that can only take literals or constexpr values.
+// 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: more numeric types
+// TODO: structs and user defined types
+// TODO: tail-call optimization.
+// TODO: constant folding
+// TODO: constexpr evaluation
+// TODO: shortcircuit evaluation for && and || operators.
+// TODO: casting on demand (1:u16, 0x123:ptr, "hi":int ??? how to deal with
+// unsafe casts?)
 
 typedef enum ExecMode {
     RUN_NORMAL,
@@ -44,6 +63,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 +89,9 @@ process_file(Str path) {
     }
 
     // Parser.
+#if DEBUG == 1
+    println("parsing...");
+#endif
     Parser parser = {
         .tokens = tokens,
         .storage = &lexer_arena,
@@ -94,6 +119,9 @@ process_file(Str path) {
     }
 
     // Semantic analysis.
+#if DEBUG == 1
+    println("semantic analysis...");
+#endif
     Analyzer analyzer = (Analyzer){
         .storage = &lexer_arena,
         .file_name = path,
@@ -166,63 +194,27 @@ process_file(Str path) {
     // 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;
-    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,
+        .numeric_types = analyzer.numeric_types,
+    };
+    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}",
+#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);