fix py_inspect_currentfunction

include/pocketpy/interpreter/vm.h

@@ -51,7 +51,8 @@ typedef struct VM {
 
     py_TValue reg[8];  // users' registers
 
-    py_TValue* __curr_class;
+    py_StackRef __curr_class;
+    py_StackRef __curr_function;
     py_TValue __vectorcall_buffer[PK_MAX_CO_VARNAMES];
 
     ManagedHeap heap;
@@ -76,10 +77,10 @@ bool pk_wrapper__self(int argc, py_Ref argv);
 bool pk_wrapper__NotImplementedError(int argc, py_Ref argv);
 
 typedef enum FrameResult {
-    RES_RETURN,
-    RES_CALL,
-    RES_YIELD,
-    RES_ERROR,
+    RES_ERROR = 0,
+    RES_RETURN = 1,
+    RES_CALL = 2,
+    RES_YIELD = 3,
 } FrameResult;
 
 FrameResult VM__run_top_frame(VM* self);

include/pocketpy/pocketpy.h

@@ -310,8 +310,9 @@ PK_EXPORT void py_setslot(py_Ref self, int i, py_Ref val);
 
 /************* Inspection *************/
 
-/// Get the current `function` object from the stack.
+/// Get the current `function` object on the stack.
 /// Return `NULL` if not available.
+/// NOTE: This function should be placed at the beginning of your decl-based bindings.
 PK_EXPORT py_StackRef py_inspect_currentfunction();
 /// Get the current `module` object where the code is executed.
 /// Return `NULL` if not available.
@@ -586,6 +587,7 @@ enum py_MagicNames {
 };
 
 enum py_PredefinedTypes {
+    tp_nil = 0,
     tp_object = 1,
     tp_type,  // py_Type
     tp_int,

src/interpreter/vm.c

@@ -70,6 +70,7 @@ void VM__ctor(VM* self) {
     self->is_curr_exc_handled = false;
 
     self->__curr_class = NULL;
+    self->__curr_function = NULL;
 
     ManagedHeap__ctor(&self->heap, self);
     ValueStack__ctor(&self->stack);
@@ -346,7 +347,7 @@ static bool
         return TypeError("%s() takes %d positional arguments but %d were given",
                          co->name->data,
                          decl_argc,
-                         p1 - argv);
+                         (int)(p1 - argv));
     }
 
     py_TValue* t = argv;
@@ -419,10 +420,9 @@ FrameResult VM__vectorcall(VM* self, uint16_t argc, uint16_t kwargc, bool opcall
         // [unbound, self, args..., kwargs...]
     }
 
-    py_Ref argv = py_isnil(p0 + 1) ? p0 + 2 : p0 + 1;
+    py_Ref argv = p0 + 1 + (int)py_isnil(p0 + 1);
 
     if(p0->type == tp_function) {
-        /*****************_py_call*****************/
         // check stack overflow
         if(self->stack.sp > self->stack.end) {
             py_exception(tp_StackOverflowError, "");
@@ -441,18 +441,22 @@ FrameResult VM__vectorcall(VM* self, uint16_t argc, uint16_t kwargc, bool opcall
                 memcpy(argv, self->__vectorcall_buffer, co->nlocals * sizeof(py_TValue));
                 // submit the call
                 if(!fn->cfunc) {
+                    // python function
                     VM__push_frame(self, Frame__new(co, &fn->module, p0, argv, true));
                     return opcall ? RES_CALL : VM__run_top_frame(self);
                 } else {
+                    // decl-based binding
+                    self->__curr_function = p0;
                     bool ok = py_callcfunc(fn->cfunc, co->nlocals, argv);
                     self->stack.sp = p0;
+                    self->__curr_function = NULL;
                     return ok ? RES_RETURN : RES_ERROR;
                 }
             }
             case FuncType_SIMPLE:
                 if(p1 - argv != fn->decl->args.length) {
                     const char* fmt = "%s() takes %d positional arguments but %d were given";
-                    TypeError(fmt, co->name->data, fn->decl->args.length, p1 - argv);
+                    TypeError(fmt, co->name->data, fn->decl->args.length, (int)(p1 - argv));
                     return RES_ERROR;
                 }
                 if(kwargc) {
@@ -634,7 +638,7 @@ void pk_print_stack(VM* self, Frame* frame, Bytecode byte) {
     c11_sbuf__ctor(&buf);
     for(py_Ref p = self->stack.begin; p != sp; p++) {
         switch(p->type) {
-            case 0: c11_sbuf__write_cstr(&buf, "nil"); break;
+            case tp_nil: c11_sbuf__write_cstr(&buf, "nil"); break;
             case tp_int: c11_sbuf__write_i64(&buf, p->_i64); break;
             case tp_float: c11_sbuf__write_f64(&buf, p->_f64, -1); break;
             case tp_bool: c11_sbuf__write_cstr(&buf, p->_bool ? "True" : "False"); break;

src/public/py_exception.c

@@ -153,6 +153,7 @@ void py_clearexc(py_StackRef p0) {
     vm->curr_exception = *py_NIL;
     vm->is_curr_exc_handled = false;
     vm->__curr_class = NULL;
+    vm->__curr_function = NULL;
     if(p0) vm->stack.sp = p0;
 }
 

src/public/stack_ops.c

@@ -70,9 +70,7 @@ void py_setslot(py_Ref self, int i, py_Ref val) {
 }
 
 py_StackRef py_inspect_currentfunction(){
-    Frame* frame = pk_current_vm->top_frame;
-    if(!frame || !frame->has_function) return NULL;
-    return frame->p0;
+    return pk_current_vm->__curr_function;
 }
 
 py_GlobalRef py_inspect_currentmodule(){