Merge 6cc3d8023350163e72b83d49981ad2c4b08d39b4 into cf70668a2f4ea9984f0d6bddbe89eb39e01e5dcf

include/pocketpy/interpreter/vm.h

@@ -63,7 +63,8 @@ typedef struct VM {
     CachedNames cached_names;
 
     py_StackRef curr_class;
-    py_StackRef curr_decl_based_function;   // this is for get current function without frame
+    py_StackRef curr_function;
+    
     TraceInfo trace_info;
     WatchdogInfo watchdog_info;
     LineProfiler line_profiler;

include/pocketpy/pocketpy.h

@@ -391,9 +391,9 @@ PK_API void py_tphookattributes(py_Type type,
 
 /************* Inspection *************/
 
-/// Get the current `function` object on the stack.
+/// Get the current `Callable` object on the stack of the most recent vectorcall.
 /// Return `NULL` if not available.
-/// NOTE: This function should be placed at the beginning of your decl-based bindings.
+/// NOTE: This function should be placed at the beginning of your bindings or you will get wrong result.
 PK_API py_StackRef py_inspect_currentfunction();
 /// Get the current `module` object where the code is executed.
 /// Return `NULL` if not available.

src/interpreter/ceval.c

@@ -1244,7 +1244,7 @@ __ERROR:
 __ERROR_RE_RAISE:
     do {
         self->curr_class = NULL;
-        self->curr_decl_based_function = NULL;
+        self->curr_function = NULL;
     } while(0);
 
     int target = Frame__goto_exception_handler(frame, &self->stack, &self->unhandled_exc);

src/interpreter/vm.c

@@ -103,7 +103,8 @@ void VM__ctor(VM* self) {
 
     self->ctx = NULL;
     self->curr_class = NULL;
-    self->curr_decl_based_function = NULL;
+    self->curr_function = NULL;
+
     memset(&self->trace_info, 0, sizeof(TraceInfo));
     memset(&self->watchdog_info, 0, sizeof(WatchdogInfo));
     LineProfiler__ctor(&self->line_profiler);
@@ -482,8 +483,8 @@ FrameResult VM__vectorcall(VM* self, uint16_t argc, uint16_t kwargc, bool opcall
     }
 #endif
 
-    py_Ref p1 = self->stack.sp - kwargc * 2;
-    py_Ref p0 = p1 - argc - 2;
+    py_StackRef p1 = self->stack.sp - kwargc * 2;
+    py_StackRef p0 = p1 - argc - 2;
     // [callable, <self>, args..., kwargs...]
     //      ^p0                    ^p1      ^_sp
 
@@ -496,7 +497,8 @@ FrameResult VM__vectorcall(VM* self, uint16_t argc, uint16_t kwargc, bool opcall
         // [unbound, self, args..., kwargs...]
     }
 
-    py_Ref argv = p0 + 1 + (int)py_isnil(p0 + 1);
+    py_StackRef argv = p0 + 1 + (int)py_isnil(p0 + 1);
+    self->curr_function = p0;  // set current function for inspection
 
     if(p0->type == tp_function) {
         Function* fn = py_touserdata(p0);
@@ -516,10 +518,8 @@ FrameResult VM__vectorcall(VM* self, uint16_t argc, uint16_t kwargc, bool opcall
                     return opcall ? RES_CALL : VM__run_top_frame(self);
                 } else {
                     // decl-based binding
-                    self->curr_decl_based_function = p0;
                     bool ok = py_callcfunc(fn->cfunc, co->nlocals, argv);
                     self->stack.sp = p0;
-                    self->curr_decl_based_function = NULL;
                     return ok ? RES_RETURN : RES_ERROR;
                 }
             }
@@ -545,10 +545,8 @@ FrameResult VM__vectorcall(VM* self, uint16_t argc, uint16_t kwargc, bool opcall
                     return opcall ? RES_CALL : VM__run_top_frame(self);
                 } else {
                     // decl-based binding
-                    self->curr_decl_based_function = p0;
                     bool ok = py_callcfunc(fn->cfunc, co->nlocals, argv);
                     self->stack.sp = p0;
-                    self->curr_decl_based_function = NULL;
                     return ok ? RES_RETURN : RES_ERROR;
                 }
             case FuncType_GENERATOR: {

src/modules/os.c

@@ -215,7 +215,31 @@ static bool io_FileIO_flush(int argc, py_Ref argv) {
     py_newnone(py_retval());
     return true;
 }
-
+static bool io_FileIO_readlines(int argc, py_Ref argv) {
+    PY_CHECK_ARGC(1);
+    io_FileIO* ud = py_touserdata(py_arg(0));
+    py_newlist(py_retval()); 
+    char* buf = NULL;
+    size_t buf_size = 0;
+    size_t len = 0;
+    int c;
+    while(true) {
+        len = 0;
+        while((c = fgetc(ud->file)) != EOF) {
+            if(len + 1 >= buf_size) {
+                buf_size = (buf_size == 0) ? 64 : buf_size * 2;
+                buf = PK_REALLOC(buf, buf_size);
+            }
+            buf[len++] = (char)c;
+            if(c == '\n') break;
+        }
+        if(len == 0) break;
+        py_newstrv(py_getreg(0), (c11_sv){buf, len});
+        py_list_append(py_retval(), py_getreg(0));
+    }
+    if(buf) PK_FREE(buf);
+    return true;
+}
 void pk__add_module_io() {
     py_Ref mod = py_newmodule("io");
 
@@ -230,6 +254,7 @@ void pk__add_module_io() {
     py_bindmethod(FileIO, "tell", io_FileIO_tell);
     py_bindmethod(FileIO, "seek", io_FileIO_seek);
     py_bindmethod(FileIO, "flush", io_FileIO_flush);
+    py_bindmethod(FileIO, "readlines", io_FileIO_readlines);
 
     py_newint(py_emplacedict(mod, py_name("SEEK_SET")), SEEK_SET);
     py_newint(py_emplacedict(mod, py_name("SEEK_CUR")), SEEK_CUR);

src/public/Inspection.c

@@ -3,10 +3,8 @@
 
 py_StackRef py_inspect_currentfunction() {
     VM* vm = pk_current_vm;
-    if(vm->curr_decl_based_function) return vm->curr_decl_based_function;
-    py_Frame* frame = vm->top_frame;
-    if(!frame || frame->is_locals_special) return NULL;
-    return frame->p0;
+    if(vm->curr_function >= vm->stack.sp) return NULL;
+    return vm->curr_function;
 }
 
 py_GlobalRef py_inspect_currentmodule() {