1 files changed, 34 insertions, 27 deletions

diff --git a/src/compiler.c b/src/compiler.c
index bd50955..84cc99a 100644
--- a/src/compiler.c
+++ b/src/compiler.c
@@ -29,6 +29,11 @@ typedef union Constant {
     ptrsize ptr;
 } Constant;
 
+typedef struct LineCol {
+    sz line;
+    sz col;
+} LineCol;
+
 typedef struct Chunk {
     sz id;
     Instruction *code;
@@ -54,17 +59,17 @@ typedef struct Chunk {
     // Debugging.
     Str file_name;
     Arena *storage;
-    // TODO: line/col info for debugging.
+    LineCol *linecol;
 } Chunk;
 
 typedef enum OpCode {
     //            OP    DST   A   B
     // ---------------------------------------------------------------
     // VM/high level instructions.
-    OP_HALT,    // halt
-    OP_STVARI,  // stvari vx, ca
-    OP_STVAR,   // stvar  vx, ra
-    OP_LDVAR,   // ldvar  rx, vx
+    OP_HALT,     // halt
+    OP_STGVARI,  // stgvari vx, ca
+    OP_STGVAR,   // stgvar  vx, ra
+    OP_LDGVAR,   // ldgvar  rx, vx
     // Load/Store instructions.
     OP_LD8K,   // ld8k   rx, ca      -> u8  rx = ca
     OP_LD16K,  // ld16k  rx, ca      -> u16 rx = ca
@@ -147,9 +152,9 @@ typedef enum OpCode {
 
 Str op_str[] = {
     [OP_HALT] = cstr("HALT    "),
-    [OP_STVAR] = cstr("STVAR   "),
-    [OP_STVARI] = cstr("STVARI  "),
-    [OP_LDVAR] = cstr("LDVAR   "),
+    [OP_STGVAR] = cstr("STGVAR  "),
+    [OP_STGVARI] = cstr("STGVARI "),
+    [OP_LDGVAR] = cstr("LDGVAR  "),
     // Load ops.
     [OP_LD8K] = cstr("LD8K    "),
     [OP_LD16K] = cstr("LD16K   "),
@@ -245,15 +250,17 @@ typedef struct CompResult {
 
 CompResult compile_expr(Chunk *chunk, Node *node);
 
-#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); \
+#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);                     \
+        LineCol linecol = (LineCol){.line = (NODE)->line, .col = (NODE)->col}; \
+        array_push((CHUNK)->linecol, linecol, (CHUNK)->storage);               \
     } while (0)
 
 CompResult
@@ -512,11 +519,11 @@ compile_expr(Chunk *chunk, Node *node) {
                 CompResult res = compile_expr(chunk, node->var_val);
                 switch (res.type) {
                     case COMP_CONST: {
-                        EMIT_OP(OP_STVARI, idx, res.idx, 0, node->var_val,
+                        EMIT_OP(OP_STGVARI, idx, res.idx, 0, node->var_val,
                                 chunk);
                     } break;
                     case COMP_REG: {
-                        EMIT_OP(OP_STVAR, idx, res.idx, 0, node->var_val,
+                        EMIT_OP(OP_STGVAR, idx, res.idx, 0, node->var_val,
                                 chunk);
                     } break;
                     default: {
@@ -536,7 +543,7 @@ compile_expr(Chunk *chunk, Node *node) {
             }
             Variable var = map->val;
             u8 reg_dst = chunk->reg_idx++;
-            EMIT_OP(OP_LDVAR, reg_dst, var.idx, 0, node->var_val, chunk);
+            EMIT_OP(OP_LDGVAR, reg_dst, var.idx, 0, node, chunk);
             return (CompResult){.type = COMP_REG, .idx = reg_dst};
         } break;
         case NODE_BLOCK: {
@@ -639,15 +646,15 @@ disassemble_instruction(Instruction instruction) {
             println("%s r%d, r%d, r%d", op_str[instruction.op], instruction.dst,
                     instruction.a, instruction.b);
             break;
-        case OP_LDVAR:
+        case OP_LDGVAR:
             println("%s r%d, v%d", op_str[instruction.op], instruction.dst,
                     instruction.a, instruction.b);
             break;
-        case OP_STVAR:
+        case OP_STGVAR:
             println("%s v%d, r%d", op_str[instruction.op], instruction.dst,
                     instruction.a, instruction.b);
             break;
-        case OP_STVARI:
+        case OP_STGVARI:
             println("%s v%d, c%d", op_str[instruction.op], instruction.dst,
                     instruction.a, instruction.b);
             break;
@@ -668,26 +675,26 @@ disassemble_instruction(Instruction instruction) {
 
 void
 disassemble_chunk(Chunk chunk) {
-    println("%s: =========== code ===========", chunk.file_name);
+    println("%s: ============== code ==============", chunk.file_name);
     for (sz i = 0; i < array_size(chunk.code); i++) {
         print("%s: %x{4}:  ", chunk.file_name, i);
         disassemble_instruction(chunk.code[i]);
     }
     if (array_size(chunk.constants) > 0) {
-        println("%s: ========= constants ========", chunk.file_name);
+        println("%s: ============ constants ===========", chunk.file_name);
         for (sz i = 0; i < array_size(chunk.constants); i++) {
             println("%s: %x{2}:  %x{8}", chunk.file_name, i,
                     chunk.constants[i]);
         }
     }
     if (array_size(chunk.strings) > 0) {
-        println("%s: ========== strings =========", chunk.file_name);
+        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]);
         }
     }
     if (array_size(chunk.vars) > 0) {
-        println("%s: ========= variables ========", chunk.file_name);
+        println("%s: ============ variables ===========", chunk.file_name);
         for (sz i = 0; i < array_size(chunk.vars); i++) {
             println("%s: %x{2}: [%x{4}:%x{4}] %s: %s", chunk.file_name, i,
                     chunk.vars[i].offset,