Refactored all OP_ functions to vm/CATEGORY/ and renamed the files.

src/vm/core/call.c

@@ -0,0 +1,25 @@
+case OP_CALL: {
+    int argc = inst.operand;
+    if (argc < 0) argc = 0;
+    /* collect args in reverse (preserve order) */
+    Value *args = NULL;
+    if (argc > 0) {
+        args = (Value*)malloc(sizeof(Value) * argc);
+        /* pop args into array in reverse */
+        for (int i = argc - 1; i >= 0; --i) {
+            args[i] = pop_value(vm);
+        }
+    }
+    /* pop function value */
+    Value fnv = pop_value(vm);
+    if (fnv.type != VAL_FUNCTION) {
+        fprintf(stderr, "Runtime type error: CALL expects function\n");
+        exit(1);
+    }
+    /* push new frame and transfer args */
+    vm_push_frame(vm, fnv.fn, argc, args);
+    /* free args array (locals moved), free fnv (no-op for function) */
+    free(args);
+    /* note: fnv contains a pointer to the Bytecode, don't free here */
+    break;
+}

src/vm/core/dup.c

@@ -0,0 +1,9 @@
+case OP_DUP: {
+    if (vm->sp < 0) {
+        fprintf(stderr, "Runtime error: stack underflow for DUP\n");
+        exit(1);
+    }
+    Value top = vm->stack[vm->sp];
+    push_value(vm, copy_value(&top));
+    break;
+}

src/vm/core/halt.c

@@ -0,0 +1,2 @@
+case OP_HALT:
+    return;

src/vm/core/jump.c

@@ -0,0 +1,4 @@
+case OP_JUMP: {
+    f->ip = inst.operand;
+    break;
+}

src/vm/core/jump_if_false.c

@@ -0,0 +1,9 @@
+case OP_JUMP_IF_FALSE: {
+    Value cond = pop_value(vm);
+    int truthy = value_is_truthy(&cond);
+    free_value(cond);
+    if (!truthy) {
+        f->ip = inst.operand;
+    }
+    break;
+}

src/vm/core/load_const.c

@@ -0,0 +1,10 @@
+case OP_LOAD_CONST: {
+    int idx = inst.operand;
+    if (idx < 0 || idx >= f->fn->const_count) {
+        fprintf(stderr, "Runtime error: constant index out of range\n");
+        exit(1);
+    }
+    Value c = copy_value(&f->fn->constants[idx]);
+    push_value(vm, c);
+    break;
+}

src/vm/core/load_global.c

@@ -0,0 +1,12 @@
+case OP_LOAD_GLOBAL: {
+    int idx = inst.operand;
+    if (idx < 0 || idx >= VM_MAX_GLOBALS) {
+        fprintf(stderr, "Runtime error: global index out of range\n");
+        exit(1);
+    }
+#ifdef FUN_DEBUG
+    fprintf(stderr, "DEBUG LOAD_GLOBAL[%d]: type=%d\n", idx, vm->globals[idx].type);
+#endif
+    push_value(vm, copy_value(&vm->globals[idx]));
+    break;
+}

src/vm/core/load_local.c

@@ -0,0 +1,10 @@
+case OP_LOAD_LOCAL: {
+    int slot = inst.operand;
+    if (slot < 0 || slot >= FRAME_MAX_LOCALS) {
+        fprintf(stderr, "Runtime error: local slot out of range\n");
+        exit(1);
+    }
+    Value val = copy_value(&f->locals[slot]);
+    push_value(vm, val);
+    break;
+}

src/vm/core/nop.c

@@ -0,0 +1,2 @@
+case OP_NOP:
+    break;

src/vm/core/pop.c

@@ -0,0 +1,9 @@
+case OP_POP: {
+    if (vm->sp < 0) {
+        fprintf(stderr, "Runtime error: stack underflow for POP\n");
+        exit(1);
+    }
+    Value v = pop_value(vm);
+    free_value(v);
+    break;
+}

src/vm/core/return.c

@@ -0,0 +1,8 @@
+case OP_RETURN: {
+    Value retv;
+    if (vm->sp >= 0) retv = pop_value(vm);
+    else retv = make_nil();
+    vm_pop_frame(vm);
+    push_value(vm, retv);
+    break;
+}

src/vm/core/store_global.c

@@ -0,0 +1,14 @@
+case OP_STORE_GLOBAL: {
+    int idx = inst.operand;
+    if (idx < 0 || idx >= VM_MAX_GLOBALS) {
+        fprintf(stderr, "Runtime error: global index out of range\n");
+        exit(1);
+    }
+    Value v = pop_value(vm);
+#ifdef FUN_DEBUG
+    fprintf(stderr, "DEBUG STORE_GLOBAL[%d]: new.type=%d\n", idx, v.type);
+#endif
+    free_value(vm->globals[idx]);
+    vm->globals[idx] = v;
+    break;
+}

src/vm/core/store_local.c

@@ -0,0 +1,12 @@
+case OP_STORE_LOCAL: {
+    int slot = inst.operand;
+    if (slot < 0 || slot >= FRAME_MAX_LOCALS) {
+        fprintf(stderr, "Runtime error: local slot out of range\n");
+        exit(1);
+    }
+    Value v = pop_value(vm);
+    /* free previous local then move v into it */
+    free_value(f->locals[slot]);
+    f->locals[slot] = v;
+    break;
+}

src/vm/core/swap.c

@@ -0,0 +1,11 @@
+case OP_SWAP: {
+    if (vm->sp < 1) {
+        fprintf(stderr, "Runtime error: stack underflow for SWAP\n");
+        exit(1);
+    }
+    Value a = vm->stack[vm->sp];
+    Value b = vm->stack[vm->sp - 1];
+    vm->stack[vm->sp] = b;
+    vm->stack[vm->sp - 1] = a;
+    break;
+}