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

optimize

Browse Source 
up

Update pocketpy.h

Update pocketpy.h
This commit is contained in:
blueloveTH 2022-12-11 03:04:46 +08:00
parent a063249832
commit df51577e06
4 changed files with 43 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
plugins/flutter/src/pocketpy.h
View File

@ -4507,9 +4507,9 @@ public:
}
template<typename T>
inline PyVar newObject(PyVar type, T _value) {
inline PyVar newObject(PyVar type, T&& _value) {
__checkType(type, _tp_type);
return pkpy::make_shared<PyObject, Py_<T>>(_value, type);
return pkpy::make_shared<PyObject, Py_<T>>(std::forward<T>(_value), type);
}
PyVar newModule(_Str name) {

34
src/pocketpy.h
View File

@ -5,13 +5,13 @@
#include "repl.h"
#define BIND_NUM_ARITH_OPT(name, op) \
_vm->bindMethodMulti({"int","float"}, #name, [](VM* vm, const pkpy::ArgList& args){ \
_vm->bindMethodMulti({"int","float"}, #name, [](VM* vm, const pkpy::ArgList& args){ \
if(!vm->isIntOrFloat(args[0], args[1])) \
vm->typeError("unsupported operand type(s) for " #op ); \
if(args[0]->isType(vm->_tp_int) && args[1]->isType(vm->_tp_int)){ \
return vm->PyInt(vm->PyInt_AS_C(args[0]) op vm->PyInt_AS_C(args[1])); \
vm->typeError("unsupported operand type(s) for " #op ); \
if(args._index(0)->isType(vm->_tp_int) && args._index(1)->isType(vm->_tp_int)){ \
return vm->PyInt(vm->PyInt_AS_C(args._index(0)) op vm->PyInt_AS_C(args._index(1))); \
}else{ \
return vm->PyFloat(vm->numToFloat(args[0]) op vm->numToFloat(args[1])); \
return vm->PyFloat(vm->numToFloat(args._index(0)) op vm->numToFloat(args._index(1))); \
} \
});
@ -21,7 +21,7 @@
if constexpr(is_eq) return vm->PyBool(args[0] == args[1]); \
vm->typeError("unsupported operand type(s) for " #op ); \
} \
return vm->PyBool(vm->numToFloat(args[0]) op vm->numToFloat(args[1])); \
return vm->PyBool(vm->numToFloat(args._index(0)) op vm->numToFloat(args._index(1))); \
});
@ -205,17 +205,17 @@ void __initializeBuiltinFunctions(VM* _vm) {
_vm->bindMethod("int", "__floordiv__", [](VM* vm, const pkpy::ArgList& args) {
if(!args[0]->isType(vm->_tp_int) || !args[1]->isType(vm->_tp_int))
vm->typeError("unsupported operand type(s) for " "//" );
_Int rhs = vm->PyInt_AS_C(args[1]);
_Int rhs = vm->PyInt_AS_C(args._index(1));
if(rhs == 0) vm->zeroDivisionError();
return vm->PyInt(vm->PyInt_AS_C(args[0]) / rhs);
return vm->PyInt(vm->PyInt_AS_C(args._index(0)) / rhs);
});
_vm->bindMethod("int", "__mod__", [](VM* vm, const pkpy::ArgList& args) {
if(!args[0]->isType(vm->_tp_int) || !args[1]->isType(vm->_tp_int))
vm->typeError("unsupported operand type(s) for " "%" );
_Int rhs = vm->PyInt_AS_C(args[1]);
_Int rhs = vm->PyInt_AS_C(args._index(1));
if(rhs == 0) vm->zeroDivisionError();
return vm->PyInt(vm->PyInt_AS_C(args[0]) % rhs);
return vm->PyInt(vm->PyInt_AS_C(args._index(0)) % rhs);
});
_vm->bindMethod("int", "__repr__", [](VM* vm, const pkpy::ArgList& args) {
@ -227,10 +227,10 @@ void __initializeBuiltinFunctions(VM* _vm) {
});
#define __INT_BITWISE_OP(name,op) \
_vm->bindMethod("int", #name, [](VM* vm, const pkpy::ArgList& args) { \
if(!args[0]->isType(vm->_tp_int) || !args[1]->isType(vm->_tp_int)) \
vm->typeError("unsupported operand type(s) for " #op ); \
return vm->PyInt(vm->PyInt_AS_C(args[0]) op vm->PyInt_AS_C(args[1])); \
_vm->bindMethod("int", #name, [](VM* vm, const pkpy::ArgList& args) { \
if(!args[0]->isType(vm->_tp_int) || !args[1]->isType(vm->_tp_int)) \
vm->typeError("unsupported operand type(s) for " #op ); \
return vm->PyInt(vm->PyInt_AS_C(args._index(0)) op vm->PyInt_AS_C(args._index(1))); \
});
__INT_BITWISE_OP(__lshift__, <<)
@ -241,12 +241,6 @@ void __initializeBuiltinFunctions(VM* _vm) {
#undef __INT_BITWISE_OP
_vm->bindMethod("int", "__xor__", [](VM* vm, const pkpy::ArgList& args) {
if(!args[0]->isType(vm->_tp_int) || !args[1]->isType(vm->_tp_int))
vm->typeError("unsupported operand type(s) for " "^" );
return vm->PyInt(vm->PyInt_AS_C(args[0]) ^ vm->PyInt_AS_C(args[1]));
});
/************ PyFloat ************/
_vm->bindMethod("float", "__new__", [](VM* vm, const pkpy::ArgList& args) {
if(args.size() == 0) return vm->PyFloat(0.0);

4
src/safestl.h
View File

@ -142,6 +142,10 @@ namespace pkpy {
return _args[i];
}
inline const PyVar& _index(uint8_t i) const {
return _args[i];
}
// overload = for &&
ArgList& operator=(ArgList&& other){
if(this != &other){

43
src/vm.h
View File

@ -156,20 +156,23 @@ protected:
case OP_POP_TOP: frame->popValue(this); break;
case OP_BINARY_OP:
{
pkpy::ArgList args = frame->popNValuesReversed(this, 2);
frame->push(fastCall(BINARY_SPECIAL_METHODS[byte.arg], std::move(args)));
frame->push(
fastCall(BINARY_SPECIAL_METHODS[byte.arg],
frame->popNValuesReversed(this, 2))
);
} break;
case OP_BITWISE_OP:
{
pkpy::ArgList args = frame->popNValuesReversed(this, 2);
frame->push(fastCall(BITWISE_SPECIAL_METHODS[byte.arg], std::move(args)));
frame->push(
fastCall(BITWISE_SPECIAL_METHODS[byte.arg],
frame->popNValuesReversed(this, 2))
);
} break;
case OP_COMPARE_OP:
{
pkpy::ArgList args = frame->popNValuesReversed(this, 2);
// for __ne__ we use the negation of __eq__
int op = byte.arg == 3 ? 2 : byte.arg;
PyVar res = fastCall(CMP_SPECIAL_METHODS[op], std::move(args));
PyVar res = fastCall(CMP_SPECIAL_METHODS[op], frame->popNValuesReversed(this, 2));
if(op != byte.arg) res = PyBool(!PyBool_AS_C(res));
frame->push(std::move(res));
} break;
@ -264,11 +267,11 @@ protected:
case OP_GOTO: {
PyVar obj = frame->popValue(this);
const _Str& label = PyStr_AS_C(obj);
auto it = frame->code->co_labels.find(label);
if(it == frame->code->co_labels.end()){
int* target = frame->code->co_labels.try_get(label);
if(target == nullptr){
_error("KeyError", "label '" + label + "' not found");
}
frame->safeJump(it->second);
frame->safeJump(*target);
} break;
case OP_GET_ITER:
{
@ -440,8 +443,8 @@ public:
PyVar fastCall(const _Str& name, pkpy::ArgList&& args){
PyObject* cls = args[0]->_type.get();
while(cls != None.get()) {
auto it = cls->attribs.find(name);
if(it != cls->attribs.end()) return call(it->second, std::move(args));
PyVar* val = cls->attribs.try_get(name);
if(val != nullptr) return call(*val, std::move(args));
cls = cls->attribs[__base__].get();
}
attributeError(args[0], name);
@ -531,7 +534,7 @@ public:
for(int i=0; i<kwargs.size(); i+=2){
const _Str& key = PyStr_AS_C(kwargs[i]);
if(fn->kwArgs.find(key) == fn->kwArgs.end()){
if(!fn->kwArgs.contains(key)){
typeError(key.__escape(true) + " is an invalid keyword argument for " + fn->name + "()");
}
const PyVar& val = kwargs[i+1];
@ -544,8 +547,8 @@ public:
locals[key] = val;
}
auto it_m = (*callable)->attribs.find(__module__);
PyVar _module = it_m != (*callable)->attribs.end() ? it_m->second : topFrame()->_module;
PyVar* it_m = (*callable)->attribs.try_get(__module__);
PyVar _module = it_m != nullptr ? *it_m : topFrame()->_module;
if(opCall){
__pushNewFrame(fn->code, _module, std::move(locals));
return __py2py_call_signal;
@ -968,12 +971,12 @@ public:
/***** Pointers' Impl *****/
PyVar NameRef::get(VM* vm, Frame* frame) const{
auto it = frame->f_locals.find(pair->first);
if(it != frame->f_locals.end()) return it->second;
it = frame->f_globals().find(pair->first);
if(it != frame->f_globals().end()) return it->second;
it = vm->builtins->attribs.find(pair->first);
if(it != vm->builtins->attribs.end()) return it->second;
PyVar* val = frame->f_locals.try_get(pair->first);
if(val) return *val;
val = frame->f_globals().try_get(pair->first);
if(val) return *val;
val = vm->builtins->attribs.try_get(pair->first);
if(val) return *val;
vm->nameError(pair->first);
return nullptr;
}