feat: implement upvalues in runtime now

Author: aymaneelmaini

src/memory.c

@@ -26,6 +26,8 @@ static void free_object(Obj* object)
     {
     case OBJ_CLOSURE:
     {
+        ObjClosure* closure = (ObjClosure*)object;
+        FREE_ARRAY(ObjUpvalue*, closure->upvalues, closure->upvalue_count);
         FREE(ObjClosure, object);
         break;
     }

src/object.c

@@ -25,8 +25,16 @@ static Obj* allocate_object(size_t size, ObjType type)
 
 ObjClosure* new_closure(ObjFunction* function)
 {
+    ObjUpvalue** upvalues = ALLOCATE(ObjUpvalue*, function->upvalue_count);
+    for (int i = 0; i < function->upvalue_count; i++)
+    {
+        upvalues[i] = NULL;
+    }
+
     ObjClosure* closure = ALLOCATE_OBJ(ObjClosure, OBJ_CLOSURE);
     closure->function = function;
+    closure->upvalues = upvalues;
+    closure->upvalue_count = function->upvalue_count;
     return closure;
 }
 
@@ -101,6 +109,13 @@ ObjString* copy_string(const char* chars, int length)
     return allocate_string(heap_chars, length, hash);
 }
 
+ObjUpvalue* new_upvalue(Value* slot)
+{
+    ObjUpvalue* upvalue = ALLOCATE_OBJ(ObjUpvalue, OBJ_UPVALUE);
+    upvalue->location = slot;
+    return upvalue;
+}
+
 static void print_function(ObjFunction* function)
 {
     if (function->name == NULL)

src/object.h

@@ -61,17 +61,26 @@ struct ObjString
     u32   hash;
 };
 
+typedef struct
+{
+    Obj    obj;
+    Value* location;
+} ObjUpvalue;
+
 typedef struct
 {
     Obj          obj;
     ObjFunction* function;
+    ObjUpvalue** upvalues;
+    int          upvalue_count;
 } ObjClosure;
 
 ObjClosure*  new_closure(ObjFunction* function);
 ObjFunction* new_function();
 ObjNative*   new_native(NativeFn function);
 ObjString*   take_string(char* chars, int length);
 ObjString*   copy_string(const char* chars, int length);
+ObjUpvalue*  new_upvalue(Value* slot);
 void         print_object(Value value);
 
 static inline bool is_obj_type(Value value, ObjType type)

src/vm.c

@@ -136,6 +136,12 @@ static bool call_value(Value callee, int arg_count)
     return false;
 }
 
+static ObjUpvalue* capture_upvalue(Value* local)
+{
+    ObjUpvalue* created_upvalue = new_upvalue(local);
+    return created_upvalue;
+}
+
 static bool is_falsey(Value value)
 {
     return IS_NIL(value) || (IS_BOOL(value) && !AS_BOOL(value));
@@ -255,6 +261,18 @@ static InterpretResult run()
             }
             break;
         }
+        case OP_GET_UPVALUE:
+        {
+            u8 slot = READ_BYTE();
+            push(*frame->closure->upvalues[slot]->location);
+            break;
+        }
+        case OP_SET_UPVALUE:
+        {
+            u8 slot = READ_BYTE();
+            *frame->closure->upvalues[slot]->location = peek(0);
+            break;
+        }
         case OP_EQUAL:
         {
             Value v2 = pop();
@@ -347,6 +365,16 @@ static InterpretResult run()
             ObjFunction* function = AS_FUNCTION(READ_CONSTANT());
             ObjClosure*  closure = new_closure(function);
             push(OBJ_VAL(closure));
+            for (int i = 0; i < closure->upvalue_count; i++)
+            {
+                u8 islocal = READ_BYTE();
+                u8 index = READ_BYTE();
+                if (islocal)
+                    closure->upvalues[i] =
+                        capture_upvalue(frame->slots + index);
+                else
+                    closure->upvalues[i] = frame->closure->upvalues[index];
+            }
             break;
         }
         case OP_RETURN: