1 files changed, 16 insertions, 120 deletions

diff --git a/src/vm.c b/src/vm.c
index 2771d07..556fbe9 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -4,130 +4,12 @@
 #include "badlib.h"
 #include "compiler.c"
 
-void
-disassemble_instruction(Instruction instruction) {
-    switch (instruction.op) {
-        case OP_MOV8:
-        case OP_MOV16:
-        case OP_MOV32:
-        case OP_MOV64:
-            println("%s r%d, r%d", op_str[instruction.op], instruction.dst,
-                    instruction.a, instruction.b);
-            break;
-        case OP_LD8K:
-        case OP_LD16K:
-        case OP_LD32K:
-        case OP_LD64K:
-            println("%s r%d, c%d", op_str[instruction.op], instruction.dst,
-                    instruction.a, instruction.b);
-            break;
-        case OP_LD8I:
-        case OP_LD16I:
-        case OP_LD32I:
-        case OP_LD64I:
-        case OP_ST8I:
-        case OP_ST16I:
-        case OP_ST32I:
-        case OP_ST64I:
-        case OP_ADDI:
-        case OP_SUBI:
-        case OP_MULI:
-        case OP_DIVI:
-        case OP_MODI:
-        case OP_ADDFI:
-        case OP_SUBFI:
-        case OP_MULFI:
-        case OP_DIVFI:
-        case OP_MODFI:
-        case OP_EQI:
-        case OP_NEQI:
-        case OP_LTI:
-        case OP_GTI:
-        case OP_LEI:
-        case OP_GEI:
-        case OP_ANDI:
-        case OP_ORI:
-        case OP_BITLSHIFTI:
-        case OP_BITRSHIFTI:
-        case OP_BITANDI:
-        case OP_BITORI:
-            println("%s r%d, r%d, c%d", op_str[instruction.op], instruction.dst,
-                    instruction.a, instruction.b);
-            break;
-        case OP_LD8:
-        case OP_LD16:
-        case OP_LD32:
-        case OP_LD64:
-        case OP_ST8:
-        case OP_ST16:
-        case OP_ST32:
-        case OP_ST64:
-        case OP_ADD:
-        case OP_SUB:
-        case OP_MUL:
-        case OP_DIV:
-        case OP_MOD:
-        case OP_ADDF:
-        case OP_SUBF:
-        case OP_MULF:
-        case OP_DIVF:
-        case OP_MODF:
-        case OP_EQ:
-        case OP_NEQ:
-        case OP_LT:
-        case OP_GT:
-        case OP_LE:
-        case OP_GE:
-        case OP_AND:
-        case OP_OR:
-        case OP_BITLSHIFT:
-        case OP_BITRSHIFT:
-        case OP_BITAND:
-        case OP_BITOR:
-            println("%s r%d, r%d, r%d", op_str[instruction.op], instruction.dst,
-                    instruction.a, instruction.b);
-            break;
-        case OP_BITNOTI:
-        case OP_NOTI:
-            println("%s r%d, c%d", op_str[instruction.op], instruction.dst,
-                    instruction.a, instruction.b);
-            break;
-        case OP_BITNOT:
-        case OP_NOT:
-            println("%s r%d, r%d", op_str[instruction.op], instruction.dst,
-                    instruction.a, instruction.b);
-            break;
-        case OP_HALT: println("%s", op_str[instruction.op]); break;
-        default: println("Unknown opcode %d", instruction.op); break;
-    }
-}
-
-void
-disassemble_chunk(Chunk chunk) {
-    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);
-        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);
-        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
+#define STACK_SIZE KB(64)
 typedef struct VM {
     Chunk *chunk;
     Constant regs[N_CONST];
+    u8 stack[STACK_SIZE];
     Instruction *ip;
 } VM;
 
@@ -252,6 +134,20 @@ vm_run(VM *vm) {
                 vm->regs[dst].f =
                     fmod(vm->regs[src_a].f, vm->chunk->constants[src_b].f);
             } break;
+            case OP_STVAR: {
+                u8 dst = instruction.dst;
+                u8 src = instruction.a;
+                Variable var = vm->chunk->vars[dst];
+                s64 *stack = (s64*)&vm->stack[var.offset];
+                *stack = vm->regs[src].i;
+            } break;
+            case OP_STVARI: {
+                u8 dst = instruction.dst;
+                u8 src = instruction.a;
+                Variable var = vm->chunk->vars[dst];
+                s64 *stack = (s64*)&vm->stack[var.offset];
+                *stack = vm->chunk->constants[src].i;
+            } break;
             case OP_HALT: {
                 println("VM HALT (int)   -> %d", vm->regs[instruction.dst]);
                 println("VM HALT (float) -> %f", vm->regs[instruction.dst]);