Finish CLOSURE

Author: heinthanth

examples/fib.meon

@@ -3,6 +3,6 @@ func fib(n)
     return fib(n - 2) + fib(n - 1);
 endfunc
 
-let start = time();
-output "ELAPSED TIME => " . fib(35);
-output time() - start;
+let start = clock();
+output "RESULT => " . fib(35);
+output "ELAPSED => " . (clock() - start) . "s";

includes/chunk.h

@@ -18,6 +18,9 @@ typedef enum
     //OP_DEFINE_LOCAL,
     OP_SET_LOCAL,
     OP_SET_GLOBAL,
+    OP_GET_UPVALUE,
+    OP_SET_UPVALUE,
+    OP_CLOSE_UPVALUE,
     OP_EQUAL,
     OP_GREATER,
     OP_GREATER_EQUAL,
@@ -37,6 +40,7 @@ typedef enum
     OP_JUMP,
     OP_LOOP,
     OP_CALL,
+    OP_CLOSURE,
     OP_RETURN
 } OpCode;
 

includes/object.h

@@ -8,11 +8,13 @@
 #define OBJ_TYPE(value) (AS_OBJ(value)->t)
 
 #define IS_STRING(value) check_object_t(value, OBJECT_STRING)
+#define IS_CLOSURE(value) check_object_t(value, OBJECT_CLOSURE)
 #define IS_FUNCTION(value) check_object_t(value, OBJECT_FUNCTION)
-#define IS_NATIVE(value)       check_object_t(value, OBJECT_NATIVE)
+#define IS_NATIVE(value) check_object_t(value, OBJECT_NATIVE)
 
+#define AS_CLOSURE(value) ((ObjectClosure *)AS_OBJ(value))
 #define AS_FUNCTION(value) ((ObjectFunction *)AS_OBJ(value))
-#define AS_NATIVE(value) (((ObjectNative*)AS_OBJ(value))->function)
+#define AS_NATIVE(value) (((ObjectNative *)AS_OBJ(value))->function)
 #define AS_STRING(value) ((ObjectString *)AS_OBJ(value))
 #define AS_CSTRING(value) (((ObjectString *)AS_OBJ(value))->chars)
 
@@ -21,6 +23,8 @@ typedef enum
     OBJECT_STRING,
     OBJECT_FUNCTION,
     OBJECT_NATIVE,
+    OBJECT_CLOSURE,
+    OBJECT_UPVALUE,
 } object_t;
 
 struct Object
@@ -33,15 +37,17 @@ typedef struct
 {
     Object object;
     int argsCount;
+    int upvalueCount;
     Chunk chunk;
     ObjectString *name;
 } ObjectFunction;
 
-typedef Value (*NativeFn)(int argCount, Value* args);
+typedef Value (*NativeFn)(int argCount, Value *args);
 
-typedef struct {
-  Object object;
-  NativeFn function;
+typedef struct
+{
+    Object object;
+    NativeFn function;
 } ObjectNative;
 
 struct ObjectString
@@ -52,8 +58,26 @@ struct ObjectString
     uint32_t hash;
 };
 
+typedef struct ObjectUpvalue
+{
+    Object obj;
+    Value *location;
+     Value closed;
+    struct ObjectUpvalue *next;
+} ObjectUpvalue;
+
+typedef struct
+{
+    Object obj;
+    ObjectFunction *function;
+    ObjectUpvalue **upvalues;
+    int upvalueCount;
+} ObjectClosure;
+
 ObjectFunction *newFunction();
-ObjectNative* newNative(NativeFn function);
+ObjectNative *newNative(NativeFn function);
+ObjectClosure *newClosure(ObjectFunction *function);
+ObjectUpvalue *newUpvalue(Value *slot);
 ObjectString *takeString(char *chars, int length);
 ObjectString *cpString(const char *chars, int length);
 

includes/vm.h

@@ -10,7 +10,7 @@
 
 typedef struct
 {
-    ObjectFunction *function;
+    ObjectClosure* closure;
     uint8_t *ip;
     Value *slots;
 } CallFrame;
@@ -23,6 +23,7 @@ typedef struct
     Value *stackTop;
     Table globals;
     Table strings;
+    ObjectUpvalue* openUpvalues;
     Object *objects;
 } VM;
 

src/compiler.c

@@ -51,8 +51,15 @@ typedef struct
 {
     Token name;
     int depth;
+    bool isCaptured;
 } Local;
 
+typedef struct
+{
+    uint8_t index;
+    bool isLocal;
+} Upvalue;
+
 typedef enum
 {
     TYPE_FUNCTION,
@@ -66,6 +73,7 @@ typedef struct Compiler
     function_t t;
     Local locals[UINT8_COUNT];
     int localCount;
+    Upvalue upvalues[UINT8_COUNT];
     int scopeDepth;
 } Compiler;
 
@@ -236,6 +244,7 @@ static void initCompiler(Compiler *compiler, function_t t)
     local->depth = 0;
     local->name.start = "";
     local->name.length = 0;
+    local->isCaptured = false;
 }
 
 static ObjectFunction *endCompiler(int debugLevel)
@@ -264,7 +273,14 @@ static void endScope()
     current->scopeDepth--;
     while (current->localCount > 0 && current->locals[current->localCount - 1].depth > current->scopeDepth)
     {
-        emit_b(OP_POP);
+        if (current->locals[current->localCount - 1].isCaptured)
+        {
+            emit_b(OP_CLOSE_UPVALUE);
+        }
+        else
+        {
+            emit_b(OP_POP);
+        }
         current->localCount--;
     }
 }
@@ -304,6 +320,51 @@ static int resolveLocal(Compiler *compiler, Token *name)
     return -1;
 }
 
+static int addUpvalue(Compiler *compiler, uint8_t index, bool isLocal)
+{
+    int upvalueCount = compiler->function->upvalueCount;
+
+    for (int i = 0; i < upvalueCount; i++)
+    {
+        Upvalue *upvalue = &compiler->upvalues[i];
+        if (upvalue->index == index && upvalue->isLocal == isLocal)
+        {
+            return i;
+        }
+    }
+
+    if (upvalueCount == UINT8_COUNT)
+    {
+        error("Too many closure variables in function.");
+        return 0;
+    }
+
+    compiler->upvalues[upvalueCount].isLocal = isLocal;
+    compiler->upvalues[upvalueCount].index = index;
+    return compiler->function->upvalueCount++;
+}
+
+static int resolveUpvalue(Compiler *compiler, Token *name)
+{
+    if (compiler->enclosing == NULL)
+        return -1;
+
+    int local = resolveLocal(compiler->enclosing, name);
+    if (local != -1)
+    {
+        compiler->enclosing->locals[local].isCaptured = true;
+        return addUpvalue(compiler, (uint8_t)local, true);
+    }
+
+    int upvalue = resolveUpvalue(compiler->enclosing, name);
+    if (upvalue != -1)
+    {
+        return addUpvalue(compiler, (uint8_t)upvalue, false);
+    }
+
+    return -1;
+}
+
 static void addLocal(Token name)
 {
     if (current->localCount == UINT8_COUNT)
@@ -315,6 +376,7 @@ static void addLocal(Token name)
     Local *local = &current->locals[current->localCount++];
     local->name = name;
     local->depth = -1;
+    local->isCaptured = false;
 }
 
 static void declareVariable()
@@ -523,7 +585,13 @@ static void function(function_t t)
 
     // Create the function object.
     ObjectFunction *function = endCompiler(0);
-    emit_bs(OP_CONSTANT, makeConstant(OBJ_VAL(function)));
+    emit_bs(OP_CLOSURE, makeConstant(OBJ_VAL(function)));
+
+    for (int i = 0; i < function->upvalueCount; i++)
+    {
+        emit_b(compiler.upvalues[i].isLocal ? 1 : 0);
+        emit_b(compiler.upvalues[i].index);
+    }
 }
 
 static void funcDeclaration()
@@ -949,6 +1017,11 @@ static void namedVariable(Token name, bool canAssign)
         getOp = OP_GET_LOCAL;
         setOp = OP_SET_LOCAL;
     }
+    else if ((arg = resolveUpvalue(current, &name)) != -1)
+    {
+        getOp = OP_GET_UPVALUE;
+        setOp = OP_SET_UPVALUE;
+    }
     else
     {
         arg = identifierConstant(&name);

src/debug.c

@@ -1,6 +1,7 @@
 #include <stdio.h>
 
 #include "debug.h"
+#include "object.h"
 #include "value.h"
 
 void disassembleChunk(Chunk *chunk, const char *name)
@@ -84,6 +85,12 @@ int disassembleInstruction(Chunk *chunk, int offset)
         return constantInstruction("dvt", chunk, offset);
     case OP_SET_GLOBAL:
         return constantInstruction("gset", chunk, offset);
+    case OP_GET_UPVALUE:
+        return bInstruction("uvget", chunk, offset);
+    case OP_CLOSE_UPVALUE:
+      return simpleInstruction("uvclose", offset);
+    case OP_SET_UPVALUE:
+        return bInstruction("uvset", chunk, offset);
     case OP_EQUAL:
         return simpleInstruction("eq", offset);
     case OP_GREATER:
@@ -121,7 +128,26 @@ int disassembleInstruction(Chunk *chunk, int offset)
     case OP_LOOP:
         return jumpInstruction("loop", -1, chunk, offset);
     case OP_CALL:
-      return bInstruction("call", chunk, offset);
+        return bInstruction("call", chunk, offset);
+    case OP_CLOSURE:
+    {
+        offset++;
+        uint8_t constant = chunk->code[offset++];
+        printf("%-16s %4d ", "OP_CLOSURE", constant);
+        printValue(chunk->constants.values[constant]);
+        printf("\n");
+
+        ObjectFunction *function = AS_FUNCTION(chunk->constants.values[constant]);
+        for (int j = 0; j < function->upvalueCount; j++)
+        {
+            int isLocal = chunk->code[offset++];
+            int index = chunk->code[offset++];
+            printf("%04d      |                     %s %d\n",
+                   offset - 2, isLocal ? "local" : "upvalue", index);
+        }
+
+        return offset;
+    }
     case OP_RETURN:
         return simpleInstruction("ret", offset);
     default:

src/mem.c

@@ -36,6 +36,16 @@ static void freeObject(Object *object)
     case OBJECT_NATIVE:
         FREE(ObjectNative, object);
         break;
+    case OBJECT_CLOSURE:
+    {
+        ObjectClosure *closure = (ObjectClosure *)object;
+        FREE_ARRAY(ObjectUpvalue *, closure->upvalues, closure->upvalueCount);
+        FREE(ObjectClosure, object);
+        break;
+    }
+    case OBJECT_UPVALUE:
+        FREE(ObjectUpvalue, object);
+        break;
     }
 }
 

src/native.c

@@ -24,5 +24,5 @@ static void defineNative(VM *vm, const char *name, NativeFn function)
 void loadNativeFunction(VM *vm)
 {
     defineNative(vm, "time", getUnixEpoch);
-    defineNative(vm, "clock", getUnixEpoch);
+    defineNative(vm, "clock", clockNative);
 }