Zxc200611/pocketpy
1
0
Fork 0
mirror of https://github.com/pocketpy/pocketpy synced 2025-10-24 21:40:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

up

Browse Source
This commit is contained in:
blueloveTH 2023-02-03 18:40:03 +08:00
parent 8468747ae2
commit 27f6290605
8 changed files with 237 additions and 237 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
scripts/moc.py
View File

@ -46,7 +46,7 @@ for n in [4,3,2,1]:
impl = '\n'.join([' '*8 + i for i in impl]) impl = '\n'.join([' '*8 + i for i in impl])
s += f'''__EXPORT\nvoid pkpy_vm_bind{name[3:]}(VM* vm, const char* mod, const char* name, {name} f) {{ s += f'''__EXPORT\nvoid pkpy_vm_bind{name[3:]}(VM* vm, const char* mod, const char* name, {name} f) {{
PyVar obj = vm->new_module_if_not_existed(mod); PyVar obj = vm->new_module_if_not_existed(mod);
vm->bindFunc<{len(p_args)}>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {{ vm->bindFunc<{len(p_args)}>(obj, name, [f](VM* vm, const pkpy::Args& args) {{
{impl} {impl}
}}); }});
}}''' + '\n' }}''' + '\n'

250
src/_bindings.h
View File

File diff suppressed because it is too large Load Diff

8
src/codeobject.h
View File

@ -263,10 +263,10 @@ public:
} }
} }
pkpy::ArgList pop_n_values_reversed(VM* vm, int n){ pkpy::Args pop_n_values_reversed(VM* vm, int n){
int new_size = s_data.size() - n; int new_size = s_data.size() - n;
if(new_size < 0) throw std::runtime_error("stack_size() < n"); if(new_size < 0) throw std::runtime_error("stack_size() < n");
pkpy::ArgList v(n); pkpy::Args v(n);
for(int i=n-1; i>=0; i--){ for(int i=n-1; i>=0; i--){
v[i] = std::move(s_data[new_size + i]); v[i] = std::move(s_data[new_size + i]);
try_deref(vm, v[i]); try_deref(vm, v[i]);
@ -275,8 +275,8 @@ public:
return v; return v;
} }
pkpy::ArgList pop_n_reversed(int n){ pkpy::Args pop_n_reversed(int n){
pkpy::ArgList v(n); pkpy::Args v(n);
for(int i=n-1; i>=0; i--) v[i] = pop(); for(int i=n-1; i>=0; i--) v[i] = pop();
return v; return v;
} }

2
src/common.h
View File

@ -41,4 +41,4 @@ typedef int64_t i64;
typedef double f64; typedef double f64;
#define DUMMY_VAL (i64)0 #define DUMMY_VAL (i64)0
#define CPP_LAMBDA(x) ([](VM* vm, const pkpy::ArgList& args) { return x; }) #define CPP_LAMBDA(x) ([](VM* vm, const pkpy::Args& args) { return x; })

6
src/obj.h
View File

@ -7,8 +7,8 @@ struct BaseRef;
class VM; class VM;
class Frame; class Frame;
//typedef PyVar (*_CppFuncRaw)(VM*, const pkpy::ArgList&); //typedef PyVar (*_CppFuncRaw)(VM*, const pkpy::Args&);
typedef std::function<PyVar(VM*, const pkpy::ArgList&)> _CppFuncRaw; typedef std::function<PyVar(VM*, const pkpy::Args&)> _CppFuncRaw;
typedef pkpy::shared_ptr<CodeObject> _Code; typedef pkpy::shared_ptr<CodeObject> _Code;
struct _CppFunc { struct _CppFunc {
@ -17,7 +17,7 @@ struct _CppFunc {
bool method; bool method;
_CppFunc(_CppFuncRaw f, int argc, bool method) : f(f), argc(argc), method(method) {} _CppFunc(_CppFuncRaw f, int argc, bool method) : f(f), argc(argc), method(method) {}
inline PyVar operator()(VM* vm, const pkpy::ArgList& args) const; inline PyVar operator()(VM* vm, const pkpy::Args& args) const;
}; };
struct Function { struct Function {

138
src/pocketpy.h
View File

@ -17,7 +17,7 @@ _Code VM::compile(_Str source, _Str filename, CompileMode mode) {
} }
#define BIND_NUM_ARITH_OPT(name, op) \ #define BIND_NUM_ARITH_OPT(name, op) \
_vm->bindMethodMulti<1>({"int","float"}, #name, [](VM* vm, const pkpy::ArgList& args){ \ _vm->bindMethodMulti<1>({"int","float"}, #name, [](VM* vm, const pkpy::Args& args){ \
if(args[0]->is_type(vm->_tp_int) && args[1]->is_type(vm->_tp_int)){ \ if(args[0]->is_type(vm->_tp_int) && args[1]->is_type(vm->_tp_int)){ \
return vm->PyInt(vm->PyInt_AS_C(args[0]) op vm->PyInt_AS_C(args[1])); \ return vm->PyInt(vm->PyInt_AS_C(args[0]) op vm->PyInt_AS_C(args[1])); \
}else{ \ }else{ \
@ -26,7 +26,7 @@ _Code VM::compile(_Str source, _Str filename, CompileMode mode) {
}); });
#define BIND_NUM_LOGICAL_OPT(name, op, is_eq) \ #define BIND_NUM_LOGICAL_OPT(name, op, is_eq) \
_vm->bindMethodMulti<1>({"int","float"}, #name, [](VM* vm, const pkpy::ArgList& args){ \ _vm->bindMethodMulti<1>({"int","float"}, #name, [](VM* vm, const pkpy::Args& args){ \
bool _0 = args[0]->is_type(vm->_tp_int) || args[0]->is_type(vm->_tp_float); \ bool _0 = args[0]->is_type(vm->_tp_int) || args[0]->is_type(vm->_tp_float); \
bool _1 = args[1]->is_type(vm->_tp_int) || args[1]->is_type(vm->_tp_float); \ bool _1 = args[1]->is_type(vm->_tp_int) || args[1]->is_type(vm->_tp_float); \
if(!_0 || !_1){ \ if(!_0 || !_1){ \
@ -52,23 +52,23 @@ void __initializeBuiltinFunctions(VM* _vm) {
#undef BIND_NUM_ARITH_OPT #undef BIND_NUM_ARITH_OPT
#undef BIND_NUM_LOGICAL_OPT #undef BIND_NUM_LOGICAL_OPT
_vm->bindBuiltinFunc<1>("__sys_stdout_write", [](VM* vm, const pkpy::ArgList& args) { _vm->bindBuiltinFunc<1>("__sys_stdout_write", [](VM* vm, const pkpy::Args& args) {
(*vm->_stdout) << vm->PyStr_AS_C(args[0]); (*vm->_stdout) << vm->PyStr_AS_C(args[0]);
return vm->None; return vm->None;
}); });
_vm->bindBuiltinFunc<0>("super", [](VM* vm, const pkpy::ArgList& args) { _vm->bindBuiltinFunc<0>("super", [](VM* vm, const pkpy::Args& args) {
auto it = vm->top_frame()->f_locals().find(m_self); auto it = vm->top_frame()->f_locals().find(m_self);
if(it == vm->top_frame()->f_locals().end()) vm->typeError("super() can only be called in a class method"); if(it == vm->top_frame()->f_locals().end()) vm->typeError("super() can only be called in a class method");
return vm->new_object(vm->_tp_super, it->second); return vm->new_object(vm->_tp_super, it->second);
}); });
_vm->bindBuiltinFunc<1>("eval", [](VM* vm, const pkpy::ArgList& args) { _vm->bindBuiltinFunc<1>("eval", [](VM* vm, const pkpy::Args& args) {
_Code code = vm->compile(vm->PyStr_AS_C(args[0]), "<eval>", EVAL_MODE); _Code code = vm->compile(vm->PyStr_AS_C(args[0]), "<eval>", EVAL_MODE);
return vm->_exec(code, vm->top_frame()->_module, vm->top_frame()->_locals); return vm->_exec(code, vm->top_frame()->_module, vm->top_frame()->_locals);
}); });
_vm->bindBuiltinFunc<1>("exec", [](VM* vm, const pkpy::ArgList& args) { _vm->bindBuiltinFunc<1>("exec", [](VM* vm, const pkpy::Args& args) {
_Code code = vm->compile(vm->PyStr_AS_C(args[0]), "<exec>", EXEC_MODE); _Code code = vm->compile(vm->PyStr_AS_C(args[0]), "<exec>", EXEC_MODE);
vm->_exec(code, vm->top_frame()->_module, vm->top_frame()->_locals); vm->_exec(code, vm->top_frame()->_module, vm->top_frame()->_locals);
return vm->None; return vm->None;
@ -78,40 +78,40 @@ void __initializeBuiltinFunctions(VM* _vm) {
_vm->bindBuiltinFunc<1>("hash", CPP_LAMBDA(vm->PyInt(vm->hash(args[0])))); _vm->bindBuiltinFunc<1>("hash", CPP_LAMBDA(vm->PyInt(vm->hash(args[0]))));
_vm->bindBuiltinFunc<1>("len", CPP_LAMBDA(vm->call(args[0], __len__, pkpy::noArg()))); _vm->bindBuiltinFunc<1>("len", CPP_LAMBDA(vm->call(args[0], __len__, pkpy::noArg())));
_vm->bindBuiltinFunc<1>("chr", [](VM* vm, const pkpy::ArgList& args) { _vm->bindBuiltinFunc<1>("chr", [](VM* vm, const pkpy::Args& args) {
i64 i = vm->PyInt_AS_C(args[0]); i64 i = vm->PyInt_AS_C(args[0]);
if (i < 0 || i > 128) vm->valueError("chr() arg not in range(128)"); if (i < 0 || i > 128) vm->valueError("chr() arg not in range(128)");
return vm->PyStr(std::string(1, (char)i)); return vm->PyStr(std::string(1, (char)i));
}); });
_vm->bindBuiltinFunc<1>("ord", [](VM* vm, const pkpy::ArgList& args) { _vm->bindBuiltinFunc<1>("ord", [](VM* vm, const pkpy::Args& args) {
_Str s = vm->PyStr_AS_C(args[0]); _Str s = vm->PyStr_AS_C(args[0]);
if (s.size() != 1) vm->typeError("ord() expected an ASCII character"); if (s.size() != 1) vm->typeError("ord() expected an ASCII character");
return vm->PyInt((i64)(s.c_str()[0])); return vm->PyInt((i64)(s.c_str()[0]));
}); });
_vm->bindBuiltinFunc<2>("hasattr", [](VM* vm, const pkpy::ArgList& args) { _vm->bindBuiltinFunc<2>("hasattr", [](VM* vm, const pkpy::Args& args) {
return vm->PyBool(vm->getattr(args[0], vm->PyStr_AS_C(args[1]), false) != nullptr); return vm->PyBool(vm->getattr(args[0], vm->PyStr_AS_C(args[1]), false) != nullptr);
}); });
_vm->bindBuiltinFunc<3>("setattr", [](VM* vm, const pkpy::ArgList& args) { _vm->bindBuiltinFunc<3>("setattr", [](VM* vm, const pkpy::Args& args) {
PyVar obj = args[0]; PyVar obj = args[0];
vm->setattr(obj, vm->PyStr_AS_C(args[1]), args[2]); vm->setattr(obj, vm->PyStr_AS_C(args[1]), args[2]);
return vm->None; return vm->None;
}); });
_vm->bindBuiltinFunc<2>("getattr", [](VM* vm, const pkpy::ArgList& args) { _vm->bindBuiltinFunc<2>("getattr", [](VM* vm, const pkpy::Args& args) {
_Str name = vm->PyStr_AS_C(args[1]); _Str name = vm->PyStr_AS_C(args[1]);
return vm->getattr(args[0], name); return vm->getattr(args[0], name);
}); });
_vm->bindBuiltinFunc<1>("hex", [](VM* vm, const pkpy::ArgList& args) { _vm->bindBuiltinFunc<1>("hex", [](VM* vm, const pkpy::Args& args) {
std::stringstream ss; std::stringstream ss;
ss << std::hex << vm->PyInt_AS_C(args[0]); ss << std::hex << vm->PyInt_AS_C(args[0]);
return vm->PyStr("0x" + ss.str()); return vm->PyStr("0x" + ss.str());
}); });
_vm->bindBuiltinFunc<1>("dir", [](VM* vm, const pkpy::ArgList& args) { _vm->bindBuiltinFunc<1>("dir", [](VM* vm, const pkpy::Args& args) {
std::vector<_Str> names; std::vector<_Str> names;
for (auto& [k, _] : args[0]->attribs) names.push_back(k); for (auto& [k, _] : args[0]->attribs) names.push_back(k);
for (auto& [k, _] : args[0]->_type->attribs) { for (auto& [k, _] : args[0]->_type->attribs) {
@ -126,7 +126,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
return vm->PyList(ret); return vm->PyList(ret);
}); });
_vm->bindMethod<0>("object", "__repr__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<0>("object", "__repr__", [](VM* vm, const pkpy::Args& args) {
PyVar _self = args[0]; PyVar _self = args[0];
std::stringstream ss; std::stringstream ss;
ss << std::hex << (uintptr_t)_self.get(); ss << std::hex << (uintptr_t)_self.get();
@ -138,7 +138,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
_vm->bindMethod<1>("object", "__ne__", CPP_LAMBDA(vm->PyBool(args[0] != args[1]))); _vm->bindMethod<1>("object", "__ne__", CPP_LAMBDA(vm->PyBool(args[0] != args[1])));
_vm->bindStaticMethod<1>("type", "__new__", CPP_LAMBDA(args[0]->_type)); _vm->bindStaticMethod<1>("type", "__new__", CPP_LAMBDA(args[0]->_type));
_vm->bindStaticMethod<-1>("range", "__new__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindStaticMethod<-1>("range", "__new__", [](VM* vm, const pkpy::Args& args) {
_Range r; _Range r;
switch (args.size()) { switch (args.size()) {
case 1: r.stop = vm->PyInt_AS_C(args[0]); break; case 1: r.stop = vm->PyInt_AS_C(args[0]); break;
@ -156,13 +156,13 @@ void __initializeBuiltinFunctions(VM* _vm) {
_vm->bindMethod<0>("NoneType", "__repr__", CPP_LAMBDA(vm->PyStr("None"))); _vm->bindMethod<0>("NoneType", "__repr__", CPP_LAMBDA(vm->PyStr("None")));
_vm->bindMethod<0>("NoneType", "__json__", CPP_LAMBDA(vm->PyStr("null"))); _vm->bindMethod<0>("NoneType", "__json__", CPP_LAMBDA(vm->PyStr("null")));
_vm->bindMethodMulti<1>({"int", "float"}, "__truediv__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethodMulti<1>({"int", "float"}, "__truediv__", [](VM* vm, const pkpy::Args& args) {
f64 rhs = vm->num_to_float(args[1]); f64 rhs = vm->num_to_float(args[1]);
if (rhs == 0) vm->zeroDivisionError(); if (rhs == 0) vm->zeroDivisionError();
return vm->PyFloat(vm->num_to_float(args[0]) / rhs); return vm->PyFloat(vm->num_to_float(args[0]) / rhs);
}); });
_vm->bindMethodMulti<1>({"int", "float"}, "__pow__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethodMulti<1>({"int", "float"}, "__pow__", [](VM* vm, const pkpy::Args& args) {
if(args[0]->is_type(vm->_tp_int) && args[1]->is_type(vm->_tp_int)){ if(args[0]->is_type(vm->_tp_int) && args[1]->is_type(vm->_tp_int)){
return vm->PyInt((i64)round(pow(vm->PyInt_AS_C(args[0]), vm->PyInt_AS_C(args[1])))); return vm->PyInt((i64)round(pow(vm->PyInt_AS_C(args[0]), vm->PyInt_AS_C(args[1]))));
}else{ }else{
@ -171,7 +171,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
}); });
/************ PyInt ************/ /************ PyInt ************/
_vm->bindStaticMethod<1>("int", "__new__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindStaticMethod<1>("int", "__new__", [](VM* vm, const pkpy::Args& args) {
if (args[0]->is_type(vm->_tp_int)) return args[0]; if (args[0]->is_type(vm->_tp_int)) return args[0];
if (args[0]->is_type(vm->_tp_float)) return vm->PyInt((i64)vm->PyFloat_AS_C(args[0])); if (args[0]->is_type(vm->_tp_float)) return vm->PyInt((i64)vm->PyFloat_AS_C(args[0]));
if (args[0]->is_type(vm->_tp_bool)) return vm->PyInt(vm->PyBool_AS_C(args[0]) ? 1 : 0); if (args[0]->is_type(vm->_tp_bool)) return vm->PyInt(vm->PyBool_AS_C(args[0]) ? 1 : 0);
@ -190,28 +190,28 @@ void __initializeBuiltinFunctions(VM* _vm) {
return vm->None; return vm->None;
}); });
_vm->bindMethod<1>("int", "__floordiv__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<1>("int", "__floordiv__", [](VM* vm, const pkpy::Args& args) {
i64 rhs = vm->PyInt_AS_C(args[1]); i64 rhs = vm->PyInt_AS_C(args[1]);
if(rhs == 0) vm->zeroDivisionError(); if(rhs == 0) vm->zeroDivisionError();
return vm->PyInt(vm->PyInt_AS_C(args[0]) / rhs); return vm->PyInt(vm->PyInt_AS_C(args[0]) / rhs);
}); });
_vm->bindMethod<1>("int", "__mod__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<1>("int", "__mod__", [](VM* vm, const pkpy::Args& args) {
i64 rhs = vm->PyInt_AS_C(args[1]); i64 rhs = vm->PyInt_AS_C(args[1]);
if(rhs == 0) vm->zeroDivisionError(); if(rhs == 0) vm->zeroDivisionError();
return vm->PyInt(vm->PyInt_AS_C(args[0]) % rhs); return vm->PyInt(vm->PyInt_AS_C(args[0]) % rhs);
}); });
_vm->bindMethod<0>("int", "__repr__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<0>("int", "__repr__", [](VM* vm, const pkpy::Args& args) {
return vm->PyStr(std::to_string(vm->PyInt_AS_C(args[0]))); return vm->PyStr(std::to_string(vm->PyInt_AS_C(args[0])));
}); });
_vm->bindMethod<0>("int", "__json__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<0>("int", "__json__", [](VM* vm, const pkpy::Args& args) {
return vm->PyStr(std::to_string((int)vm->PyInt_AS_C(args[0]))); return vm->PyStr(std::to_string((int)vm->PyInt_AS_C(args[0])));
}); });
#define __INT_BITWISE_OP(name,op) \ #define __INT_BITWISE_OP(name,op) \
_vm->bindMethod<1>("int", #name, [](VM* vm, const pkpy::ArgList& args) { \ _vm->bindMethod<1>("int", #name, [](VM* vm, const pkpy::Args& args) { \
return vm->PyInt(vm->PyInt_AS_C(args[0]) op vm->PyInt_AS_C(args[1])); \ return vm->PyInt(vm->PyInt_AS_C(args[0]) op vm->PyInt_AS_C(args[1])); \
}); });
@ -224,7 +224,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
#undef __INT_BITWISE_OP #undef __INT_BITWISE_OP
/************ PyFloat ************/ /************ PyFloat ************/
_vm->bindStaticMethod<1>("float", "__new__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindStaticMethod<1>("float", "__new__", [](VM* vm, const pkpy::Args& args) {
if (args[0]->is_type(vm->_tp_int)) return vm->PyFloat((f64)vm->PyInt_AS_C(args[0])); if (args[0]->is_type(vm->_tp_int)) return vm->PyFloat((f64)vm->PyInt_AS_C(args[0]));
if (args[0]->is_type(vm->_tp_float)) return args[0]; if (args[0]->is_type(vm->_tp_float)) return args[0];
if (args[0]->is_type(vm->_tp_bool)) return vm->PyFloat(vm->PyBool_AS_C(args[0]) ? 1.0 : 0.0); if (args[0]->is_type(vm->_tp_bool)) return vm->PyFloat(vm->PyBool_AS_C(args[0]) ? 1.0 : 0.0);
@ -243,7 +243,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
return vm->None; return vm->None;
}); });
_vm->bindMethod<0>("float", "__repr__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<0>("float", "__repr__", [](VM* vm, const pkpy::Args& args) {
f64 val = vm->PyFloat_AS_C(args[0]); f64 val = vm->PyFloat_AS_C(args[0]);
if(std::isinf(val) || std::isnan(val)) return vm->PyStr(std::to_string(val)); if(std::isinf(val) || std::isnan(val)) return vm->PyStr(std::to_string(val));
_StrStream ss; _StrStream ss;
@ -253,7 +253,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
return vm->PyStr(s); return vm->PyStr(s);
}); });
_vm->bindMethod<0>("float", "__json__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<0>("float", "__json__", [](VM* vm, const pkpy::Args& args) {
f64 val = vm->PyFloat_AS_C(args[0]); f64 val = vm->PyFloat_AS_C(args[0]);
if(std::isinf(val) || std::isnan(val)) vm->valueError("cannot jsonify 'nan' or 'inf'"); if(std::isinf(val) || std::isnan(val)) vm->valueError("cannot jsonify 'nan' or 'inf'");
return vm->PyStr(std::to_string(val)); return vm->PyStr(std::to_string(val));
@ -262,18 +262,18 @@ void __initializeBuiltinFunctions(VM* _vm) {
/************ PyString ************/ /************ PyString ************/
_vm->bindStaticMethod<1>("str", "__new__", CPP_LAMBDA(vm->asStr(args[0]))); _vm->bindStaticMethod<1>("str", "__new__", CPP_LAMBDA(vm->asStr(args[0])));
_vm->bindMethod<1>("str", "__add__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<1>("str", "__add__", [](VM* vm, const pkpy::Args& args) {
const _Str& lhs = vm->PyStr_AS_C(args[0]); const _Str& lhs = vm->PyStr_AS_C(args[0]);
const _Str& rhs = vm->PyStr_AS_C(args[1]); const _Str& rhs = vm->PyStr_AS_C(args[1]);
return vm->PyStr(lhs + rhs); return vm->PyStr(lhs + rhs);
}); });
_vm->bindMethod<0>("str", "__len__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<0>("str", "__len__", [](VM* vm, const pkpy::Args& args) {
const _Str& _self = vm->PyStr_AS_C(args[0]); const _Str& _self = vm->PyStr_AS_C(args[0]);
return vm->PyInt(_self.u8_length()); return vm->PyInt(_self.u8_length());
}); });
_vm->bindMethod<1>("str", "__contains__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<1>("str", "__contains__", [](VM* vm, const pkpy::Args& args) {
const _Str& _self = vm->PyStr_AS_C(args[0]); const _Str& _self = vm->PyStr_AS_C(args[0]);
const _Str& _other = vm->PyStr_AS_C(args[1]); const _Str& _other = vm->PyStr_AS_C(args[1]);
return vm->PyBool(_self.find(_other) != _Str::npos); return vm->PyBool(_self.find(_other) != _Str::npos);
@ -285,29 +285,29 @@ void __initializeBuiltinFunctions(VM* _vm) {
vm->PyIter(pkpy::make_shared<BaseIterator, StringIterator>(vm, args[0])) vm->PyIter(pkpy::make_shared<BaseIterator, StringIterator>(vm, args[0]))
)); ));
_vm->bindMethod<0>("str", "__repr__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<0>("str", "__repr__", [](VM* vm, const pkpy::Args& args) {
const _Str& _self = vm->PyStr_AS_C(args[0]); const _Str& _self = vm->PyStr_AS_C(args[0]);
return vm->PyStr(_self.__escape(true)); return vm->PyStr(_self.__escape(true));
}); });
_vm->bindMethod<0>("str", "__json__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<0>("str", "__json__", [](VM* vm, const pkpy::Args& args) {
const _Str& _self = vm->PyStr_AS_C(args[0]); const _Str& _self = vm->PyStr_AS_C(args[0]);
return vm->PyStr(_self.__escape(false)); return vm->PyStr(_self.__escape(false));
}); });
_vm->bindMethod<1>("str", "__eq__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<1>("str", "__eq__", [](VM* vm, const pkpy::Args& args) {
if(args[0]->is_type(vm->_tp_str) && args[1]->is_type(vm->_tp_str)) if(args[0]->is_type(vm->_tp_str) && args[1]->is_type(vm->_tp_str))
return vm->PyBool(vm->PyStr_AS_C(args[0]) == vm->PyStr_AS_C(args[1])); return vm->PyBool(vm->PyStr_AS_C(args[0]) == vm->PyStr_AS_C(args[1]));
return vm->PyBool(args[0] == args[1]); return vm->PyBool(args[0] == args[1]);
}); });
_vm->bindMethod<1>("str", "__ne__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<1>("str", "__ne__", [](VM* vm, const pkpy::Args& args) {
if(args[0]->is_type(vm->_tp_str) && args[1]->is_type(vm->_tp_str)) if(args[0]->is_type(vm->_tp_str) && args[1]->is_type(vm->_tp_str))
return vm->PyBool(vm->PyStr_AS_C(args[0]) != vm->PyStr_AS_C(args[1])); return vm->PyBool(vm->PyStr_AS_C(args[0]) != vm->PyStr_AS_C(args[1]));
return vm->PyBool(args[0] != args[1]); return vm->PyBool(args[0] != args[1]);
}); });
_vm->bindMethod<1>("str", "__getitem__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<1>("str", "__getitem__", [](VM* vm, const pkpy::Args& args) {
const _Str& _self (vm->PyStr_AS_C(args[0])); const _Str& _self (vm->PyStr_AS_C(args[0]));
if(args[1]->is_type(vm->_tp_slice)){ if(args[1]->is_type(vm->_tp_slice)){
@ -321,19 +321,19 @@ void __initializeBuiltinFunctions(VM* _vm) {
return vm->PyStr(_self.u8_getitem(_index)); return vm->PyStr(_self.u8_getitem(_index));
}); });
_vm->bindMethod<1>("str", "__gt__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<1>("str", "__gt__", [](VM* vm, const pkpy::Args& args) {
const _Str& _self (vm->PyStr_AS_C(args[0])); const _Str& _self (vm->PyStr_AS_C(args[0]));
const _Str& _obj (vm->PyStr_AS_C(args[1])); const _Str& _obj (vm->PyStr_AS_C(args[1]));
return vm->PyBool(_self > _obj); return vm->PyBool(_self > _obj);
}); });
_vm->bindMethod<1>("str", "__lt__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<1>("str", "__lt__", [](VM* vm, const pkpy::Args& args) {
const _Str& _self (vm->PyStr_AS_C(args[0])); const _Str& _self (vm->PyStr_AS_C(args[0]));
const _Str& _obj (vm->PyStr_AS_C(args[1])); const _Str& _obj (vm->PyStr_AS_C(args[1]));
return vm->PyBool(_self < _obj); return vm->PyBool(_self < _obj);
}); });
_vm->bindMethod<2>("str", "replace", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<2>("str", "replace", [](VM* vm, const pkpy::Args& args) {
const _Str& _self = vm->PyStr_AS_C(args[0]); const _Str& _self = vm->PyStr_AS_C(args[0]);
const _Str& _old = vm->PyStr_AS_C(args[1]); const _Str& _old = vm->PyStr_AS_C(args[1]);
const _Str& _new = vm->PyStr_AS_C(args[2]); const _Str& _new = vm->PyStr_AS_C(args[2]);
@ -347,19 +347,19 @@ void __initializeBuiltinFunctions(VM* _vm) {
return vm->PyStr(_copy); return vm->PyStr(_copy);
}); });
_vm->bindMethod<1>("str", "startswith", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<1>("str", "startswith", [](VM* vm, const pkpy::Args& args) {
const _Str& _self = vm->PyStr_AS_C(args[0]); const _Str& _self = vm->PyStr_AS_C(args[0]);
const _Str& _prefix = vm->PyStr_AS_C(args[1]); const _Str& _prefix = vm->PyStr_AS_C(args[1]);
return vm->PyBool(_self.find(_prefix) == 0); return vm->PyBool(_self.find(_prefix) == 0);
}); });
_vm->bindMethod<1>("str", "endswith", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<1>("str", "endswith", [](VM* vm, const pkpy::Args& args) {
const _Str& _self = vm->PyStr_AS_C(args[0]); const _Str& _self = vm->PyStr_AS_C(args[0]);
const _Str& _suffix = vm->PyStr_AS_C(args[1]); const _Str& _suffix = vm->PyStr_AS_C(args[1]);
return vm->PyBool(_self.rfind(_suffix) == _self.length() - _suffix.length()); return vm->PyBool(_self.rfind(_suffix) == _self.length() - _suffix.length());
}); });
_vm->bindMethod<1>("str", "join", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<1>("str", "join", [](VM* vm, const pkpy::Args& args) {
const _Str& _self = vm->PyStr_AS_C(args[0]); const _Str& _self = vm->PyStr_AS_C(args[0]);
PyVarList* _list; PyVarList* _list;
if(args[1]->is_type(vm->_tp_list)){ if(args[1]->is_type(vm->_tp_list)){
@ -378,19 +378,19 @@ void __initializeBuiltinFunctions(VM* _vm) {
}); });
/************ PyList ************/ /************ PyList ************/
_vm->bindMethod<0>("list", "__iter__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<0>("list", "__iter__", [](VM* vm, const pkpy::Args& args) {
return vm->PyIter( return vm->PyIter(
pkpy::make_shared<BaseIterator, VectorIterator>(vm, args[0]) pkpy::make_shared<BaseIterator, VectorIterator>(vm, args[0])
); );
}); });
_vm->bindMethod<1>("list", "append", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<1>("list", "append", [](VM* vm, const pkpy::Args& args) {
PyVarList& _self = vm->PyList_AS_C(args[0]); PyVarList& _self = vm->PyList_AS_C(args[0]);
_self.push_back(args[1]); _self.push_back(args[1]);
return vm->None; return vm->None;
}); });
_vm->bindMethod<2>("list", "insert", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<2>("list", "insert", [](VM* vm, const pkpy::Args& args) {
PyVarList& _self = vm->PyList_AS_C(args[0]); PyVarList& _self = vm->PyList_AS_C(args[0]);
int _index = (int)vm->PyInt_AS_C(args[1]); int _index = (int)vm->PyInt_AS_C(args[1]);
if(_index < 0) _index += _self.size(); if(_index < 0) _index += _self.size();
@ -400,16 +400,16 @@ void __initializeBuiltinFunctions(VM* _vm) {
return vm->None; return vm->None;
}); });
_vm->bindMethod<0>("list", "clear", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<0>("list", "clear", [](VM* vm, const pkpy::Args& args) {
vm->PyList_AS_C(args[0]).clear(); vm->PyList_AS_C(args[0]).clear();
return vm->None; return vm->None;
}); });
_vm->bindMethod<0>("list", "copy", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<0>("list", "copy", [](VM* vm, const pkpy::Args& args) {
return vm->PyList(vm->PyList_AS_C(args[0])); return vm->PyList(vm->PyList_AS_C(args[0]));
}); });
_vm->bindMethod<1>("list", "__add__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<1>("list", "__add__", [](VM* vm, const pkpy::Args& args) {
const PyVarList& _self = vm->PyList_AS_C(args[0]); const PyVarList& _self = vm->PyList_AS_C(args[0]);
const PyVarList& _obj = vm->PyList_AS_C(args[1]); const PyVarList& _obj = vm->PyList_AS_C(args[1]);
PyVarList _new_list = _self; PyVarList _new_list = _self;
@ -417,12 +417,12 @@ void __initializeBuiltinFunctions(VM* _vm) {
return vm->PyList(_new_list); return vm->PyList(_new_list);
}); });
_vm->bindMethod<0>("list", "__len__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<0>("list", "__len__", [](VM* vm, const pkpy::Args& args) {
const PyVarList& _self = vm->PyList_AS_C(args[0]); const PyVarList& _self = vm->PyList_AS_C(args[0]);
return vm->PyInt(_self.size()); return vm->PyInt(_self.size());
}); });
_vm->bindMethodMulti<1>({"list", "tuple"}, "__getitem__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethodMulti<1>({"list", "tuple"}, "__getitem__", [](VM* vm, const pkpy::Args& args) {
bool list = args[0]->is_type(vm->_tp_list); bool list = args[0]->is_type(vm->_tp_list);
const PyVarList& _self = list ? vm->PyList_AS_C(args[0]) : vm->PyTuple_AS_C(args[0]); const PyVarList& _self = list ? vm->PyList_AS_C(args[0]) : vm->PyTuple_AS_C(args[0]);
@ -439,7 +439,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
return _self[_index]; return _self[_index];
}); });
_vm->bindMethod<2>("list", "__setitem__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<2>("list", "__setitem__", [](VM* vm, const pkpy::Args& args) {
PyVarList& _self = vm->PyList_AS_C(args[0]); PyVarList& _self = vm->PyList_AS_C(args[0]);
int _index = (int)vm->PyInt_AS_C(args[1]); int _index = (int)vm->PyInt_AS_C(args[1]);
_index = vm->normalized_index(_index, _self.size()); _index = vm->normalized_index(_index, _self.size());
@ -447,7 +447,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
return vm->None; return vm->None;
}); });
_vm->bindMethod<1>("list", "__delitem__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<1>("list", "__delitem__", [](VM* vm, const pkpy::Args& args) {
PyVarList& _self = vm->PyList_AS_C(args[0]); PyVarList& _self = vm->PyList_AS_C(args[0]);
int _index = (int)vm->PyInt_AS_C(args[1]); int _index = (int)vm->PyInt_AS_C(args[1]);
_index = vm->normalized_index(_index, _self.size()); _index = vm->normalized_index(_index, _self.size());
@ -456,16 +456,16 @@ void __initializeBuiltinFunctions(VM* _vm) {
}); });
/************ PyTuple ************/ /************ PyTuple ************/
_vm->bindStaticMethod<1>("tuple", "__new__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindStaticMethod<1>("tuple", "__new__", [](VM* vm, const pkpy::Args& args) {
PyVarList _list = vm->PyList_AS_C(vm->call(vm->builtins->attribs["list"], args)); PyVarList _list = vm->PyList_AS_C(vm->call(vm->builtins->attribs["list"], args));
return vm->PyTuple(_list); return vm->PyTuple(_list);
}); });
_vm->bindMethod<0>("tuple", "__iter__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<0>("tuple", "__iter__", [](VM* vm, const pkpy::Args& args) {
return vm->PyIter(pkpy::make_shared<BaseIterator, VectorIterator>(vm, args[0])); return vm->PyIter(pkpy::make_shared<BaseIterator, VectorIterator>(vm, args[0]));
}); });
_vm->bindMethod<0>("tuple", "__len__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<0>("tuple", "__len__", [](VM* vm, const pkpy::Args& args) {
const PyVarList& _self = vm->PyTuple_AS_C(args[0]); const PyVarList& _self = vm->PyTuple_AS_C(args[0]);
return vm->PyInt(_self.size()); return vm->PyInt(_self.size());
}); });
@ -473,17 +473,17 @@ void __initializeBuiltinFunctions(VM* _vm) {
/************ PyBool ************/ /************ PyBool ************/
_vm->bindStaticMethod<1>("bool", "__new__", CPP_LAMBDA(vm->asBool(args[0]))); _vm->bindStaticMethod<1>("bool", "__new__", CPP_LAMBDA(vm->asBool(args[0])));
_vm->bindMethod<0>("bool", "__repr__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<0>("bool", "__repr__", [](VM* vm, const pkpy::Args& args) {
bool val = vm->PyBool_AS_C(args[0]); bool val = vm->PyBool_AS_C(args[0]);
return vm->PyStr(val ? "True" : "False"); return vm->PyStr(val ? "True" : "False");
}); });
_vm->bindMethod<0>("bool", "__json__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<0>("bool", "__json__", [](VM* vm, const pkpy::Args& args) {
bool val = vm->PyBool_AS_C(args[0]); bool val = vm->PyBool_AS_C(args[0]);
return vm->PyStr(val ? "true" : "false"); return vm->PyStr(val ? "true" : "false");
}); });
_vm->bindMethod<1>("bool", "__xor__", [](VM* vm, const pkpy::ArgList& args) { _vm->bindMethod<1>("bool", "__xor__", [](VM* vm, const pkpy::Args& args) {
bool _self = vm->PyBool_AS_C(args[0]); bool _self = vm->PyBool_AS_C(args[0]);
bool _obj = vm->PyBool_AS_C(args[1]); bool _obj = vm->PyBool_AS_C(args[1]);
return vm->PyBool(_self ^ _obj); return vm->PyBool(_self ^ _obj);
@ -508,7 +508,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
void __add_module_time(VM* vm){ void __add_module_time(VM* vm){
PyVar mod = vm->new_module("time"); PyVar mod = vm->new_module("time");
vm->bindFunc<0>(mod, "time", [](VM* vm, const pkpy::ArgList& args) { vm->bindFunc<0>(mod, "time", [](VM* vm, const pkpy::Args& args) {
auto now = std::chrono::high_resolution_clock::now(); auto now = std::chrono::high_resolution_clock::now();
return vm->PyFloat(std::chrono::duration_cast<std::chrono::microseconds>(now.time_since_epoch()).count() / 1000000.0); return vm->PyFloat(std::chrono::duration_cast<std::chrono::microseconds>(now.time_since_epoch()).count() / 1000000.0);
}); });
@ -516,15 +516,15 @@ void __add_module_time(VM* vm){
void __add_module_sys(VM* vm){ void __add_module_sys(VM* vm){
PyVar mod = vm->new_module("sys"); PyVar mod = vm->new_module("sys");
vm->bindFunc<1>(mod, "getrefcount", [](VM* vm, const pkpy::ArgList& args) { vm->bindFunc<1>(mod, "getrefcount", [](VM* vm, const pkpy::Args& args) {
return vm->PyInt(args[0].use_count()); return vm->PyInt(args[0].use_count());
}); });
vm->bindFunc<0>(mod, "getrecursionlimit", [](VM* vm, const pkpy::ArgList& args) { vm->bindFunc<0>(mod, "getrecursionlimit", [](VM* vm, const pkpy::Args& args) {
return vm->PyInt(vm->maxRecursionDepth); return vm->PyInt(vm->maxRecursionDepth);
}); });
vm->bindFunc<1>(mod, "setrecursionlimit", [](VM* vm, const pkpy::ArgList& args) { vm->bindFunc<1>(mod, "setrecursionlimit", [](VM* vm, const pkpy::Args& args) {
vm->maxRecursionDepth = (int)vm->PyInt_AS_C(args[0]); vm->maxRecursionDepth = (int)vm->PyInt_AS_C(args[0]);
return vm->None; return vm->None;
}); });
@ -534,13 +534,13 @@ void __add_module_sys(VM* vm){
void __add_module_json(VM* vm){ void __add_module_json(VM* vm){
PyVar mod = vm->new_module("json"); PyVar mod = vm->new_module("json");
vm->bindFunc<1>(mod, "loads", [](VM* vm, const pkpy::ArgList& args) { vm->bindFunc<1>(mod, "loads", [](VM* vm, const pkpy::Args& args) {
const _Str& expr = vm->PyStr_AS_C(args[0]); const _Str& expr = vm->PyStr_AS_C(args[0]);
_Code code = vm->compile(expr, "<json>", JSON_MODE); _Code code = vm->compile(expr, "<json>", JSON_MODE);
return vm->_exec(code, vm->top_frame()->_module, vm->top_frame()->_locals); return vm->_exec(code, vm->top_frame()->_module, vm->top_frame()->_locals);
}); });
vm->bindFunc<1>(mod, "dumps", [](VM* vm, const pkpy::ArgList& args) { vm->bindFunc<1>(mod, "dumps", [](VM* vm, const pkpy::Args& args) {
return vm->asJson(args[0]); return vm->asJson(args[0]);
}); });
} }
@ -562,7 +562,7 @@ void __add_module_math(VM* vm){
void __add_module_dis(VM* vm){ void __add_module_dis(VM* vm){
PyVar mod = vm->new_module("dis"); PyVar mod = vm->new_module("dis");
vm->bindFunc<1>(mod, "dis", [](VM* vm, const pkpy::ArgList& args) { vm->bindFunc<1>(mod, "dis", [](VM* vm, const pkpy::Args& args) {
_Code code = vm->PyFunction_AS_C(args[0])->code; _Code code = vm->PyFunction_AS_C(args[0])->code;
(*vm->_stdout) << vm->disassemble(code); (*vm->_stdout) << vm->disassemble(code);
return vm->None; return vm->None;
@ -584,12 +584,12 @@ struct ReMatch {
vm->bindMethod<0>(_tp_match, "start", CPP_LAMBDA(vm->PyInt(UNION_GET(ReMatch, args[0]).start))); vm->bindMethod<0>(_tp_match, "start", CPP_LAMBDA(vm->PyInt(UNION_GET(ReMatch, args[0]).start)));
vm->bindMethod<0>(_tp_match, "end", CPP_LAMBDA(vm->PyInt(UNION_GET(ReMatch, args[0]).end))); vm->bindMethod<0>(_tp_match, "end", CPP_LAMBDA(vm->PyInt(UNION_GET(ReMatch, args[0]).end)));
vm->bindMethod<0>(_tp_match, "span", [](VM* vm, const pkpy::ArgList& args) { vm->bindMethod<0>(_tp_match, "span", [](VM* vm, const pkpy::Args& args) {
auto& m = UNION_GET(ReMatch, args[0]); auto& m = UNION_GET(ReMatch, args[0]);
return vm->PyTuple({ vm->PyInt(m.start), vm->PyInt(m.end) }); return vm->PyTuple({ vm->PyInt(m.start), vm->PyInt(m.end) });
}); });
vm->bindMethod<1>(_tp_match, "group", [](VM* vm, const pkpy::ArgList& args) { vm->bindMethod<1>(_tp_match, "group", [](VM* vm, const pkpy::Args& args) {
auto& m = UNION_GET(ReMatch, args[0]); auto& m = UNION_GET(ReMatch, args[0]);
int index = (int)vm->PyInt_AS_C(args[1]); int index = (int)vm->PyInt_AS_C(args[1]);
index = vm->normalized_index(index, m.m.size()); index = vm->normalized_index(index, m.m.size());
@ -615,19 +615,19 @@ void __add_module_re(VM* vm){
PyVar mod = vm->new_module("re"); PyVar mod = vm->new_module("re");
ReMatch::_bind(vm); ReMatch::_bind(vm);
vm->bindFunc<2>(mod, "match", [](VM* vm, const pkpy::ArgList& args) { vm->bindFunc<2>(mod, "match", [](VM* vm, const pkpy::Args& args) {
const _Str& pattern = vm->PyStr_AS_C(args[0]); const _Str& pattern = vm->PyStr_AS_C(args[0]);
const _Str& string = vm->PyStr_AS_C(args[1]); const _Str& string = vm->PyStr_AS_C(args[1]);
return __regex_search(pattern, string, true, vm); return __regex_search(pattern, string, true, vm);
}); });
vm->bindFunc<2>(mod, "search", [](VM* vm, const pkpy::ArgList& args) { vm->bindFunc<2>(mod, "search", [](VM* vm, const pkpy::Args& args) {
const _Str& pattern = vm->PyStr_AS_C(args[0]); const _Str& pattern = vm->PyStr_AS_C(args[0]);
const _Str& string = vm->PyStr_AS_C(args[1]); const _Str& string = vm->PyStr_AS_C(args[1]);
return __regex_search(pattern, string, false, vm); return __regex_search(pattern, string, false, vm);
}); });
vm->bindFunc<3>(mod, "sub", [](VM* vm, const pkpy::ArgList& args) { vm->bindFunc<3>(mod, "sub", [](VM* vm, const pkpy::Args& args) {
const _Str& pattern = vm->PyStr_AS_C(args[0]); const _Str& pattern = vm->PyStr_AS_C(args[0]);
const _Str& repl = vm->PyStr_AS_C(args[1]); const _Str& repl = vm->PyStr_AS_C(args[1]);
const _Str& string = vm->PyStr_AS_C(args[2]); const _Str& string = vm->PyStr_AS_C(args[2]);
@ -635,7 +635,7 @@ void __add_module_re(VM* vm){
return vm->PyStr(std::regex_replace(string, re, repl)); return vm->PyStr(std::regex_replace(string, re, repl));
}); });
vm->bindFunc<2>(mod, "split", [](VM* vm, const pkpy::ArgList& args) { vm->bindFunc<2>(mod, "split", [](VM* vm, const pkpy::Args& args) {
const _Str& pattern = vm->PyStr_AS_C(args[0]); const _Str& pattern = vm->PyStr_AS_C(args[0]);
const _Str& string = vm->PyStr_AS_C(args[1]); const _Str& string = vm->PyStr_AS_C(args[1]);
std::regex re(pattern); std::regex re(pattern);

42
src/safestl.h
View File

@ -37,9 +37,9 @@ typedef emhash8::HashMap<_Str, PyVar> PyVarDict;
namespace pkpy { namespace pkpy {
const int MAX_POOLING_N = 10; const int MAX_POOLING_N = 10;
static thread_local std::vector<PyVar*>* _poolArgList = new std::vector<PyVar*>[MAX_POOLING_N]; static thread_local std::vector<PyVar*>* _poolArgs = new std::vector<PyVar*>[MAX_POOLING_N];
class ArgList { class Args {
PyVar* _args; PyVar* _args;
int _size; int _size;
@ -49,44 +49,44 @@ namespace pkpy {
this->_size = 0; this->_size = 0;
return; return;
} }
if(n >= MAX_POOLING_N || _poolArgList[n].empty()){ if(n >= MAX_POOLING_N || _poolArgs[n].empty()){
this->_args = new PyVar[n]; this->_args = new PyVar[n];
this->_size = n; this->_size = n;
}else{ }else{
this->_args = _poolArgList[n].back(); this->_args = _poolArgs[n].back();
this->_size = n; this->_size = n;
_poolArgList[n].pop_back(); _poolArgs[n].pop_back();
} }
} }
void __tryRelease(){ void __tryRelease(){
if(_size == 0 || _args == nullptr) return; if(_size == 0 || _args == nullptr) return;
if(_size >= MAX_POOLING_N || _poolArgList[_size].size() > 32){ if(_size >= MAX_POOLING_N || _poolArgs[_size].size() > 32){
delete[] _args; delete[] _args;
}else{ }else{
for(int i = 0; i < _size; i++) _args[i].reset(); for(int i = 0; i < _size; i++) _args[i].reset();
_poolArgList[_size].push_back(_args); _poolArgs[_size].push_back(_args);
} }
} }
public: public:
ArgList(size_t n){ Args(size_t n){
__tryAlloc(n); __tryAlloc(n);
} }
ArgList(const ArgList& other){ Args(const Args& other){
__tryAlloc(other._size); __tryAlloc(other._size);
for(int i=0; i<_size; i++) _args[i] = other._args[i]; for(int i=0; i<_size; i++) _args[i] = other._args[i];
} }
ArgList(ArgList&& other) noexcept { Args(Args&& other) noexcept {
this->_args = other._args; this->_args = other._args;
this->_size = other._size; this->_size = other._size;
other._args = nullptr; other._args = nullptr;
other._size = 0; other._size = 0;
} }
ArgList(PyVarList&& other) noexcept { Args(PyVarList&& other) noexcept {
__tryAlloc(other.size()); __tryAlloc(other.size());
for(int i=0; i<_size; i++){ for(int i=0; i<_size; i++){
_args[i] = std::move(other[i]); _args[i] = std::move(other[i]);
@ -97,7 +97,7 @@ namespace pkpy {
PyVar& operator[](int i){ return _args[i]; } PyVar& operator[](int i){ return _args[i]; }
const PyVar& operator[](int i) const { return _args[i]; } const PyVar& operator[](int i) const { return _args[i]; }
ArgList& operator=(ArgList&& other) noexcept { Args& operator=(Args&& other) noexcept {
__tryRelease(); __tryRelease();
this->_args = other._args; this->_args = other._args;
this->_size = other._size; this->_size = other._size;
@ -124,33 +124,33 @@ namespace pkpy {
memcpy((void*)(_args+1), (void*)old_args, sizeof(PyVar)*old_size); memcpy((void*)(_args+1), (void*)old_args, sizeof(PyVar)*old_size);
memset((void*)old_args, 0, sizeof(PyVar)*old_size); memset((void*)old_args, 0, sizeof(PyVar)*old_size);
if(old_size >= MAX_POOLING_N || _poolArgList[old_size].size() > 32){ if(old_size >= MAX_POOLING_N || _poolArgs[old_size].size() > 32){
delete[] old_args; delete[] old_args;
}else{ }else{
_poolArgList[old_size].push_back(old_args); _poolArgs[old_size].push_back(old_args);
} }
} }
~ArgList(){ ~Args(){
__tryRelease(); __tryRelease();
} }
}; };
const ArgList& noArg(){ const Args& noArg(){
static const ArgList ret(0); static const Args ret(0);
return ret; return ret;
} }
template<typename T> template<typename T>
ArgList oneArg(T&& a) { Args oneArg(T&& a) {
ArgList ret(1); Args ret(1);
ret[0] = std::forward<T>(a); ret[0] = std::forward<T>(a);
return ret; return ret;
} }
template<typename T1, typename T2> template<typename T1, typename T2>
ArgList twoArgs(T1&& a, T2&& b) { Args twoArgs(T1&& a, T2&& b) {
ArgList ret(2); Args ret(2);
ret[0] = std::forward<T1>(a); ret[0] = std::forward<T1>(a);
ret[1] = std::forward<T2>(b); ret[1] = std::forward<T2>(b);
return ret; return ret;

26
src/vm.h
View File

@ -71,7 +71,7 @@ protected:
} break; } break;
case OP_BUILD_SMART_TUPLE: case OP_BUILD_SMART_TUPLE:
{ {
pkpy::ArgList items = frame->pop_n_reversed(byte.arg); pkpy::Args items = frame->pop_n_reversed(byte.arg);
bool done = false; bool done = false;
for(int i=0; i<items.size(); i++){ for(int i=0; i<items.size(); i++){
if(!items[i]->is_type(_tp_ref)) { if(!items[i]->is_type(_tp_ref)) {
@ -87,7 +87,7 @@ protected:
} break; } break;
case OP_BUILD_STRING: case OP_BUILD_STRING:
{ {
pkpy::ArgList items = frame->pop_n_values_reversed(this, byte.arg); pkpy::Args items = frame->pop_n_values_reversed(this, byte.arg);
_StrStream ss; _StrStream ss;
for(int i=0; i<items.size(); i++) ss << PyStr_AS_C(asStr(items[i])); for(int i=0; i<items.size(); i++) ss << PyStr_AS_C(asStr(items[i]));
frame->push(PyStr(ss.str())); frame->push(PyStr(ss.str()));
@ -96,7 +96,7 @@ protected:
frame->push(builtins->attribs[m_eval]); frame->push(builtins->attribs[m_eval]);
} break; } break;
case OP_LIST_APPEND: { case OP_LIST_APPEND: {
pkpy::ArgList args(2); pkpy::Args args(2);
args[1] = frame->pop_value(this); // obj args[1] = frame->pop_value(this); // obj
args[0] = frame->top_value_offset(this, -2); // list args[0] = frame->top_value_offset(this, -2); // list
fast_call(m_append, std::move(args)); fast_call(m_append, std::move(args));
@ -133,7 +133,7 @@ protected:
case OP_POP_TOP: frame->__pop(); break; case OP_POP_TOP: frame->__pop(); break;
case OP_BINARY_OP: case OP_BINARY_OP:
{ {
pkpy::ArgList args(2); pkpy::Args args(2);
args[1] = frame->pop_value(this); args[1] = frame->pop_value(this);
args[0] = frame->top_value(this); args[0] = frame->top_value(this);
frame->top() = fast_call(BINARY_SPECIAL_METHODS[byte.arg], std::move(args)); frame->top() = fast_call(BINARY_SPECIAL_METHODS[byte.arg], std::move(args));
@ -147,7 +147,7 @@ protected:
} break; } break;
case OP_COMPARE_OP: case OP_COMPARE_OP:
{ {
pkpy::ArgList args(2); pkpy::Args args(2);
args[1] = frame->pop_value(this); args[1] = frame->pop_value(this);
args[0] = frame->top_value(this); args[0] = frame->top_value(this);
frame->top() = fast_call(CMP_SPECIAL_METHODS[byte.arg], std::move(args)); frame->top() = fast_call(CMP_SPECIAL_METHODS[byte.arg], std::move(args));
@ -201,7 +201,7 @@ protected:
break; break;
case OP_BUILD_MAP: case OP_BUILD_MAP:
{ {
pkpy::ArgList items = frame->pop_n_values_reversed(this, byte.arg*2); pkpy::Args items = frame->pop_n_values_reversed(this, byte.arg*2);
PyVar obj = call(builtins->attribs["dict"]); PyVar obj = call(builtins->attribs["dict"]);
for(int i=0; i<items.size(); i+=2){ for(int i=0; i<items.size(); i+=2){
call(obj, __setitem__, pkpy::twoArgs(items[i], items[i+1])); call(obj, __setitem__, pkpy::twoArgs(items[i], items[i+1]));
@ -221,9 +221,9 @@ protected:
{ {
int ARGC = byte.arg & 0xFFFF; int ARGC = byte.arg & 0xFFFF;
int KWARGC = (byte.arg >> 16) & 0xFFFF; int KWARGC = (byte.arg >> 16) & 0xFFFF;
pkpy::ArgList kwargs(0); pkpy::Args kwargs(0);
if(KWARGC > 0) kwargs = frame->pop_n_values_reversed(this, KWARGC*2); if(KWARGC > 0) kwargs = frame->pop_n_values_reversed(this, KWARGC*2);
pkpy::ArgList args = frame->pop_n_values_reversed(this, ARGC); pkpy::Args args = frame->pop_n_values_reversed(this, ARGC);
PyVar callable = frame->pop_value(this); PyVar callable = frame->pop_value(this);
PyVar ret = call(callable, std::move(args), kwargs, true); PyVar ret = call(callable, std::move(args), kwargs, true);
if(ret == __py2py_call_signal) return ret; if(ret == __py2py_call_signal) return ret;
@ -397,7 +397,7 @@ public:
return True; return True;
} }
PyVar fast_call(const _Str& name, pkpy::ArgList&& args){ PyVar fast_call(const _Str& name, pkpy::Args&& args){
PyObject* cls = args[0]->_type.get(); PyObject* cls = args[0]->_type.get();
while(cls != None.get()) { while(cls != None.get()) {
PyVar* val = cls->attribs.try_get(name); PyVar* val = cls->attribs.try_get(name);
@ -413,13 +413,13 @@ public:
} }
template<typename ArgT> template<typename ArgT>
inline std::enable_if_t<std::is_same_v<std::remove_const_t<std::remove_reference_t<ArgT>>, pkpy::ArgList>, PyVar> inline std::enable_if_t<std::is_same_v<std::remove_const_t<std::remove_reference_t<ArgT>>, pkpy::Args>, PyVar>
call(const PyVar& _callable, ArgT&& args){ call(const PyVar& _callable, ArgT&& args){
return call(_callable, std::forward<ArgT>(args), pkpy::noArg(), false); return call(_callable, std::forward<ArgT>(args), pkpy::noArg(), false);
} }
template<typename ArgT> template<typename ArgT>
inline std::enable_if_t<std::is_same_v<std::remove_const_t<std::remove_reference_t<ArgT>>, pkpy::ArgList>, PyVar> inline std::enable_if_t<std::is_same_v<std::remove_const_t<std::remove_reference_t<ArgT>>, pkpy::Args>, PyVar>
call(const PyVar& obj, const _Str& func, ArgT&& args){ call(const PyVar& obj, const _Str& func, ArgT&& args){
return call(getattr(obj, func), std::forward<ArgT>(args), pkpy::noArg(), false); return call(getattr(obj, func), std::forward<ArgT>(args), pkpy::noArg(), false);
} }
@ -428,7 +428,7 @@ public:
return call(getattr(obj, func), pkpy::noArg(), pkpy::noArg(), false); return call(getattr(obj, func), pkpy::noArg(), pkpy::noArg(), false);
} }
PyVar call(const PyVar& _callable, pkpy::ArgList args, const pkpy::ArgList& kwargs, bool opCall){ PyVar call(const PyVar& _callable, pkpy::Args args, const pkpy::Args& kwargs, bool opCall){
if(_callable->is_type(_tp_type)){ if(_callable->is_type(_tp_type)){
auto it = _callable->attribs.find(__new__); auto it = _callable->attribs.find(__new__);
PyVar obj; PyVar obj;
@ -1056,7 +1056,7 @@ PyVar StringIterator::next(){
return vm->PyStr(str.u8_getitem(index++)); return vm->PyStr(str.u8_getitem(index++));
} }
PyVar _CppFunc::operator()(VM* vm, const pkpy::ArgList& args) const{ PyVar _CppFunc::operator()(VM* vm, const pkpy::Args& args) const{
int args_size = args.size() - (int)method; // remove self int args_size = args.size() - (int)method; // remove self
if(argc != -1 && args_size != argc) { if(argc != -1 && args_size != argc) {
vm->typeError("expected " + std::to_string(argc) + " arguments, but got " + std::to_string(args_size)); vm->typeError("expected " + std::to_string(argc) + " arguments, but got " + std::to_string(args_size));