some up

include/pocketpy/interpreter/frame.h

@@ -37,7 +37,7 @@ typedef struct Frame {
     struct Frame* f_back;   // TODO: set this
     const Bytecode* ip;
     const CodeObject* co;
-    PyObject* module_;
+    PyObject* module;
     PyObject* function;     // a function object or NULL (global scope)
     PyVar* p0;              // unwinding base
     PyVar* locals;          // locals base
@@ -46,7 +46,7 @@ typedef struct Frame {
 } Frame;
 
 
-Frame* Frame__new(Frame* f_back, const CodeObject* co, PyObject* module_, PyObject* function, PyVar* p0, PyVar* locals, const CodeObject* locals_co);
+Frame* Frame__new(const CodeObject* co, PyObject* module, PyObject* function, PyVar* p0, PyVar* locals, const CodeObject* locals_co);
 void Frame__delete(Frame* self);
 
 PK_INLINE int Frame__ip(const Frame* self){
@@ -64,11 +64,11 @@ PK_INLINE int Frame__iblock(const Frame* self){
 }
 
 PK_INLINE pk_NameDict* Frame__f_globals(Frame* self){
-    return self->module_->dict;
+    return self->module->dict;
 }
 
 PK_INLINE PyVar* Frame__f_globals_try_get(Frame* self, StrName name){
-    return pk_NameDict__try_get(self->module_->dict, name);
+    return pk_NameDict__try_get(self->module->dict, name);
 }
 
 PyVar* Frame__f_closure_try_get(Frame* self, StrName name);

include/pocketpy/interpreter/gc.h

@@ -33,7 +33,6 @@ PyObject* pk_ManagedHeap__gcnew(pk_ManagedHeap* self, Type type, int size);
 
 // external implementation
 void pk_ManagedHeap__mark(pk_ManagedHeap* self);
-void pk_ManagedHeap__delete_obj(pk_ManagedHeap* self, PyObject* obj);
 
 #ifdef __cplusplus
 }

include/pocketpy/interpreter/vm.h

@@ -58,8 +58,11 @@ typedef struct pk_VM {
     
     // singleton objects
     PyVar True, False, None, NotImplemented, Ellipsis;
+    // last error
+    py_Error* last_error;
+    // last retval
+    PyVar last_retval;
 
-    PyObject* __last_exception;
     PyObject* __curr_class;
     PyObject* __cached_object_new;
     FuncDecl_ __dynamic_func_decl;
@@ -74,6 +77,18 @@ typedef struct pk_VM {
 void pk_VM__ctor(pk_VM* self);
 void pk_VM__dtor(pk_VM* self);
 
+void pk_VM__push_frame(pk_VM* self, Frame* frame);
+void pk_VM__pop_frame(pk_VM* self);
+
+typedef enum pk_FrameResult{
+    RES_ERROR,
+    RES_CALL,
+    RES_YIELD,
+    RES_RETURN
+} pk_FrameResult;
+
+pk_FrameResult pk_VM__run_top_frame(pk_VM* self);
+
 Type pk_VM__new_type(pk_VM* self, const char* name, Type base, PyObject* module, bool subclass_enabled);
 PyObject* pk_VM__new_module(pk_VM* self, const char* name, const char* package);
 

include/pocketpy/objects/object.h

@@ -21,12 +21,8 @@ static_assert(sizeof(PyObject) <= 16, "!(sizeof(PyObject) <= 16)");
 #define PK_OBJ_GET(T, val)          (*(T*)(PyObject__value_ptr((val)._obj)))
 #define PK_OBJ_SIZEOF(T)            (sizeof(T) + 16)
 
-PK_INLINE void PyObject__ctor(PyObject* self, Type type, bool gc_is_large){
+PyObject* PyObject__new(Type type, int size);
-    self->type = type;
+void PyObject__delete(pk_VM* vm, PyObject* self);
-    self->gc_is_large = gc_is_large;
-    self->gc_marked = false;
-    self->dict = NULL;
-}
 
 PK_INLINE PyVar PyVar__fromobj(PyObject* obj){
     PyVar retval = {

include/pocketpy/pocketpy.h

@@ -10,9 +10,9 @@ typedef struct PyVar PyVar;
 typedef struct pk_VM pk_VM;
 typedef struct py_Error py_Error;
 
-typedef unsigned (*py_CFunction)(const PyVar*, int);
+typedef int (*py_CFunction)(const PyVar*, int);
 
-extern pk_VM* pk_vm;
+extern pk_VM* pk_current_vm;
 
 void py_initialize();
 // void py_switch_vm(const char* name);

src/interpreter/frame.c

@@ -39,13 +39,13 @@ void UnwindTarget__delete(UnwindTarget* self){
     free(self);
 }
 
-Frame* Frame__new(Frame* f_back, const CodeObject* co, PyObject* module_, PyObject* function, PyVar* p0, PyVar* locals, const CodeObject* locals_co){
+Frame* Frame__new(const CodeObject* co, PyObject* module, PyObject* function, PyVar* p0, PyVar* locals, const CodeObject* locals_co){
     static_assert(sizeof(Frame) <= kPoolFrameBlockSize, "!(sizeof(Frame) <= kPoolFrameBlockSize)");
     Frame* self = PoolFrame_alloc();
-    self->f_back = f_back;
+    self->f_back = NULL;
     self->ip = (Bytecode*)co->codes.data - 1;
     self->co = co;
-    self->module_ = module_;
+    self->module = module;
     self->function = function;
     self->p0 = p0;
     self->locals = locals;

src/interpreter/gc.c

@@ -17,11 +17,11 @@ void pk_ManagedHeap__ctor(pk_ManagedHeap *self, pk_VM *vm){
 void pk_ManagedHeap__dtor(pk_ManagedHeap *self){
     for(int i = 0; i < self->gen.count; i++){
         PyObject* obj = c11__getitem(PyObject*, &self->gen, i);
-        pk_ManagedHeap__delete_obj(self, obj);
+        PyObject__delete(obj);
     }
     for(int i = 0; i < self->no_gc.count; i++){
         PyObject* obj = c11__getitem(PyObject*, &self->no_gc, i);
-        pk_ManagedHeap__delete_obj(self, obj);
+        PyObject__delete(obj);
     }
     c11_vector__dtor(&self->no_gc);
     c11_vector__dtor(&self->gen);
@@ -67,7 +67,7 @@ int pk_ManagedHeap__sweep(pk_ManagedHeap *self){
             if(self->_gc_on_delete){
                 self->_gc_on_delete(self->vm, obj);
             }
-            pk_ManagedHeap__delete_obj(self, obj);
+            PyObject__delete(obj);
         }
     }
 
@@ -89,29 +89,29 @@ int pk_ManagedHeap__sweep(pk_ManagedHeap *self){
 }
 
 PyObject* pk_ManagedHeap__new(pk_ManagedHeap *self, Type type, int size){
-    PyObject* obj;
+    PyObject* obj = PyObject__new(type, size);
-    if(size <= kPoolObjectBlockSize){
-        obj = PoolObject_alloc();
-        PyObject__ctor(obj, type, false);
-    }else{
-        obj = malloc(size);
-        PyObject__ctor(obj, type, true);
-    }
     c11_vector__push(PyObject*, &self->no_gc, obj);
     return obj;
 }
 
 PyObject* pk_ManagedHeap__gcnew(pk_ManagedHeap *self, Type type, int size){
-    PyObject* obj;
+    PyObject* obj = PyObject__new(type, size);
-    if(size <= kPoolObjectBlockSize){
-        obj = PoolObject_alloc();
-        PyObject__ctor(obj, type, false);
-    }else{
-        obj = malloc(size);
-        PyObject__ctor(obj, type, true);
-    }
     c11_vector__push(PyObject*, &self->gen, obj);
     self->gc_counter++;
     return obj;
 }
 
+PyObject* PyObject__new(Type type, int size){
+    PyObject* self;
+    if(size <= kPoolObjectBlockSize){
+        self = PoolObject_alloc();
+        self->gc_is_large = false;
+    }else{
+        self = malloc(size);
+        self->gc_is_large = true;
+    }
+    self->type = type;
+    self->gc_marked = false;
+    self->dict = NULL;
+    return self;
+}

src/interpreter/vm.c

@@ -1,4 +1,5 @@
 #include "pocketpy/interpreter/vm.h"
+#include "pocketpy/common/memorypool.h"
 
 static unsigned char* pk_default_import_file(pk_VM* vm, const char* path){
     return NULL;
@@ -153,6 +154,22 @@ void pk_VM__dtor(pk_VM* self){
     ValueStack__clear(&self->stack);
 }
 
+void pk_VM__push_frame(pk_VM* self, Frame* frame){
+    frame->f_back = self->top_frame;
+    self->top_frame = frame;
+}
+
+void pk_VM__pop_frame(pk_VM* self){
+    assert(self->top_frame);
+    Frame* frame = self->top_frame;
+    self->top_frame = frame->f_back;
+    Frame__delete(frame);
+}
+
+pk_FrameResult pk_VM__run_top_frame(pk_VM* self){
+    return RES_RETURN;
+}
+
 Type pk_VM__new_type(pk_VM* self, const char* name, Type base, PyObject* module, bool subclass_enabled){
     Type type = self->types.count;
     pk_TypeInfo* ti = c11_vector__emplace(&self->types);
@@ -161,3 +178,30 @@ Type pk_VM__new_type(pk_VM* self, const char* name, Type base, PyObject* module,
     pk_TypeInfo__ctor(ti, pk_StrName__map(name), base, typeobj, module, subclass_enabled);
     return type;
 }
+
+/****************************************/
+void PyObject__delete(PyObject *self){
+    pk_TypeInfo* ti = c11__getitem(pk_TypeInfo*, &pk_current_vm->types, self->type);
+    if(ti->dtor) ti->dtor(PyObject__value_ptr(self));
+    if(self->dict) pk_NameDict__delete(self->dict);
+    if(self->gc_is_large){
+        free(self);
+    }else{
+        PoolObject_dealloc(self);
+    }
+}
+
+void pk_ManagedHeap__mark(pk_ManagedHeap* self){
+    // for(int i=0; i<self->no_gc.count; i++){
+    //     PyObject* obj = c11__getitem(PyObject*, &self->no_gc, i);
+    //     vm->__obj_gc_mark(obj);
+    // }
+    // vm->callstack.apply([vm](Frame& frame) {
+    //     frame._gc_mark(vm);
+    // });
+    // vm->obj_gc_mark(vm->__last_exception);
+    // vm->obj_gc_mark(vm->__curr_class);
+    // vm->obj_gc_mark(vm->__c.error);
+    // vm->__stack_gc_mark(vm->s_data.begin(), vm->s_data.end());
+    // if(self->_gc_marker_ex) self->_gc_marker_ex((pkpy_VM*)vm);
+}

src/pocketpy.c

@@ -1,20 +1,40 @@
 #include "pocketpy/pocketpy.h"
 #include "pocketpy/objects/object.h"
 #include "pocketpy/interpreter/vm.h"
+#include <assert.h>
+#include <stdlib.h>
 
-pk_VM* pk_vm;
+pk_VM* pk_current_vm;
 static pk_VM pk_default_vm;
 
 void py_initialize(){
     Pools_initialize();
     pk_StrName__initialize();
-    pk_vm = &pk_default_vm;
+    pk_current_vm = &pk_default_vm;
     pk_VM__ctor(&pk_default_vm);
 }
 
+py_Error* py_exec_simple(const char* source){
+    CodeObject* co = NULL;
+    pk_VM* vm = pk_current_vm;
+    Frame* frame = Frame__new(
+        co,
+        vm->main,
+        NULL,
+        vm->stack.sp,
+        vm->stack.sp,
+        co
+    );
+    pk_VM__push_frame(vm, frame);
+    pk_FrameResult res = pk_VM__run_top_frame(vm);
+    if(res == RES_ERROR) return vm->last_error;
+    if(res == RES_RETURN) return NULL; // vm->last_retval;
+    assert(0);  // unreachable
+}
+
 void py_finalize(){
     pk_VM__dtor(&pk_default_vm);
-    pk_vm = NULL;
+    pk_current_vm = NULL;
     pk_StrName__finalize();
     Pools_finalize();
 }