feat: implement classes and instances basic infra

Author: aymaneelmaini

src/chunk.c

@@ -4,6 +4,7 @@
 #include "chunk.h"
 #include "memory.h"
 #include "value.h"
+#include "vm.h"
 
 void init_chunk(Chunk* chunk)
 {
@@ -37,6 +38,8 @@ void write_chunk(Chunk* chunk, u8 byte, int line)
 
 int add_constant(Chunk* chunk, Value value)
 {
+    push(value);
     write_value_array(&chunk->constants, value);
+    pop();
     return chunk->constants.count - 1;
 }

src/chunk.h

@@ -35,6 +35,7 @@ typedef enum
     OP_CLOSURE,
     OP_CLOSE_UPVALUE,
     OP_RETURN,
+    OP_CLASS,
 } OpCode;
 
 typedef struct

src/compiler.c

@@ -748,6 +748,19 @@ static void function(FunctionType type)
     }
 }
 
+static void class_declaration()
+{
+    consume(TOKEN_IDENTIFIER, "Expect class name.");
+    u8 name_constant = identifier_constant(&parser.previous);
+    declare_variable(true);
+
+    emit_bytes(OP_CLASS, name_constant);
+    define_variable(name_constant, true);
+
+    consume(TOKEN_LEFT_BRACE, "Expected '{' after class name");
+    consume(TOKEN_RIGHT_BRACE, "Expected '}' after class body");
+}
+
 static void fun_declaration()
 {
     u8 global = parse_variable(false, "Expect function name");
@@ -930,10 +943,10 @@ static void synchronize()
 
 static void declaration()
 {
-    if (match(TOKEN_FUN))
-    {
+    if (match(TOKEN_CLASS))
+        class_declaration();
+    else if (match(TOKEN_FUN))
         fun_declaration();
-    }
     else if (match(TOKEN_VAR) || match(TOKEN_VAL))
         var_declaration();
     else

src/debug.c

@@ -107,6 +107,8 @@ int disassemble_instruction(Chunk* chunk, int offset)
         return simple_instruction("OP_CLOSE_UPVALUE", offset);
     case OP_RETURN:
         return simple_instruction("OP_RETURN", offset);
+    case OP_CLASS:
+        return constant_instruction("OP_CLASS", chunk, offset);
     default:
         printf("Uknown opcode %d \n", instruction);
         return offset + 1;

src/memory.c

@@ -92,6 +92,10 @@ static void blacken_object(Obj* object)
 #endif  // DEbUG_LOG_GC
     switch (object->type)
     {
+    case OBJ_CLASS:
+        ObjClass* klass = (ObjClass*)object;
+        mark_object((Obj*)klass->name);
+        break;
     case OBJ_CLOSURE:
         ObjClosure* closure = (ObjClosure*)object;
         mark_object((Obj*)closure->function);
@@ -105,6 +109,11 @@ static void blacken_object(Obj* object)
         mark_object((Obj*)function->name);
         mark_array(&function->chunk.constants);
         break;
+    case OBJ_INSTANCE:
+        ObjInstance* instance = (ObjInstance*)object;
+        mark_object((Obj*)instance->klass);
+        mark_table(&instance->fields);
+        break;
     case OBJ_UPVALUE:
         mark_value(((ObjUpvalue*)object)->closed);
         break;
@@ -123,6 +132,9 @@ static void free_object(Obj* object)
 
     switch (object->type)
     {
+    case OBJ_CLASS:
+        FREE(ObjClass, object);
+        break;
     case OBJ_CLOSURE:
     {
         ObjClosure* closure = (ObjClosure*)object;
@@ -137,6 +149,11 @@ static void free_object(Obj* object)
         FREE(ObjFunction, object);
         break;
     }
+    case OBJ_INSTANCE:
+        ObjInstance* instance = (ObjInstance*)object;
+        free_table(&instance->fields);
+        FREE(ObjInstance, object);
+        break;
     case OBJ_NATIVE:
     {
         FREE(ObjNative, object);

src/object.c

@@ -8,9 +8,10 @@
 #include "memory.h"
 #include "object.h"
 #include "table.h"
+#include "value.h"
 #include "vm.h"
 
-#define ALLOCATE_OBJ(type, object_type)                                        \
+#define ALLOCATE_OBJ(type, object_type) \
     (type*)allocate_object(sizeof(type), object_type)
 
 static Obj* allocate_object(size_t size, ObjType type)
@@ -28,6 +29,13 @@ static Obj* allocate_object(size_t size, ObjType type)
     return object;
 }
 
+ObjClass* new_class(ObjString* name)
+{
+    ObjClass* klass = ALLOCATE_OBJ(ObjClass, OBJ_CLASS);
+    klass->name = name;
+    return klass;
+}
+
 ObjClosure* new_closure(ObjFunction* function)
 {
     ObjUpvalue** upvalues = ALLOCATE(ObjUpvalue*, function->upvalue_count);
@@ -54,6 +62,14 @@ ObjFunction* new_function()
     return function;
 }
 
+ObjInstance* new_instance(ObjClass* klass)
+{
+    ObjInstance* instance = ALLOCATE_OBJ(ObjInstance, OBJ_INSTANCE);
+    instance->klass = klass;
+    init_table(&instance->fields);
+    return instance;
+}
+
 ObjNative* new_native(NativeFn function)
 {
     ObjNative* native = ALLOCATE_OBJ(ObjNative, OBJ_NATIVE);
@@ -68,7 +84,9 @@ static ObjString* allocate_string(char* chars, int length, u32 hash)
     string->chars = chars;
     string->hash = hash;
 
+    push(OBJ_VAL(string));
     table_set(&vm.strings, string, NIL_VAL);
+    pop();
 
     return string;
 }
@@ -138,6 +156,9 @@ void print_object(Value value)
 
     switch (OBJ_TYPE(value))
     {
+    case OBJ_CLASS:
+        printf("%s", AS_CLASS(value)->name->chars);
+        break;
     case OBJ_CLOSURE:
     {
         print_function(AS_CLOSURE(value)->function);
@@ -148,6 +169,9 @@ void print_object(Value value)
         print_function(AS_FUNCTION(value));
         break;
     }
+    case OBJ_INSTANCE:
+        printf("%s instance", AS_INSTANCE(value)->klass->name->chars);
+        break;
     case OBJ_NATIVE:
     {
         printf("<native fn>");

src/object.h

@@ -3,16 +3,23 @@
 
 #include "chunk.h"
 #include "common.h"
+#include "table.h"
 #include "value.h"
 
 #define OBJ_TYPE(value) (AS_OBJ(value)->type)
 
+#define IS_CLASS(value) is_obj_type(value, OBJ_CLASS)
+#define AS_CLASS(value) ((ObjClass*)AS_OBJ(value))
+
 #define IS_CLOSURE(value) is_obj_type(value, OBJ_CLOSURE)
 #define AS_CLOSURE(value) ((ObjClosure*)AS_OBJ(value))
 
 #define IS_FUNCTION(value) is_obj_type(value, OBJ_FUNCTION);
 #define AS_FUNCTION(value) (((ObjFunction*)AS_OBJ(value)))
 
+#define IS_INSTANCE(value) is_obj_type(value, OBJ_INSTANCE)
+#define AS_INSTANCE(value) ((ObjInstance*)AS_OBJ(value))
+
 #define IS_NATIVE(value) is_obj_type(value, OBJ_NATIVE);
 #define AS_NATIVE(value) (((ObjNative*)AS_OBJ(value))->function)
 
@@ -22,8 +29,10 @@
 
 typedef enum
 {
+    OBJ_CLASS,
     OBJ_CLOSURE,
     OBJ_FUNCTION,
+    OBJ_INSTANCE,
     OBJ_NATIVE,
     OBJ_STRING,
     OBJ_UPVALUE,
@@ -78,8 +87,23 @@ typedef struct
     int          upvalue_count;
 } ObjClosure;
 
+typedef struct ObjClass
+{
+    Obj        obj;
+    ObjString* name;
+} ObjClass;
+
+typedef struct ObjInstance
+{
+    Obj       obj;
+    ObjClass* klass;
+    Table     fields;
+} ObjInstance;
+
+ObjClass*    new_class(ObjString* name);
 ObjClosure*  new_closure(ObjFunction* function);
 ObjFunction* new_function();
+ObjInstance* new_instance(ObjClass* klass);
 ObjNative*   new_native(NativeFn function);
 ObjString*   take_string(char* chars, int length);
 ObjString*   copy_string(const char* chars, int length);

src/vm.c

@@ -124,6 +124,10 @@ static bool call_value(Value callee, int arg_count)
     {
         switch (OBJ_TYPE(callee))
         {
+        case OBJ_INSTANCE:
+            ObjClass* klass = AS_CLASS(callee);
+            vm.stack_top[-arg_count - 1] = OBJ_VAL(new_instance(klass));
+            return true;
         case OBJ_CLOSURE:
             return call(AS_CLOSURE(callee), arg_count);
         case OBJ_NATIVE:
@@ -187,8 +191,8 @@ static bool is_falsey(Value value)
 
 static void concatenate()
 {
-    ObjString* b = AS_STRING(pop());
-    ObjString* a = AS_STRING(pop());
+    ObjString* b = AS_STRING(peek(0));
+    ObjString* a = AS_STRING(peek(1));
 
     int   length = a->length + b->length;
     char* chars = ALLOCATE(char, length + 1);
@@ -197,6 +201,9 @@ static void concatenate()
     chars[length] = '\0';
 
     ObjString* result = take_string(chars, length);
+
+    pop();
+    pop();
     push(OBJ_VAL(result));
 }
 
@@ -438,6 +445,9 @@ static InterpretResult run()
             frame = &vm.frames[vm.frame_count - 1];
             break;
         }
+        case OP_CLASS:
+            push(OBJ_VAL(new_class(READ_STRING())));
+            break;
         }
     }