feat: Implement core virtual machine, object system, and LLVM compiler backend.

Author: ProgrammerKR

include/object.h

@@ -150,9 +150,12 @@ struct ObjDictionary {
 
 typedef struct ObjTask ObjTask;
 
+typedef void (*ResumeFn)(void*);
+
 struct ObjTask {
   Obj obj;
   void* coroHandle; // LLVM Coroutine Handle
+  ResumeFn resume;  // Helper to resume coroutine
   bool completed;
   Value result;
   struct ObjTask* next; // For scheduler queue
@@ -175,7 +178,7 @@ struct ObjInstance *newInstance(struct ObjClass *klass);
 struct ObjBoundMethod *newBoundMethod(Value receiver, ObjClosure *method);
 struct ObjList *newList();
 struct ObjDictionary *newDictionary();
-struct ObjTask *newTask(void* hdl);
+struct ObjTask *newTask(void* hdl, ResumeFn resume);
 void printObject(Value value);
 
 static inline bool isObjType(Value value, ObjType type) {

src/compiler/backend_llvm.cpp

@@ -81,7 +81,7 @@ class LLVMEmitter {
         // Runtime helper: ObjTask* prox_rt_new_task(void* hdl)
         llvm::FunctionType *NewTaskType = llvm::FunctionType::get(
              Builder->getInt64Ty(), // Value (ObjTask* encoded)
-             {Builder->getPtrTy()},
+             {Builder->getPtrTy(), Builder->getPtrTy()},
              false
         );
         llvm::Function::Create(NewTaskType, llvm::Function::ExternalLinkage, "prox_rt_new_task", ModuleOb.get());
@@ -176,7 +176,9 @@ class LLVMEmitter {
 
              // Create a Task object to return initially
              llvm::Function* NewTask = ModuleOb->getFunction("prox_rt_new_task");
-             llvm::Value* TaskObj = Builder->CreateCall(NewTask, {CoroHdl}, "taskObj");
+             llvm::Function* ResumeFn = ModuleOb->getFunction("prox_rt_resume");
+             // ResumeFn should exist since setupSchedulerHelpers called before emitModule
+             llvm::Value* TaskObj = Builder->CreateCall(NewTask, {CoroHdl, ResumeFn}, "taskObj");
 
              // We need to return this TaskObj properly when function 'starts' (suspends at init).
              // But LLVM coroutines split functions. We need to handle `IR_OP_RETURN` specially too.

src/runtime/object.c

@@ -145,11 +145,12 @@ void printObject(Value value) {
   }
 }
 
-struct ObjTask *newTask(void* hdl) {
-  struct ObjTask *task = ALLOCATE_OBJ(struct ObjTask, OBJ_TASK);
+struct ObjTask *newTask(void* hdl, ResumeFn resume) {
+  ObjTask *task = (ObjTask *)allocateObject(sizeof(ObjTask), OBJ_TASK);
   task->coroHandle = hdl;
+  task->resume = resume;
   task->completed = false;
-  task->result = NIL_VAL;
+  task->result = NULL_VAL;
   task->next = NULL;
   return task;
 }

src/runtime/scheduler.c

@@ -10,7 +10,8 @@
 #include <stdlib.h>
 
 // Extern declaration of generated LLVM wrapper
-extern void prox_rt_resume(void* hdl);
+// prox_rt_resume removed, using function pointer in ObjTask
+
 
 typedef struct TaskQueue {
     ObjTask* head;
@@ -46,8 +47,8 @@ void scheduler_run() {
         ObjTask* task = scheduler_dequeue();
         currentTask = task;
         // Resume
-        if (task->coroHandle) {
-             prox_rt_resume(task->coroHandle);
+        if (task->coroHandle && task->resume) {
+             task->resume(task->coroHandle);
         }
         currentTask = NULL;
     }
@@ -76,8 +77,8 @@ void prox_rt_await(Value taskVal) {
     }
 }
 
-Value prox_rt_new_task(void* hdl) {
-    ObjTask* task = newTask(hdl);
+Value prox_rt_new_task(void* hdl, ResumeFn resume) {
+    ObjTask* task = newTask(hdl, resume);
     // Auto-schedule new tasks? 
     // Yes, usually.
     scheduler_enqueue(task);

src/runtime/vm.c

@@ -18,6 +18,12 @@
 #include "../include/vm.h"
 #include "../include/error_report.h"
 
+static bool bindMethod(struct ObjClass *klass, ObjString *name, VM *vm);
+static void defineMethod(ObjString *name, VM *vm);
+static void closeUpvalues(VM *vm, Value *last);
+static ObjUpvalue *captureUpvalue(Value *local, VM *vm);
+static bool invokeFromClass(struct ObjClass *klass, ObjString *name, int argCount, VM *vm);
+
 VM vm;
 
 static void resetStack(VM *pvm) {