feat: Complete local variables resolution at compile time

Author: aymaneelmaini

src/chunk.h

@@ -11,6 +11,8 @@ typedef enum
     OP_TRUE,
     OP_FALSE,
     OP_POP,
+    OP_GET_LOCAL,
+    OP_SET_LOCAL,
     OP_GET_GLOBAL,
     OP_DEFINE_GLOBAL,
     OP_SET_GLOBAL,

src/compiler.c

@@ -2,6 +2,7 @@
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <sys/types.h>
 
 #include "chunk.h"
@@ -58,7 +59,7 @@ typedef struct
 {
     Local locals[UINT8_COUNT];
     int   local_count;
-    int   local_depth;
+    int   scope_depth;
 
 } Compiler;
 
@@ -175,7 +176,7 @@ static void emit_constant(Value value)
 static void init_compiler(Compiler* compiler)
 {
     compiler->local_count = 0;
-    compiler->local_depth = 0;
+    compiler->scope_depth = 0;
     current = compiler;
 }
 
@@ -190,12 +191,20 @@ static void end_compiler()
 
 static void begin_scope()
 {
-    current->local_depth++;
+    current->scope_depth++;
 }
 
 static void end_scope()
 {
-    current->local_depth--;
+    current->scope_depth--;
+
+    while (current->local_count > 0 &&
+           current->locals[current->local_count - 1].depth >
+               current->scope_depth)
+    {
+        emit_byte(OP_POP);
+        current->local_count--;
+    }
 }
 
 static void       expression();
@@ -209,14 +218,84 @@ static u8 identifier_constant(Token* name)
     return make_constant(OBJ_VAL(copy_string(name->start, name->length)));
 }
 
+static bool identifiers_equal(Token* t1, Token* t2)
+{
+    if (t1->length != t2->length)
+        return false;
+
+    return memcmp(t1->start, t2->start, t1->length) == 0;
+}
+
+static int resolve_local(Compiler* compiler, Token* name)
+{
+    for (int i = compiler->local_count - 1; i >= 0; i--)
+    {
+        Local* local = &compiler->locals[i];
+        if (identifiers_equal(name, &local->name))
+        {
+            if (local->depth == -1)
+                error("Can't read local variable in its initializer");
+
+            return i;
+        }
+    }
+    return -1;
+}
+
+static void add_local(Token name)
+{
+    if (current->local_count == UINT8_COUNT)
+    {
+        error("Too many variables in function");
+        return;
+    }
+    Local* local = &current->locals[current->local_count++];
+    local->name = name;
+    local->depth = -1;
+}
+
+static void declare_variable()
+{
+    if (current->scope_depth == 0)
+        return;
+
+    Token* name = &parser.previous;
+
+    for (int i = current->local_count - 1; i >= 0; i--)
+    {
+        Local* local = &current->locals[i];
+        if (local->depth != -1 && local->depth < current->scope_depth)
+            break;
+
+        if (identifiers_equal(name, &local->name))
+            error("Already variable with this name in this scope");
+    }
+    add_local(*name);
+}
+
 static u8 parse_variable(char* error_message)
 {
     consume(TOKEN_IDENTIFIER, error_message);
+
+    declare_variable();
+    if (current->scope_depth > 0)
+        return 0;
+
     return identifier_constant(&parser.previous);
 }
 
+static void mark_initialized()
+{
+    current->locals[current->local_count - 1].depth = current->scope_depth;
+}
+
 static void define_variable(u8 global)
 {
+    if (current->scope_depth > 0)
+    {
+        mark_initialized();
+        return;
+    }
     emit_bytes(OP_DEFINE_GLOBAL, global);
 }
 
@@ -302,15 +381,29 @@ static void string(bool can_assign)
 
 static void named_variable(Token name, bool can_assign)
 {
-    u8 arg = identifier_constant(&name);
+    u8  get_op, set_op;
+    int arg = resolve_local(current, &name);
+
+    if (arg != -1)
+    {
+        get_op = OP_GET_LOCAL;
+        set_op = OP_SET_LOCAL;
+    }
+    else
+    {
+        arg = identifier_constant(&name);
+        get_op = OP_GET_GLOBAL;
+        set_op = OP_SET_GLOBAL;
+    }
+
     if (can_assign && match(TOKEN_EQUAL))
     {
         expression();
-        emit_bytes(OP_SET_GLOBAL, arg);
+        emit_bytes(set_op, (u8)arg);
     }
     else
     {
-        emit_bytes(OP_GET_GLOBAL, arg);
+        emit_bytes(get_op, (u8)arg);
     }
 }
 

src/debug.c

@@ -4,13 +4,9 @@
 #include "debug.h"
 #include "value.h"
 
-/**
- * NOTE: I'm noob into c, and i don't know if it's best practice to do this or
- * not but I like to keep impl details at buttom so i put this signatures here
- * to be easy for reader / reviewer to read code fluently
- **/
 static int simple_instruction(const char* name, int offset);
 static int constant_instruction(const char* name, Chunk* chunk, int offset);
+static int byte_instruction(const char* name, Chunk* chunk, int offset);
 
 void disassemble_chunk(Chunk* chunk, const char* name)
 {
@@ -44,6 +40,10 @@ int disassemble_instruction(Chunk* chunk, int offset)
         return simple_instruction("OP_TRUE", offset);
     case OP_POP:
         return simple_instruction("OP_POP", offset);
+    case OP_GET_LOCAL:
+        return byte_instruction("OP_GET_LOCAL", chunk, offset);
+    case OP_SET_LOCAL:
+        return byte_instruction("OP_SET_LOCAL", chunk, offset);
     case OP_GET_GLOBAL:
         return constant_instruction("OP_GET_GLOBAL", chunk, offset);
     case OP_DEFINE_GLOBAL:
@@ -84,6 +84,13 @@ static int simple_instruction(const char* name, int offset)
     return offset + 1;
 }
 
+static int byte_instruction(const char* name, Chunk* chunk, int offset)
+{
+    uint8_t slot = chunk->code[offset + 1];
+    printf("%-16s %4d\n", name, slot);
+    return offset + 2;
+}
+
 static int constant_instruction(const char* name, Chunk* chunk, int offset)
 {
     u8 constantIndex = chunk->code[offset + 1];

src/vm.c

@@ -138,6 +138,18 @@ static InterpretResult run()
         case OP_POP:
             pop();
             break;
+        case OP_GET_LOCAL:
+        {
+            u8 slot = READ_BYTE();
+            push(vm.stack[slot]);
+            break;
+        }
+        case OP_SET_LOCAL:
+        {
+            u8 slot = READ_BYTE();
+            vm.stack[slot] = peek(0);
+            break;
+        }
         case OP_GET_GLOBAL:
         {
             ObjString* name = READ_STRING();