Update vm.c

Author: AzliRynz

vm.c

@@ -2,53 +2,57 @@
 #include "compiler.h"
 #include "vm.h"
 
-static InterpretResult run() {
-    #define READ_BYTE() (*vm.ip++)
-    #define READ_CONSTANT() (vm.chunk->constants[READ_BYTE()])
+static InterpretResult run(VM* vm) {
+    #define READ_BYTE() (*vm->ip++)
+    #define READ_CONSTANT() (vm->chunk->constants.values[READ_BYTE()])
     #define BINARY_OP(op) \
         do { \
-            double b = pop(); \
-            double a = pop(); \
-            push(a op b); \
+            if (!IS_NUMBER(peek(0)) || !IS_NUMBER(peek(1))) { \
+                runtime_error("Operands must be numbers."); \
+                return INTERPRET_RUNTIME_ERROR; \
+            } \
+            double b = AS_NUMBER(pop(vm)); \
+            double a = AS_NUMBER(pop(vm)); \
+            push(vm, NUMBER_VAL(a op b)); \
         } while (false)
 
     for (;;) {
         uint8_t instruction;
         switch (instruction = READ_BYTE()) {
             case OP_CONSTANT: {
                 Value constant = READ_CONSTANT();
-                push(constant);
+                push(vm, constant);
                 break;
             }
-            case OP_NIL: push(NIL_VAL); break;
-            case OP_TRUE: push(BOOL_VAL(true)); break;
-            case OP_FALSE: push(BOOL_VAL(false)); break;
+            case OP_NIL: push(vm, NIL_VAL); break;
+            case OP_TRUE: push(vm, BOOL_VAL(true)); break;
+            case OP_FALSE: push(vm, BOOL_VAL(false)); break;
             case OP_EQUAL: {
-                Value b = pop();
-                Value a = pop();
-                push(BOOL_VAL(values_equal(a, b)));
+                Value b = pop(vm);
+                Value a = pop(vm);
+                push(vm, BOOL_VAL(values_equal(a, b)));
                 break;
             }
-            case OP_GREATER:  BINARY_OP(>); break;
-            case OP_LESS:     BINARY_OP(<); break;
-            case OP_ADD:      BINARY_OP(+); break;
-            case OP_SUBTRACT:  BINARY_OP(-); break;
-            case OP_MULTIPLY:  BINARY_OP(*); break;
-            case OP_DIVIDE:    BINARY_OP(/); break;
+            case OP_GREATER: BINARY_OP(>); break;
+            case OP_LESS: BINARY_OP(<); break;
+            case OP_ADD: BINARY_OP(+); break;
+            case OP_SUBTRACT: BINARY_OP(-); break;
+            case OP_MULTIPLY: BINARY_OP(*); break;
+            case OP_DIVIDE: BINARY_OP(/); break;
             case OP_NOT:
-                push(BOOL_VAL(is_falsey(pop())));
+                push(vm, BOOL_VAL(is_falsey(pop(vm))));
                 break;
             case OP_NEGATE: {
-                Value value = pop();
+                Value value = pop(vm);
                 if (!IS_NUMBER(value)) {
                     runtime_error("Operand must be a number.");
                     return INTERPRET_RUNTIME_ERROR;
                 }
-                push(NUMBER_VAL(-AS_NUMBER(value)));
+                push(vm, NUMBER_VAL(-AS_NUMBER(value)));
                 break;
             }
             case OP_PRINT: {
-                print_value(pop());
+                print_value(pop(vm));
                 printf("\n");
                 break;
             }
@@ -65,10 +69,13 @@ static InterpretResult run() {
 
 void init_vm(VM* vm) {
     vm->stack_top = vm->stack;
+    vm->objects = NULL;
+    vm->bytes_allocated = 0;
+    vm->next_gc = 1024 * 1024;
 }
 
 void free_vm(VM* vm) {
-    // Nothing to free yet
+    free_objects(vm);
 }
 
 InterpretResult interpret(VM* vm, const char* source) {
@@ -83,7 +90,7 @@ InterpretResult interpret(VM* vm, const char* source) {
     vm->chunk = &chunk;
     vm->ip = vm->chunk->code;
 
-    InterpretResult result = run();
+    InterpretResult result = run(vm);
 
     free_chunk(&chunk);
     return result;
@@ -100,18 +107,15 @@ Value pop(VM* vm) {
 }
 
 bool is_falsey(Value value) {
-    return (value.type == TYPE_NIL) || 
-           (value.type == TYPE_BOOL && !value.data.bool_val);
+    return IS_NIL(value) || (IS_BOOL(value) && !AS_BOOL(value));
 }
 
 bool values_equal(Value a, Value b) {
     if (a.type != b.type) return false;
     switch (a.type) {
-        case TYPE_BOOL:   return a.data.bool_val == b.data.bool_val;
-        case TYPE_NIL:    return true;
-        case TYPE_INT:    return a.data.int_val == b.data.int_val;
-        case TYPE_FLOAT:  return a.data.float_val == b.data.float_val;
-        case TYPE_STRING: return strcmp(a.data.str_val, b.data.str_val) == 0;
-        default:          return false;
+        case VAL_BOOL:   return AS_BOOL(a) == AS_BOOL(b);
+        case VAL_NIL:    return true;
+        case VAL_NUMBER: return AS_NUMBER(a) == AS_NUMBER(b);
+        default:         return false; // Unreachable
     }
 }