4 files changed, 156 insertions, 91 deletions

diff --git a/src/compiler.c b/src/compiler.c
index a860a58..aeb6793 100644
--- a/src/compiler.c
+++ b/src/compiler.c
@@ -96,6 +96,7 @@ typedef enum OpCode {
     OP_STLVAR,   // stlvar  vx, ra
     OP_LDLVAR,   // ldlvar  rx, va
     OP_LDLADDR,  // ldladdr rx, va
+    OP_LDSTR,    // ldstr   rx, sa ; Stores the address of the string sa into rx
     // Functions.
     OP_CALL,     // call fx        ; Bumps the stack pointer by cx
     OP_RET,      // ret            ; Returns from current function
@@ -107,6 +108,7 @@ typedef enum OpCode {
     OP_PUTRETI,  // putreti cx     ; Put cx into the return value memory.
     // Printing values with builtin print/println functions.
     OP_PRINTSTR,   // p  rx
+    OP_PRINTSTRI,  // p  rx
     OP_PRINTS64,   // p  rx
     OP_PRINTF64,   // p  rx
     OP_PRINTS64I,  // p  cx
@@ -210,6 +212,7 @@ Str op_str[] = {
     [OP_STLVARI] = cstr("STLVARI "),
     [OP_LDLVAR] = cstr("LDLVAR  "),
     [OP_LDLADDR] = cstr("LDLADDR "),
+    [OP_LDSTR] = cstr("LDSTR   "),
     [OP_PRINTSTR] = cstr("PRNTSTR "),
     [OP_PRINTS64] = cstr("PRNTS64 "),
     [OP_PRINTF64] = cstr("PRNTF64 "),
@@ -328,22 +331,21 @@ typedef struct CompResult {
 
 CompResult compile_expr(Chunk *chunk, Node *node, sz lab_pre, sz lab_post);
 
-#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){0};                                  \
-        if (NODE) {                                                      \
-            Node *_node = (NODE);                                        \
-            linecol = (LineCol){.line = _node->line, .col = _node->col}; \
-        }                                                                \
-        array_push((CHUNK)->linecol, linecol, (CHUNK)->storage);         \
-    } while (0)
+void
+emit_op(OpCode op, sz dst, sz a, sz b, Node *node, Chunk *chunk) {
+    Instruction inst = (Instruction){
+        .op = op,
+        .dst = dst,
+        .a = a,
+        .b = b,
+    };
+    array_push(chunk->code, inst, chunk->storage);
+    LineCol linecol = (LineCol){0};
+    if (node) {
+        linecol = (LineCol){.line = node->line, .col = node->col};
+    }
+    array_push(chunk->linecol, linecol, chunk->storage);
+}
 
 CompResult
 compile_binary(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
@@ -462,7 +464,7 @@ compile_binary(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
     switch (comp_a.type) {
         case COMP_CONST: {
             reg_a = chunk->reg_idx++;
-            EMIT_OP(ldop, reg_a, comp_a.idx, 0, node, chunk);
+            emit_op(ldop, reg_a, comp_a.idx, 0, node, chunk);
         } break;
         case COMP_REG: {
             reg_a = comp_a.idx;
@@ -484,7 +486,7 @@ compile_binary(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
         } break;
     }
     sz reg_dst = chunk->reg_idx++;  // Better for optimization
-    EMIT_OP(op, reg_dst, reg_a, reg_b, node, chunk);
+    emit_op(op, reg_dst, reg_a, reg_b, node, chunk);
     return (CompResult){.type = COMP_REG, .idx = reg_dst};
 }
 
@@ -519,7 +521,7 @@ compile_unary(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
         } break;
     }
     sz reg_dst = chunk->reg_idx++;
-    EMIT_OP(op, reg_dst, reg_a, 0, node, chunk);
+    emit_op(op, reg_dst, reg_a, 0, node, chunk);
     return (CompResult){.type = COMP_REG, .idx = reg_dst};
 }
 
@@ -602,18 +604,18 @@ compile_if(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
 
         // Jump to the `false` branch.
         sz lab0 = chunk->labels_idx++;
-        EMIT_OP(jmpop, lab0, cond.idx, 0, node->ifelse.cond, chunk);
+        emit_op(jmpop, lab0, cond.idx, 0, node->ifelse.cond, chunk);
 
         // Condition is true.
         CompResult then_expr =
             compile_expr(chunk, node->ifelse.expr_true, lab_pre, lab_post);
         switch (then_expr.type) {
             case COMP_CONST: {
-                EMIT_OP(OP_LD64K, reg_dst, then_expr.idx, 0, node->ifelse.cond,
+                emit_op(OP_LD64K, reg_dst, then_expr.idx, 0, node->ifelse.cond,
                         chunk);
             } break;
             case COMP_REG: {
-                EMIT_OP(OP_MOV64, reg_dst, then_expr.idx, 0, node->ifelse.cond,
+                emit_op(OP_MOV64, reg_dst, then_expr.idx, 0, node->ifelse.cond,
                         chunk);
             } break;
             case COMP_RET: break;
@@ -625,18 +627,18 @@ compile_if(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
         // Jump to the end of the expression.
         sz pos0 = array_size(chunk->code);
         sz lab1 = chunk->labels_idx++;
-        EMIT_OP(OP_JMP, lab1, 0, 0, node->ifelse.expr_else, chunk);
+        emit_op(OP_JMP, lab1, 0, 0, node->ifelse.expr_else, chunk);
 
         // Else expression.
         CompResult else_expr =
             compile_expr(chunk, node->ifelse.expr_else, lab_pre, lab_post);
         switch (else_expr.type) {
             case COMP_CONST: {
-                EMIT_OP(OP_LD64K, reg_dst, else_expr.idx, 0,
+                emit_op(OP_LD64K, reg_dst, else_expr.idx, 0,
                         node->ifelse.expr_else, chunk);
             } break;
             case COMP_REG: {
-                EMIT_OP(OP_MOV64, reg_dst, else_expr.idx, 0,
+                emit_op(OP_MOV64, reg_dst, else_expr.idx, 0,
                         node->ifelse.expr_else, chunk);
             } break;
             case COMP_RET: break;
@@ -654,7 +656,7 @@ compile_if(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
 
     // Jump to the `false` branch.
     sz lab0 = chunk->labels_idx++;
-    EMIT_OP(jmpop, lab0, cond.idx, 0, node->ifelse.cond, chunk);
+    emit_op(jmpop, lab0, cond.idx, 0, node->ifelse.cond, chunk);
 
     // Condition is true.
     compile_expr(chunk, node->ifelse.expr_true, lab_pre, lab_post);
@@ -662,7 +664,7 @@ compile_if(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
     // Jump to the end of the expression.
     sz pos0 = array_size(chunk->code);
     sz lab1 = chunk->labels_idx++;
-    EMIT_OP(OP_JMP, lab1, 0, 0, node->ifelse.expr_else, chunk);
+    emit_op(OP_JMP, lab1, 0, 0, node->ifelse.expr_else, chunk);
 
     // Else expression.
     if (node->ifelse.expr_else) {
@@ -701,14 +703,14 @@ compile_cond(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
                 }
                 // Jump to the `next` branch.
                 sz lab0 = chunk->labels_idx++;
-                EMIT_OP(jmpop, lab0, cond.idx, 0, expr->case_entry.expr, chunk);
+                emit_op(jmpop, lab0, cond.idx, 0, expr->case_entry.expr, chunk);
 
                 // Condition is true.
                 compile_expr(chunk, expr->case_entry.expr, lab_pre, lab_post);
                 if (i != array_size(node->match.cases) - 1) {
                     // Jump to the end of the expression.
                     sz pos0 = array_size(chunk->code);
-                    EMIT_OP(OP_JMP, lab1, 0, 0, node->ifelse.expr_else, chunk);
+                    emit_op(OP_JMP, lab1, 0, 0, node->ifelse.expr_else, chunk);
                     intintmap_insert(&chunk->labels, lab0, pos0 + 1,
                                      chunk->storage);
                 }
@@ -744,18 +746,18 @@ compile_cond(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
             }
             // Jump to the `next` branch.
             sz lab0 = chunk->labels_idx++;
-            EMIT_OP(jmpop, lab0, cond.idx, 0, expr->case_entry.expr, chunk);
+            emit_op(jmpop, lab0, cond.idx, 0, expr->case_entry.expr, chunk);
 
             // Condition is true.
             CompResult then_expr =
                 compile_expr(chunk, expr->case_entry.expr, lab_pre, lab_post);
             switch (then_expr.type) {
                 case COMP_CONST: {
-                    EMIT_OP(OP_LD64K, reg_dst, then_expr.idx, 0,
+                    emit_op(OP_LD64K, reg_dst, then_expr.idx, 0,
                             expr->case_entry.expr, chunk);
                 } break;
                 case COMP_REG: {
-                    EMIT_OP(OP_MOV64, reg_dst, then_expr.idx, 0,
+                    emit_op(OP_MOV64, reg_dst, then_expr.idx, 0,
                             expr->case_entry.expr, chunk);
                 } break;
                 case COMP_RET: break;
@@ -766,7 +768,7 @@ compile_cond(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
             if (i != array_size(node->match.cases) - 1) {
                 // Jump to the end of the expression.
                 sz pos0 = array_size(chunk->code);
-                EMIT_OP(OP_JMP, lab1, 0, 0, node->ifelse.expr_else, chunk);
+                emit_op(OP_JMP, lab1, 0, 0, node->ifelse.expr_else, chunk);
                 intintmap_insert(&chunk->labels, lab0, pos0 + 1,
                                  chunk->storage);
             }
@@ -775,11 +777,11 @@ compile_cond(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
                 compile_expr(chunk, expr->case_entry.expr, lab_pre, lab_post);
             switch (then_expr.type) {
                 case COMP_CONST: {
-                    EMIT_OP(OP_LD64K, reg_dst, then_expr.idx, 0,
+                    emit_op(OP_LD64K, reg_dst, then_expr.idx, 0,
                             expr->case_entry.expr, chunk);
                 } break;
                 case COMP_REG: {
-                    EMIT_OP(OP_MOV64, reg_dst, then_expr.idx, 0,
+                    emit_op(OP_MOV64, reg_dst, then_expr.idx, 0,
                             expr->case_entry.expr, chunk);
                 } break;
                 case COMP_RET: break;
@@ -798,14 +800,14 @@ compile_cond(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
 CompResult
 compile_break(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
     (void)lab_pre;
-    EMIT_OP(OP_JMP, lab_post, 0, 0, node, chunk);
+    emit_op(OP_JMP, lab_post, 0, 0, node, chunk);
     return (CompResult){.type = COMP_NIL};
 }
 
 CompResult
 compile_continue(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
     (void)lab_post;
-    EMIT_OP(OP_JMP, lab_pre, 0, 0, node, chunk);
+    emit_op(OP_JMP, lab_pre, 0, 0, node, chunk);
     return (CompResult){.type = COMP_NIL};
 }
 
@@ -829,12 +831,12 @@ compile_while(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
     }
 
     // Jump to the `end of the loop` branch.
-    EMIT_OP(jmpop, lab0, cond.idx, 0, node->loop.cond, chunk);
+    emit_op(jmpop, lab0, cond.idx, 0, node->loop.cond, chunk);
 
     // Condition is true.
     compile_expr(chunk, node->loop.expr, lab1, lab0);
     sz pos0 = array_size(chunk->code);
-    EMIT_OP(OP_JMP, lab1, 0, 0, node, chunk);
+    emit_op(OP_JMP, lab1, 0, 0, node, chunk);
 
     // Update labels.
     intintmap_insert(&chunk->labels, lab0, pos0 + 1, chunk->storage);
@@ -856,10 +858,10 @@ compile_funcall(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
             if (str_eq(expr->type, cstr("int"))) {
                 switch (result.type) {
                     case COMP_CONST: {
-                        EMIT_OP(OP_PRINTS64I, result.idx, 0, 0, expr, chunk);
+                        emit_op(OP_PRINTS64I, result.idx, 0, 0, expr, chunk);
                     } break;
                     case COMP_REG: {
-                        EMIT_OP(OP_PRINTS64, result.idx, 0, 0, expr, chunk);
+                        emit_op(OP_PRINTS64, result.idx, 0, 0, expr, chunk);
                     } break;
                     default: {
                         return (CompResult){.type = COMP_ERR};
@@ -868,10 +870,10 @@ compile_funcall(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
             } else if (str_eq(expr->type, cstr("f64"))) {
                 switch (result.type) {
                     case COMP_CONST: {
-                        EMIT_OP(OP_PRINTF64I, result.idx, 0, 0, expr, chunk);
+                        emit_op(OP_PRINTF64I, result.idx, 0, 0, expr, chunk);
                     } break;
                     case COMP_REG: {
-                        EMIT_OP(OP_PRINTF64, result.idx, 0, 0, expr, chunk);
+                        emit_op(OP_PRINTF64, result.idx, 0, 0, expr, chunk);
                     } break;
                     default: {
                         return (CompResult){.type = COMP_ERR};
@@ -880,7 +882,10 @@ compile_funcall(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
             } else if (str_eq(expr->type, cstr("str"))) {
                 switch (result.type) {
                     case COMP_STRING: {
-                        EMIT_OP(OP_PRINTSTR, result.idx, 0, 0, expr, chunk);
+                        emit_op(OP_PRINTSTRI, result.idx, 0, 0, expr, chunk);
+                    } break;
+                    case COMP_REG: {
+                        emit_op(OP_PRINTSTR, result.idx, 0, 0, expr, chunk);
                     } break;
                     default: {
                         return (CompResult){.type = COMP_ERR};
@@ -890,7 +895,7 @@ compile_funcall(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
         }
         if (str_eq(name, cstr("println"))) {
             sz idx = add_string(chunk, cstr("\n"));
-            EMIT_OP(OP_PRINTSTR, idx, 0, 0, node, chunk);
+            emit_op(OP_PRINTSTRI, idx, 0, 0, node, chunk);
         }
         return (CompResult){.type = COMP_NIL};
     }
@@ -911,7 +916,7 @@ compile_funcall(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
     if (fun.return_arity > 0) {
         // Put the return data into a register
         sz ret_size = add_constant(chunk, 8);
-        EMIT_OP(OP_RESERVE, ret_size, 0, 0, node, chunk);
+        emit_op(OP_RESERVE, ret_size, 0, 0, node, chunk);
     }
 
     // Send parameters to the stack.
@@ -921,10 +926,10 @@ compile_funcall(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
         // TODO: Assuming all values are 8 bytes... again.
         switch (result.type) {
             case COMP_CONST: {
-                EMIT_OP(OP_PUSHI, result.idx, 0, 0, expr, chunk);
+                emit_op(OP_PUSHI, result.idx, 0, 0, expr, chunk);
             } break;
             case COMP_REG: {
-                EMIT_OP(OP_PUSH, result.idx, 0, 0, expr, chunk);
+                emit_op(OP_PUSH, result.idx, 0, 0, expr, chunk);
             } break;
             default: {
                 return (CompResult){.type = COMP_ERR};
@@ -932,13 +937,13 @@ compile_funcall(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
         }
     }
 
-    EMIT_OP(OP_CALL, fun.index, 0, 0, node, chunk);
+    emit_op(OP_CALL, fun.index, 0, 0, node, chunk);
 
     // Only one return parameter for now.
     if (fun.return_arity > 0) {
         // Put the return data into a register
         sz reg_dst = chunk->reg_idx++;
-        EMIT_OP(OP_POP, reg_dst, 0, 0, node, chunk);
+        emit_op(OP_POP, reg_dst, 0, 0, node, chunk);
         return (CompResult){.type = COMP_REG, .idx = reg_dst};
     }
 
@@ -955,10 +960,10 @@ compile_return(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
         // Put return values into memory.
         switch (res.type) {
             case COMP_CONST: {
-                EMIT_OP(OP_PUTRETI, res.idx, 0, 0, node, chunk);
+                emit_op(OP_PUTRETI, res.idx, 0, 0, node, chunk);
             } break;
             case COMP_REG: {
-                EMIT_OP(OP_PUTRET, res.idx, 0, 0, node, chunk);
+                emit_op(OP_PUTRET, res.idx, 0, 0, node, chunk);
             } break;
             default: {
                 return (CompResult){.type = COMP_ERR};
@@ -967,7 +972,7 @@ compile_return(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
         break;
     }
 
-    EMIT_OP(OP_RET, 0, 0, 0, node, chunk);
+    emit_op(OP_RET, 0, 0, 0, node, chunk);
     return (CompResult){.type = COMP_RET};
 }
 
@@ -1054,15 +1059,15 @@ compile_function(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
     // Put return values into memory.
     switch (res.type) {
         case COMP_CONST: {
-            EMIT_OP(OP_PUTRETI, res.idx, 0, 0, node, func);
+            emit_op(OP_PUTRETI, res.idx, 0, 0, node, func);
         } break;
         case COMP_REG: {
-            EMIT_OP(OP_PUTRET, res.idx, 0, 0, node, func);
+            emit_op(OP_PUTRET, res.idx, 0, 0, node, func);
         } break;
         default: break;
     }
 
-    EMIT_OP(OP_RET, 0, 0, 0, node, func);
+    emit_op(OP_RET, 0, 0, 0, node, func);
     verify_chunk(func);
     return (CompResult){.type = COMP_NIL};
 }
@@ -1130,9 +1135,11 @@ compile_expr(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
             };
         } break;
         case NODE_LET: {
+            u8 op_ldaddr = OP_LDGADDR;
             u8 op_stvari = OP_STGVARI;
             u8 op_stvar = OP_STGVAR;
             if (!str_eq(chunk->name, cstr(".main"))) {
+                op_ldaddr = OP_LDLADDR;
                 op_stvari = OP_STLVARI;
                 op_stvar = OP_STLVAR;
             }
@@ -1154,12 +1161,39 @@ compile_expr(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
                     compile_expr(chunk, node->var.val, lab_pre, lab_post);
                 switch (res.type) {
                     case COMP_CONST: {
-                        EMIT_OP(op_stvari, idx, res.idx, 0, node->var.val,
+                        emit_op(op_stvari, 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_stvar, idx, res.idx, 0, node->var.val,
+                                chunk);
+                    } break;
+                    case COMP_STRING: {
+                        sz reg_addr = chunk->reg_idx++;
+                        sz reg_str = chunk->reg_idx++;
+                        sz reg_val = chunk->reg_idx++;
+
+                        // Get the address for the local/global storage
+                        // variable.
+                        emit_op(op_ldaddr, reg_addr, idx, 0, node->var.name,
+                                chunk);
+
+                        // Get the address for the string value variable.
+                        emit_op(OP_LDSTR, reg_str, res.idx, 0, node->var.val,
+                                chunk);
+
+                        // Store the fat string pointer into the variable.
+                        sz zero = add_constant(chunk, 0);
+                        sz one = add_constant(chunk, 1);
+
+                        // Get the value for the first word of the string
+                        // pointer.
+                        emit_op(OP_LD64I, reg_val, reg_str, zero, node->var.val,
+                                chunk);
+                        emit_op(OP_ST64I, reg_val, reg_addr, zero, node, chunk);
+                        emit_op(OP_LD64I, reg_val, reg_str, one, node->var.val,
                                 chunk);
+                        emit_op(OP_ST64I, reg_val, reg_addr, one, node, chunk);
                     } break;
                     default: {
                         return (CompResult){.type = COMP_ERR};
@@ -1202,7 +1236,7 @@ compile_expr(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
                 switch (res.type) {
                     case COMP_CONST: {
                         reg_val = chunk->reg_idx++;
-                        EMIT_OP(OP_LD64K, reg_val, res.idx, 0, node, chunk);
+                        emit_op(OP_LD64K, reg_val, res.idx, 0, node, chunk);
                     } break;
                     case COMP_REG: {
                         reg_val = res.idx;
@@ -1216,10 +1250,10 @@ compile_expr(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
                 sz reg_addr = chunk->reg_idx++;
                 // Is this a pointer access or an array access?
                 if (str_has_prefix(map->val.type, cstr("[]"))) {
-                    EMIT_OP(op_ldaddr, reg_addr, map->val.idx, 0, node->var.val,
+                    emit_op(op_ldaddr, reg_addr, map->val.idx, 0, node->var.val,
                             chunk);
                 } else {
-                    EMIT_OP(op_ldvar, reg_addr, map->val.idx, 0, node->var.val,
+                    emit_op(op_ldvar, reg_addr, map->val.idx, 0, node->var.val,
                             chunk);
                 }
 
@@ -1228,11 +1262,11 @@ compile_expr(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
                     chunk, node->var.name->sym.arr_size, lab_pre, lab_post);
                 switch (idx.type) {
                     case COMP_CONST: {
-                        EMIT_OP(OP_ST64I, reg_val, reg_addr, idx.idx, node,
+                        emit_op(OP_ST64I, reg_val, reg_addr, idx.idx, node,
                                 chunk);
                     } break;
                     case COMP_REG: {
-                        EMIT_OP(OP_ST64, reg_val, reg_addr, idx.idx, node,
+                        emit_op(OP_ST64, reg_val, reg_addr, idx.idx, node,
                                 chunk);
                     } break;
                     default: {
@@ -1245,11 +1279,11 @@ compile_expr(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
             }
             switch (res.type) {
                 case COMP_CONST: {
-                    EMIT_OP(op_stvari, map->val.idx, res.idx, 0, node->var.val,
+                    emit_op(op_stvari, map->val.idx, res.idx, 0, node->var.val,
                             chunk);
                 } break;
                 case COMP_REG: {
-                    EMIT_OP(op_stvar, map->val.idx, res.idx, 0, node->var.val,
+                    emit_op(op_stvar, map->val.idx, res.idx, 0, node->var.val,
                             chunk);
                 } break;
                 default: {
@@ -1282,10 +1316,11 @@ compile_expr(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
             }
             Variable var = map->val;
             u8 reg_dst = chunk->reg_idx++;
-            if (node->is_ptr || str_has_prefix(var.type, cstr("[]"))) {
-                EMIT_OP(op_ldaddr, reg_dst, var.idx, 0, node, chunk);
+            if (node->is_ptr || str_has_prefix(var.type, cstr("[]")) ||
+                str_eq(var.type, cstr("str"))) {
+                emit_op(op_ldaddr, reg_dst, var.idx, 0, node, chunk);
             } else {
-                EMIT_OP(op_ldvar, reg_dst, var.idx, 0, node, chunk);
+                emit_op(op_ldvar, reg_dst, var.idx, 0, node, chunk);
             }
             return (CompResult){.type = COMP_REG, .idx = reg_dst};
         } break;
@@ -1317,10 +1352,10 @@ compile_expr(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
             // Address.
             sz reg_addr = chunk->reg_idx++;
             if (str_has_prefix(map->val.type, cstr("[]"))) {
-                EMIT_OP(op_ldaddr, reg_addr, map->val.idx, 0, node->var.val,
+                emit_op(op_ldaddr, reg_addr, map->val.idx, 0, node->var.val,
                         chunk);
             } else {
-                EMIT_OP(op_ldvar, reg_addr, map->val.idx, 0, node->var.val,
+                emit_op(op_ldvar, reg_addr, map->val.idx, 0, node->var.val,
                         chunk);
             }
 
@@ -1329,10 +1364,10 @@ compile_expr(Chunk *chunk, Node *node, sz lab_pre, sz lab_post) {
                 compile_expr(chunk, node->sym.arr_size, lab_pre, lab_post);
             switch (idx.type) {
                 case COMP_CONST: {
-                    EMIT_OP(OP_LD64I, reg_dst, reg_addr, idx.idx, node, chunk);
+                    emit_op(OP_LD64I, reg_dst, reg_addr, idx.idx, node, chunk);
                 } break;
                 case COMP_REG: {
-                    EMIT_OP(OP_LD64, reg_dst, reg_addr, idx.idx, node, chunk);
+                    emit_op(OP_LD64, reg_dst, reg_addr, idx.idx, node, chunk);
                 } break;
                 default: {
                     return (CompResult){.type = COMP_ERR};
@@ -1459,6 +1494,10 @@ disassemble_instruction(Instruction instruction) {
             println("%s r%d, v%d", op_str[instruction.op], instruction.dst,
                     instruction.a, instruction.b);
             break;
+        case OP_LDSTR:
+            println("%s r%d, s%d", op_str[instruction.op], instruction.dst,
+                    instruction.a, instruction.b);
+            break;
         case OP_STGVAR:
         case OP_STLVAR:
             println("%s v%d, r%d", op_str[instruction.op], instruction.dst,
@@ -1491,6 +1530,7 @@ disassemble_instruction(Instruction instruction) {
         case OP_PRINTS64:
         case OP_PRINTF64:
         case OP_PRINTSTR:
+        case OP_PRINTSTRI:
         case OP_PUSH:
         case OP_POP:
         case OP_PUTRET:
diff --git a/src/main.c b/src/main.c
index 9f687ff..8e6b6c6 100644
--- a/src/main.c
+++ b/src/main.c
@@ -24,7 +24,13 @@
 //      add(12, 34) == 12.add(34)
 //      concat(str, str): str
 //      "hello ".concat("world") ; "hello world"
-// TODO: more types
+// TODO: more integer types
+// TODO: string types
+// TODO: structs and user defined types
+// TODO: tail-call optimization.
+// TODO: constant folding
+// TODO: constexpr evaluation
+// TODO: shortcircuit evaluation for && and || operators.
 
 typedef enum ExecMode {
     RUN_NORMAL,
@@ -227,7 +233,7 @@ process_file(Str path) {
         } break;
         default: break;
     }
-    EMIT_OP(OP_HALT, res_reg, !is_nil, 0, NULL, &chunk);
+    emit_op(OP_HALT, res_reg, !is_nil, 0, NULL, &chunk);
     verify_chunk(&chunk);
 
     disassemble_chunk(chunk);
diff --git a/src/vm.c b/src/vm.c
index f363e26..404f410 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -196,8 +196,14 @@ vm_run(VM *vm) {
                 Variable var = vm->chunk->vars[src];
                 vm->regs[dst].i = (ptrsize)&vm->fp[var.offset / 8];
             } break;
+            case OP_LDSTR: {
+                u8 dst = instruction.dst;
+                u8 src = instruction.a;
+                Str *str = &vm->chunk->strings[src];
+                vm->regs[dst].ptr = (ptrsize)str;
+            } break;
             case OP_ST64I: {
-                sz value = vm->regs[instruction.dst].i;
+                sz value = vm->regs[instruction.dst].ptr;
                 s64 *addr = (s64 *)vm->regs[instruction.a].ptr;
                 sz offset = vm->chunk->constants[instruction.b].i;
                 addr[offset] = value;
@@ -293,6 +299,11 @@ vm_run(VM *vm) {
             } break;
             case OP_PRINTSTR: {
                 u8 idx = instruction.dst;
+                Str *string = (Str*)vm->regs[idx].ptr;
+                print("%s", *string);
+            } break;
+            case OP_PRINTSTRI: {
+                u8 idx = instruction.dst;
                 Str string = vm->chunk->strings[idx];
                 print("%s", string);
             } break;
diff --git a/tests/compilation.bad b/tests/compilation.bad
index 09bfa3c..b1fec85 100644
--- a/tests/compilation.bad
+++ b/tests/compilation.bad
@@ -1,18 +1,26 @@
-fun printer(): nil println("hey!")
+let name = "hello"
+; let wow = name
+; let greeting = "yomama"
 
-let y = 4
-fun nested(): nil {
-    fun adder(a: int b: int): int {
-        fun printer(): nil println("ho!")
-        printer()
-        printer()
-        printer()
-        y + a + b
-    }
-    for let i = 0, i < 10, set i += 1 {
-        println("i: " i " " adder(i, 2))
-    }
-}
+println(name wow)
 
-nested()
-printer()
+; fun greet(name: str): nil println("hello " name "!")
+
+; greet(name)
+
+; let y = 4
+; fun nested(): nil {
+;     fun adder(a: int b: int): int {
+;         fun printer(): nil println("ho!")
+;         printer()
+;         printer()
+;         printer()
+;         y + a + b
+;     }
+;     for let i = 0, i < 10, set i += 1 {
+;         println("i: " i " " adder(i, 2))
+;     }
+; }
+
+; nested()
+; printer()