Update vm.c

Author: AzliRynz

vm.c

@@ -1,20 +1,19 @@
 #include "vm.h"
-#include "bloat.h"
+#include "common.h"
 #include "chunk.h"
 #include "value.h"
 #include "object.h"
-
 #include <stdio.h>
 #include <stdarg.h>
 #include <string.h>
 
 static InterpretResult run(VM* vm) {
     #define READ_BYTE() (*vm->ip++)
-    #define READ_CONSTANT() (vm->chunk->constants[READ_BYTE()])
+    #define READ_CONSTANT() (vm->chunk->constants.values[READ_BYTE()])
     #define BINARY_OP(op) \
         do { \
-            if (!IS_NUMBER(peek(0)) || !IS_NUMBER(peek(1))) { \
-                runtime_error("Operands must be numbers."); \
+            if (!IS_NUMBER(peek(vm, 0)) || !IS_NUMBER(peek(vm, 1))) { \
+                runtime_error(vm, "Operands must be numbers."); \
                 return INTERPRET_RUNTIME_ERROR; \
             } \
             double b = AS_NUMBER(pop(vm)); \
@@ -51,7 +50,7 @@ static InterpretResult run(VM* vm) {
             case OP_NEGATE: {
                 Value value = pop(vm);
                 if (!IS_NUMBER(value)) {
-                    runtime_error("Operand must be a number.");
+                    runtime_error(vm, "Operand must be a number.");
                     return INTERPRET_RUNTIME_ERROR;
                 }
                 push(vm, NUMBER_VAL(-AS_NUMBER(value)));
@@ -127,16 +126,15 @@ bool values_equal(Value a, Value b) {
     }
 }
 
-Value peek(int offset) {
-    VM* vm;
-    if ((intptr_t)(vm->stack_top - offset - 1) < 0) {
-        runtime_error("Stack underflow!");
+Value peek(VM* vm, int offset) {
+    if ((vm->stack_top - vm->stack) <= offset) {
+        runtime_error(vm, "Stack underflow!");
         return NIL_VAL;
     }
-    return vm->stack[(int)(vm->stack_top - offset - 1)];
+    return vm->stack[(vm->stack_top - vm->stack) - offset - 1];
 }
 
-void* reallocate(void* pointer, size_t oldSize, size_t newSize) {
+void* reallocate(VM* vm, void* pointer, size_t oldSize, size_t newSize) {
     vm->bytes_allocated += newSize - oldSize;
 
     if (newSize > oldSize) {
@@ -156,30 +154,32 @@ void* reallocate(void* pointer, size_t oldSize, size_t newSize) {
 }
 
 void collect_garbage(VM* vm) {
+    // Mark phase
     for (Value* slot = vm->stack; slot < vm->stack_top; slot++) {
         mark_value(vm, *slot);
     }
 
-    Object** object = &vm->objects;
+    // Sweep phase
+    Obj** object = &vm->objects;
     while (*object != NULL) {
-        if (!(*object)->is_marked) {
-            Object* unreached = *object;
+        if (!(*object)->marked) {
+            Obj* unreached = *object;
             *object = unreached->next;
-            free_object(unreached);
+            free_object(vm, unreached);
         } else {
-            (*object)->is_marked = false;
+            (*object)->marked = false;
             object = &(*object)->next;
         }
     }
 
     vm->next_gc = vm->bytes_allocated * 2;
 }
 
-void mark_object(VM* vm, Object* object) {
+void mark_object(VM* vm, Obj* object) {
     if (object == NULL) return;
-    if (object->is_marked) return;
+    if (object->marked) return;
 
-    object->is_marked = true;
+    object->marked = true;
     // If the object contains references to other objects,
     // they should be marked here
 }
@@ -190,7 +190,7 @@ void mark_value(VM* vm, Value value) {
     }
 }
 
-void runtime_error(const char* format, ...) {
+void runtime_error(VM* vm, const char* format, ...) {
     va_list args;
     va_start(args, format);
     vfprintf(stderr, format, args);
@@ -199,10 +199,10 @@ void runtime_error(const char* format, ...) {
 }
 
 void free_objects(VM* vm) {
-    Object* object = vm->objects;
+    Obj* object = vm->objects;
     while (object != NULL) {
-        Object* next = object->next;
-        free_object(object);
+        Obj* next = object->next;
+        free_object(vm, object);
         object = next;
     }
 }