refactor: introduce functions so each chunk will be executed should be wrapped by a function

Author: aymaneelmaini

src/compiler.c

@@ -53,8 +53,17 @@ typedef struct
     bool  is_immutable;
 } Local;
 
+typedef enum
+{
+    TYPE_FUNCTION,
+    TYPE_SCRIPT,
+} FunctionType;
+
 typedef struct
 {
+    ObjFunction* function;
+    FunctionType type;
+
     Local locals[UINT8_COUNT];
     int   local_count;
     int   scope_depth;
@@ -63,12 +72,12 @@ typedef struct
 static bool immutable_globals[UINT8_MAX];
 
 Parser    parser;
-Compiler* current;
+Compiler* current = NULL;
 Chunk*    compiling_chunk;
 
 static Chunk* current_chunk()
 {
-    return compiling_chunk;
+    return &current->function->chunk;
 }
 
 static inline void error_at(Token* token, const char* message)
@@ -201,20 +210,33 @@ static void patch_jump(int offset)
     current_chunk()->code[offset] = (jump >> 8) & 0xff;
     current_chunk()->code[offset + 1] = jump & 0xff;
 }
-static void init_compiler(Compiler* compiler)
+static void init_compiler(Compiler* compiler, FunctionType type)
 {
+    compiler->function = NULL;
+    compiler->type = type;
     compiler->local_count = 0;
     compiler->scope_depth = 0;
     current = compiler;
+
+    Local* local = &current->locals[current->local_count++];
+    local->depth = 0;
+    local->name.start = "";
+    local->name.length = 0;
 }
 
-static void end_compiler()
+static ObjFunction* end_compiler()
 {
     emit_return();
+    ObjFunction* function = current->function;
+
 #ifdef DEBUG_PRINT_CODE
     if (!parser.had_error)
-        disassemble_chunk(current_chunk(), "code");
+        disassemble_chunk(current_chunk(), function->name != NULL
+                                               ? function->name->chars
+                                               : "<script>");
 #endif
+
+    return function;
 }
 
 static void begin_scope()
@@ -615,7 +637,7 @@ static void expression_statement()
     emit_byte(OP_POP);
 }
 
-static void for_satement()
+static void for_statement()
 {
     begin_scope();
     consume(TOKEN_LEFT_PAREN, "Expect '(' after 'for'");
@@ -779,11 +801,11 @@ static inline void init_parser()
     parser.panic_mode = false;
 }
 
-bool compile(const char* source, Chunk* chunk)
+ObjFunction* compile(const char* source, Chunk* chunk)
 {
     init_scanner(source);
     Compiler compiler;
-    init_compiler(&compiler);
+    init_compiler(&compiler, TYPE_SCRIPT);
     compiling_chunk = chunk;
     init_parser();
 
@@ -794,5 +816,6 @@ bool compile(const char* source, Chunk* chunk)
     }
 
     end_compiler();
-    return !parser.had_error;
+    ObjFunction* function = end_compiler();
+    return parser.had_error ? NULL : function;
 }

src/compiler.h

@@ -2,7 +2,8 @@
 #define clox_compiler_h
 
 #include "chunk.h"
+#include "object.h"
 
-bool compile(const char* source, Chunk* chunk);
+ObjFunction* compile(const char* source, Chunk* chunk);
 
 #endif

src/memory.c

@@ -1,5 +1,6 @@
 #include <stdlib.h>
 
+#include "chunk.h"
 #include "memory.h"
 #include "object.h"
 #include "value.h"
@@ -23,6 +24,13 @@ static void free_object(Obj* object)
 {
     switch (object->type)
     {
+    case OBJ_FUNCTION:
+    {
+        ObjFunction* function = (ObjFunction*)object;
+        free_chunk(&function->chunk);
+        FREE(ObjFunction, object);
+        break;
+    }
     case OBJ_STRING:
     {
         ObjString* string = (ObjString*)object;

src/object.c

@@ -3,6 +3,7 @@
 #include <string.h>
 #include <sys/types.h>
 
+#include "chunk.h"
 #include "common.h"
 #include "memory.h"
 #include "object.h"
@@ -22,6 +23,16 @@ static Obj* allocate_object(size_t size, ObjType type)
     return object;
 }
 
+ObjFunction* new_function()
+{
+    ObjFunction* function = ALLOCATE_OBJ(ObjFunction, OBJ_FUNCTION);
+
+    function->arity = 0;
+    function->name = NULL;
+    init_chunk(&function->chunk);
+    return function;
+}
+
 static ObjString* allocate_string(char* chars, int length, u32 hash)
 {
     ObjString* string = ALLOCATE_OBJ(ObjString, OBJ_STRING);
@@ -75,13 +86,31 @@ ObjString* copy_string(const char* chars, int length)
     return allocate_string(heap_chars, length, hash);
 }
 
+static void print_function(ObjFunction* function)
+{
+    if (function->name == NULL)
+    {
+        printf("<script>");
+        return;
+    }
+    printf("<fn  %s>", function->name->chars);
+}
+
 void print_object(Value value)
 {
 
     switch (OBJ_TYPE(value))
     {
+    case OBJ_FUNCTION:
+    {
+        print_function(AS_FUNCTION(value));
+        break;
+    }
     case OBJ_STRING:
+    {
+
         printf("%s", AS_CSTRING(value));
         break;
     }
+    }
 }

src/object.h

@@ -1,17 +1,23 @@
 #ifndef clox_object_h
 #define clox_object_h
 
+#include "chunk.h"
 #include "common.h"
 #include "value.h"
 
 #define OBJ_TYPE(value) (AS_OBJ(value)->type)
+
+#define IS_FUNCTION(value) is_obj_type(value, OBJ_FUNCTION);
+#define AS_FUNCTION(value) (((ObjFunction*)AS_OBJ(value)))
+
 #define IS_STRING(value) is_obj_type(value, OBJ_STRING)
 #define AS_STRING(value) ((ObjString*)AS_OBJ(value))
 #define AS_CSTRING(value) (((ObjString*)AS_OBJ(value))->chars)
 
 typedef enum
 {
-    OBJ_STRING
+    OBJ_STRING,
+    OBJ_FUNCTION,
 } ObjType;
 
 struct Obj
@@ -20,6 +26,14 @@ struct Obj
     struct Obj* next;
 };
 
+typedef struct
+{
+    Obj        obj;
+    int        arity;
+    Chunk      chunk;
+    ObjString* name;
+} ObjFunction;
+
 struct ObjString
 {
     Obj   obj;
@@ -28,9 +42,10 @@ struct ObjString
     u32   hash;
 };
 
-ObjString* take_string(char* chars, int length);
-ObjString* copy_string(const char* chars, int length);
-void       print_object(Value value);
+ObjFunction* new_function();
+ObjString*   take_string(char* chars, int length);
+ObjString*   copy_string(const char* chars, int length);
+void         print_object(Value value);
 
 static inline bool is_obj_type(Value value, ObjType type)
 {