1 files changed, 65 insertions, 25 deletions

diff --git a/src/vm.c b/src/vm.c
index 574f4fa..cb1b6cd 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -17,10 +17,22 @@ typedef union Constant {
 
 typedef struct Chunk {
     Instruction *code;
+
+    // Constant values that fit in 64 bits.
     Constant *constants;
-    Str file_name;
-    sz reg_idx;
+    IntIntMap *intmap;
     sz const_idx;
+
+    // Constant strings.
+    Str *strings;
+    StrIntMap *strmap;
+    sz str_idx;
+
+    // Number of registers currently used in this chunk.
+    sz reg_idx;
+
+    // Debugging.
+    Str file_name;
     Arena *storage;
     // TODO: line/col info for debugging.
 } Chunk;
@@ -205,6 +217,12 @@ disassemble_chunk(Chunk chunk) {
                     chunk.constants[i]);
         }
     }
+    if (array_size(chunk.strings) > 0) {
+        println("%s: ========== strings =========", chunk.file_name);
+        for (sz i = 0; i < array_size(chunk.strings); i++) {
+            println("%s: %x{2}:  %s", chunk.file_name, i, chunk.strings[i]);
+        }
+    }
 }
 
 #define N_CONST 256
@@ -292,6 +310,7 @@ vm_run(VM *vm) {
 
 typedef enum {
     COMP_CONST,
+    COMP_STRING,
     COMP_REG,
     COMP_ERR,
 } CompResultType;
@@ -303,11 +322,19 @@ typedef struct CompResult {
 
 CompResult compile_expr(Chunk *chunk, Node *node);
 
-// #define EMIT_OP(OP, CHUNK, ARENA)
+#define EMIT_OP(OP, DST, A, B, NODE, CHUNK)                \
+    do {                                                   \
+        Instruction inst = (Instruction){                  \
+            .op = (OP),                                    \
+            .dst = (DST),                                  \
+            .a = (A),                                      \
+            .b = (B),                                      \
+        };                                                 \
+        array_push((CHUNK)->code, inst, (CHUNK)->storage); \
+    } while (0)
 
 CompResult
 compile_binary(OpCode op, Chunk *chunk, Node *node) {
-    sz reg_dst = chunk->reg_idx++;
     CompResult comp_a = compile_expr(chunk, node->left);
     CompResult comp_b = compile_expr(chunk, node->right);
     sz reg_a;
@@ -315,9 +342,7 @@ compile_binary(OpCode op, Chunk *chunk, Node *node) {
     switch (comp_a.type) {
         case COMP_CONST: {
             reg_a = chunk->reg_idx++;
-            Instruction inst =
-                (Instruction){.op = OP_LD64K, .dst = reg_a, .a = comp_a.idx};
-            array_push(chunk->code, inst, chunk->storage);
+            EMIT_OP(OP_LD64K, reg_a, comp_a.idx, 0, node, chunk);
         } break;
         case COMP_REG: {
             reg_a = comp_a.idx;
@@ -329,9 +354,7 @@ compile_binary(OpCode op, Chunk *chunk, Node *node) {
     switch (comp_b.type) {
         case COMP_CONST: {
             reg_b = chunk->reg_idx++;
-            Instruction inst =
-                (Instruction){.op = OP_LD64K, .dst = reg_b, .a = comp_b.idx};
-            array_push(chunk->code, inst, chunk->storage);
+            EMIT_OP(OP_LD64K, reg_b, comp_b.idx, 0, node, chunk);
         } break;
         case COMP_REG: {
             reg_b = comp_b.idx;
@@ -340,9 +363,9 @@ compile_binary(OpCode op, Chunk *chunk, Node *node) {
             return (CompResult){.type = COMP_ERR};
         } break;
     }
-    Instruction inst =
-        (Instruction){.op = op, .dst = reg_dst, .a = reg_a, .b = reg_b};
-    array_push(chunk->code, inst, chunk->storage);
+    sz reg_dst = comp_a.idx;  // Less registers
+    // sz reg_dst = chunk->reg_idx++; // Better for optimization
+    EMIT_OP(op, reg_dst, reg_a, reg_b, node, chunk);
     return (CompResult){.type = COMP_REG, .idx = reg_dst};
 }
 
@@ -354,26 +377,43 @@ compile_expr(Chunk *chunk, Node *node) {
         case NODE_MUL: return compile_binary(OP_MUL, chunk, node); break;
         case NODE_DIV: return compile_binary(OP_DIV, chunk, node); break;
         case NODE_MOD: return compile_binary(OP_MOD, chunk, node); break;
+        case NODE_TRUE:
+        case NODE_FALSE:
         case NODE_NUM_FLOAT:
         case NODE_NUM_INT: {
+            sz value = node->value.i;
             // Make sure we don't have duplicated constants.
-            for (sz i = 0; i < chunk->const_idx; i++) {
-                if (node->value.i == chunk->constants[i].i) {
-                    return (CompResult){
-                        .type = COMP_CONST,
-                        .idx = i,
-                    };
-                }
+            IntIntMap *map = intintmap_lookup(&chunk->intmap, value);
+            if (!map) {
+                map = intintmap_insert(&chunk->intmap, value,
+                                       chunk->const_idx++, chunk->storage);
+                Constant c = (Constant){.i = node->value.i};
+                array_push(chunk->constants, c, chunk->storage);
             }
-            Constant c = (Constant){.i = node->value.i};
-            array_push(chunk->constants, c, chunk->storage);
             return (CompResult){
                 .type = COMP_CONST,
-                .idx = chunk->const_idx++,
+                .idx = map->val,
+            };
+        } break;
+        case NODE_STRING: {
+            Str string = node->value.str;
+            // Make sure we don't have duplicated strings.
+            StrIntMap *map = strintmap_lookup(&chunk->strmap, string);
+            if (!map) {
+                map = strintmap_insert(&chunk->strmap, string, chunk->str_idx++,
+                                       chunk->storage);
+                array_push(chunk->strings, string, chunk->storage);
+            }
+            return (CompResult){
+                .type = COMP_STRING,
+                .idx = map->val,
             };
         } break;
-        default: break;
+        default: {
+            eprintln("error: compilation not implemented for node %s",
+                     node_str[node->kind]);
+            exit(EXIT_FAILURE);
+        } break;
     }
     return (CompResult){.type = COMP_ERR};
 }
-