Zxc200611/pocketpy
1
0
Fork 0
mirror of https://github.com/pocketpy/pocketpy synced 2025-10-23 13:00:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

some rename

Browse Source
This commit is contained in:
blueloveTH 2024-05-03 19:45:05 +08:00
parent 9331e8eae0
commit 4f520a0c26
5 changed files with 45 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
include/pocketpy/vm.h
View File

@ -127,17 +127,15 @@ public:
PyObject* StopIteration;
PyObject* _main; // __main__ module
PyObject* _last_exception; // last exception
PyObject* _curr_class; // current class being defined
// typeid -> Type
std::map<const std::type_index, Type> _cxx_typeid_map;
// this is for repr() recursion detection (no need to mark)
std::set<PyObject*> _repr_recursion_set;
// cached code objects for FSTRING_EVAL
std::map<std::string_view, CodeObject_> _cached_codes;
// typeid -> Type
std::map<const std::type_index, Type> _cxx_typeid_map;
PyObject* __last_exception; // last exception
PyObject* __curr_class; // current class being defined
std::map<std::string_view, CodeObject_> __cached_codes;
void (*_ceval_on_step)(VM*, Frame*, Bytecode bc) = nullptr;
@ -396,8 +394,8 @@ public:
#if PK_DEBUG_CEVAL_STEP
void _log_s_data(const char* title = nullptr);
#endif
void _unpack_as_list(ArgsView args, List& list);
void _unpack_as_dict(ArgsView args, Dict& dict);
void __unpack_as_list(ArgsView args, List& list);
void __unpack_as_dict(ArgsView args, Dict& dict);
PyObject* vectorcall(int ARGC, int KWARGC=0, bool op_call=false);
PyObject* py_negate(PyObject* obj);
bool py_bool(PyObject* obj);
@ -405,7 +403,8 @@ public:
PyObject* py_list(PyObject*);
PyObject* new_module(Str name, Str package="");
Str disassemble(CodeObject_ co);
void init_builtin_types();
void __init_builtin_types();
void __post_init_builtin_types();
PyObject* getattr(PyObject* obj, StrName name, bool throw_err=true);
void delattr(PyObject* obj, StrName name);
PyObject* get_unbound_method(PyObject* obj, StrName name, PyObject** self, bool throw_err=true, bool fallback=false);
@ -419,7 +418,6 @@ public:
PyObject* bind_func(PyObject*, StrName, NativeFuncC, UserData userdata={}, BindType bt=BindType::DEFAULT);
void _error(PyObject*);
PyObject* __run_top_frame();
void post_init();
PyObject* __format_string(Str, PyObject*);
PyObject* __py_generator(Frame&& frame, ArgsView buffer);
void __op_unpack_sequence(uint16_t arg);

44
src/ceval.cpp
View File

@ -205,9 +205,9 @@ __NEXT_STEP:;
TOP() = getattr(TOP(), StrName(byte.arg));
} DISPATCH();
case OP_LOAD_CLASS_GLOBAL:{
PK_ASSERT(_curr_class != nullptr);
PK_ASSERT(__curr_class != nullptr);
StrName _name(byte.arg);
PyObject* _0 = getattr(_curr_class, _name, false);
PyObject* _0 = getattr(__curr_class, _name, false);
if(_0 != nullptr) { PUSH(_0); DISPATCH(); }
// load global if attribute not found
_0 = frame->f_globals().try_get_likely_found(_name);
@ -391,7 +391,7 @@ __NEXT_STEP:;
case OP_BUILD_TUPLE_UNPACK: {
auto _lock = heap.gc_scope_lock();
List list;
_unpack_as_list(STACK_VIEW(byte.arg), list);
__unpack_as_list(STACK_VIEW(byte.arg), list);
STACK_SHRINK(byte.arg);
PyObject* _0 = VAR(Tuple(std::move(list)));
PUSH(_0);
@ -399,7 +399,7 @@ __NEXT_STEP:;
case OP_BUILD_LIST_UNPACK: {
auto _lock = heap.gc_scope_lock();
List list;
_unpack_as_list(STACK_VIEW(byte.arg), list);
__unpack_as_list(STACK_VIEW(byte.arg), list);
STACK_SHRINK(byte.arg);
PyObject* _0 = VAR(std::move(list));
PUSH(_0);
@ -407,7 +407,7 @@ __NEXT_STEP:;
case OP_BUILD_DICT_UNPACK: {
auto _lock = heap.gc_scope_lock();
Dict dict(this);
_unpack_as_dict(STACK_VIEW(byte.arg), dict);
__unpack_as_dict(STACK_VIEW(byte.arg), dict);
STACK_SHRINK(byte.arg);
PyObject* _0 = VAR(std::move(dict));
PUSH(_0);
@ -415,7 +415,7 @@ __NEXT_STEP:;
case OP_BUILD_SET_UNPACK: {
auto _lock = heap.gc_scope_lock();
List list;
_unpack_as_list(STACK_VIEW(byte.arg), list);
__unpack_as_list(STACK_VIEW(byte.arg), list);
STACK_SHRINK(byte.arg);
PyObject* _0 = VAR(std::move(list));
_0 = call(builtins->attr(pk_id_set), _0);
@ -645,11 +645,11 @@ __NEXT_STEP:;
case OP_FSTRING_EVAL:{
PyObject* _0 = co->consts[byte.arg];
std::string_view string = CAST(Str&, _0).sv();
auto it = _cached_codes.find(string);
auto it = __cached_codes.find(string);
CodeObject_ code;
if(it == _cached_codes.end()){
if(it == __cached_codes.end()){
code = vm->compile(string, "<eval>", EVAL_MODE, true);
_cached_codes[string] = code;
__cached_codes[string] = code;
}else{
code = it->second;
}
@ -871,39 +871,39 @@ __NEXT_STEP:;
PyObject* _0 = POPX(); // super
if(_0 == None) _0 = _t(tp_object);
check_type(_0, tp_type);
_curr_class = new_type_object(frame->_module, _name, PK_OBJ_GET(Type, _0));
__curr_class = new_type_object(frame->_module, _name, PK_OBJ_GET(Type, _0));
} DISPATCH();
case OP_END_CLASS: {
PK_ASSERT(_curr_class != nullptr);
PK_ASSERT(__curr_class != nullptr);
StrName _name(byte.arg);
frame->_module->attr().set(_name, _curr_class);
frame->_module->attr().set(_name, __curr_class);
// call on_end_subclass
PyTypeInfo* ti = &_all_types[PK_OBJ_GET(Type, _curr_class)];
PyTypeInfo* ti = &_all_types[PK_OBJ_GET(Type, __curr_class)];
if(ti->base != tp_object){
PyTypeInfo* base_ti = &_all_types[ti->base];
if(base_ti->on_end_subclass) base_ti->on_end_subclass(this, ti);
}
_curr_class = nullptr;
__curr_class = nullptr;
} DISPATCH();
case OP_STORE_CLASS_ATTR:{
PK_ASSERT(_curr_class != nullptr);
PK_ASSERT(__curr_class != nullptr);
StrName _name(byte.arg);
PyObject* _0 = POPX();
if(is_type(_0, tp_function)){
PK_OBJ_GET(Function, _0)._class = _curr_class;
PK_OBJ_GET(Function, _0)._class = __curr_class;
}
_curr_class->attr().set(_name, _0);
__curr_class->attr().set(_name, _0);
} DISPATCH();
case OP_BEGIN_CLASS_DECORATION:{
PUSH(_curr_class);
PUSH(__curr_class);
} DISPATCH();
case OP_END_CLASS_DECORATION:{
_curr_class = POPX();
__curr_class = POPX();
} DISPATCH();
case OP_ADD_CLASS_ANNOTATION: {
PK_ASSERT(_curr_class != nullptr);
PK_ASSERT(__curr_class != nullptr);
StrName _name(byte.arg);
Type type = PK_OBJ_GET(Type, _curr_class);
Type type = PK_OBJ_GET(Type, __curr_class);
_all_types[type].annotated_fields.push_back(_name);
} DISPATCH();
/*****************************************/
@ -940,7 +940,7 @@ __NEXT_STEP:;
}
DISPATCH();
case OP_RE_RAISE: __raise(true); DISPATCH();
case OP_POP_EXCEPTION: _last_exception = POPX(); DISPATCH();
case OP_POP_EXCEPTION: __last_exception = POPX(); DISPATCH();
/*****************************************/
case OP_FORMAT_STRING: {
PyObject* _0 = POPX();

8
src/modules.cpp
View File

@ -200,15 +200,15 @@ void add_module_math(VM* vm){
void add_module_traceback(VM* vm){
PyObject* mod = vm->new_module("traceback");
vm->bind_func<0>(mod, "print_exc", [](VM* vm, ArgsView args) {
if(vm->_last_exception==nullptr) vm->ValueError("no exception");
Exception& e = _CAST(Exception&, vm->_last_exception);
if(vm->__last_exception==nullptr) vm->ValueError("no exception");
Exception& e = _CAST(Exception&, vm->__last_exception);
vm->stdout_write(e.summary());
return vm->None;
});
vm->bind_func<0>(mod, "format_exc", [](VM* vm, ArgsView args) {
if(vm->_last_exception==nullptr) vm->ValueError("no exception");
Exception& e = _CAST(Exception&, vm->_last_exception);
if(vm->__last_exception==nullptr) vm->ValueError("no exception");
Exception& e = _CAST(Exception&, vm->__last_exception);
return VAR(e.summary());
});
}

2
src/pocketpy.cpp
View File

@ -1510,7 +1510,7 @@ void init_builtins(VM* _vm) {
_vm->register_user_class<DictItemsIter>(_vm->builtins, "_dict_items_iter");
}
void VM::post_init(){
void VM::__post_init_builtin_types(){
init_builtins(this);
bind_method<-1>(tp_module, "__init__", [](VM* vm, ArgsView args) {

18
src/vm.cpp
View File

@ -78,9 +78,9 @@ namespace pkpy{
_stdout = [](const char* buf, int size) { std::cout.write(buf, size); };
_stderr = [](const char* buf, int size) { std::cerr.write(buf, size); };
_main = nullptr;
_last_exception = nullptr;
__last_exception = nullptr;
_import_handler = [](const char* name_p, int name_size, int* out_size) -> unsigned char*{ return nullptr; };
init_builtin_types();
__init_builtin_types();
}
PyObject* VM::py_str(PyObject* obj){
@ -734,7 +734,7 @@ void VM::_log_s_data(const char* title) {
}
#endif
void VM::init_builtin_types(){
void VM::__init_builtin_types(){
_all_types.push_back({heap._new<Type>(Type(1), Type(0)), -1, nullptr, "object", true});
_all_types.push_back({heap._new<Type>(Type(1), Type(1)), 0, nullptr, "type", false});
@ -802,12 +802,12 @@ void VM::init_builtin_types(){
builtins->attr().set("SyntaxError", _t(tp_syntax_error));
builtins->attr().set("IndentationError", _t(tp_indentation_error));
post_init();
__post_init_builtin_types();
this->_main = new_module("__main__");
}
// `heap.gc_scope_lock();` needed before calling this function
void VM::_unpack_as_list(ArgsView args, List& list){
void VM::__unpack_as_list(ArgsView args, List& list){
for(PyObject* obj: args){
if(is_type(obj, tp_star_wrapper)){
const StarWrapper& w = _CAST(StarWrapper&, obj);
@ -827,7 +827,7 @@ void VM::_unpack_as_list(ArgsView args, List& list){
}
// `heap.gc_scope_lock();` needed before calling this function
void VM::_unpack_as_dict(ArgsView args, Dict& dict){
void VM::__unpack_as_dict(ArgsView args, Dict& dict){
for(PyObject* obj: args){
if(is_type(obj, tp_star_wrapper)){
const StarWrapper& w = _CAST(StarWrapper&, obj);
@ -1321,9 +1321,9 @@ void ManagedHeap::mark() {
for(PyObject* obj: _no_gc) PK_OBJ_MARK(obj);
vm->callstack.apply([](Frame& frame){ frame._gc_mark(); });
for(PyObject* obj: vm->s_data) PK_OBJ_MARK(obj);
for(auto [_, co]: vm->_cached_codes) co->_gc_mark();
if(vm->_last_exception) PK_OBJ_MARK(vm->_last_exception);
if(vm->_curr_class) PK_OBJ_MARK(vm->_curr_class);
for(auto [_, co]: vm->__cached_codes) co->_gc_mark();
if(vm->__last_exception) PK_OBJ_MARK(vm->__last_exception);
if(vm->__curr_class) PK_OBJ_MARK(vm->__curr_class);
if(vm->_c.error != nullptr) PK_OBJ_MARK(vm->_c.error);
if(_gc_marker_ex) _gc_marker_ex(vm);
}