mirror of
https://github.com/pocketpy/pocketpy
synced 2025-10-22 04:20:17 +00:00
up
This commit is contained in:
blueloveTH
parent
d4401bfa98
commit
bc001143f2
@ -20,7 +20,7 @@
|
||||
#include <queue>
|
||||
#include <iomanip>
|
||||
#include <memory>
|
||||
// #include <functional>
|
||||
#include <functional>
|
||||
|
||||
#include <atomic>
|
||||
#include <iostream>
|
||||
|
||||
@ -3,7 +3,7 @@
|
||||
|
||||
#include "pocketpy.h"
|
||||
|
||||
//#define PK_DEBUG_TIME
|
||||
#define PK_DEBUG_TIME
|
||||
|
||||
struct Timer{
|
||||
const char* title;
|
||||
|
||||
11
src/obj.h
11
src/obj.h
@ -7,10 +7,19 @@ struct BaseRef;
|
||||
class VM;
|
||||
class Frame;
|
||||
|
||||
typedef PyVar (*_CppFunc)(VM*, const pkpy::ArgList&);
|
||||
typedef PyVar (*_CppFuncRaw)(VM*, const pkpy::ArgList&);
|
||||
//typedef std::function<PyVar(VM*, const pkpy::ArgList&)> _CppFunc;
|
||||
typedef pkpy::shared_ptr<CodeObject> _Code;
|
||||
|
||||
struct _CppFunc {
|
||||
_CppFuncRaw f;
|
||||
int argc; // DONOT include self
|
||||
bool method;
|
||||
|
||||
_CppFunc(_CppFuncRaw f, int argc, bool method) : f(f), argc(argc), method(method) {}
|
||||
inline PyVar operator()(VM* vm, const pkpy::ArgList& args) const;
|
||||
};
|
||||
|
||||
struct Function {
|
||||
_Str name;
|
||||
_Code code;
|
||||
|
||||
311
src/pocketpy.h
311
src/pocketpy.h
@ -16,7 +16,7 @@ _Code VM::compile(_Str source, _Str filename, CompileMode mode) {
|
||||
}
|
||||
|
||||
#define BIND_NUM_ARITH_OPT(name, op) \
|
||||
_vm->bindMethodMulti({"int","float"}, #name, [](VM* vm, const pkpy::ArgList& args){ \
|
||||
_vm->bindMethodMulti<1>({"int","float"}, #name, [](VM* vm, const pkpy::ArgList& args){ \
|
||||
if(!vm->is_int_or_float(args[0], args[1])) \
|
||||
vm->typeError("unsupported operand type(s) for " #op ); \
|
||||
if(args._index(0)->is_type(vm->_tp_int) && args._index(1)->is_type(vm->_tp_int)){ \
|
||||
@ -27,7 +27,7 @@ _Code VM::compile(_Str source, _Str filename, CompileMode mode) {
|
||||
});
|
||||
|
||||
#define BIND_NUM_LOGICAL_OPT(name, op, is_eq) \
|
||||
_vm->bindMethodMulti({"int","float"}, #name, [](VM* vm, const pkpy::ArgList& args){ \
|
||||
_vm->bindMethodMulti<1>({"int","float"}, #name, [](VM* vm, const pkpy::ArgList& args){ \
|
||||
if(!vm->is_int_or_float(args[0], args[1])){ \
|
||||
if constexpr(is_eq) return vm->PyBool(args[0] == args[1]); \
|
||||
vm->typeError("unsupported operand type(s) for " #op ); \
|
||||
@ -50,57 +50,48 @@ void __initializeBuiltinFunctions(VM* _vm) {
|
||||
#undef BIND_NUM_ARITH_OPT
|
||||
#undef BIND_NUM_LOGICAL_OPT
|
||||
|
||||
_vm->bindBuiltinFunc("__sys_stdout_write", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 1);
|
||||
_vm->bindBuiltinFunc<1>("__sys_stdout_write", [](VM* vm, const pkpy::ArgList& args) {
|
||||
(*vm->_stdout) << vm->PyStr_AS_C(args[0]);
|
||||
return vm->None;
|
||||
});
|
||||
|
||||
_vm->bindBuiltinFunc("super", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 0);
|
||||
_vm->bindBuiltinFunc<0>("super", [](VM* vm, const pkpy::ArgList& args) {
|
||||
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");
|
||||
return vm->new_object(vm->_tp_super, it->second);
|
||||
});
|
||||
|
||||
_vm->bindBuiltinFunc("eval", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 1);
|
||||
_vm->bindBuiltinFunc<1>("eval", [](VM* vm, const pkpy::ArgList& args) {
|
||||
const _Str& expr = vm->PyStr_AS_C(args[0]);
|
||||
_Code code = vm->compile(expr, "<eval>", EVAL_MODE);
|
||||
return vm->_exec(code, vm->top_frame()->_module, vm->top_frame()->f_locals_copy());
|
||||
});
|
||||
|
||||
_vm->bindBuiltinFunc("repr", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 1);
|
||||
_vm->bindBuiltinFunc<1>("repr", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->asRepr(args[0]);
|
||||
});
|
||||
|
||||
_vm->bindBuiltinFunc("hash", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 1);
|
||||
_vm->bindBuiltinFunc<1>("hash", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->PyInt(vm->hash(args[0]));
|
||||
});
|
||||
|
||||
_vm->bindBuiltinFunc("len", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 1);
|
||||
_vm->bindBuiltinFunc<1>("len", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->call(args[0], __len__, pkpy::noArg());
|
||||
});
|
||||
|
||||
_vm->bindBuiltinFunc("chr", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 1);
|
||||
_vm->bindBuiltinFunc<1>("chr", [](VM* vm, const pkpy::ArgList& args) {
|
||||
i64 i = vm->PyInt_AS_C(args[0]);
|
||||
if (i < 0 || i > 128) vm->valueError("chr() arg not in range(128)");
|
||||
return vm->PyStr(std::string(1, (char)i));
|
||||
});
|
||||
|
||||
_vm->bindBuiltinFunc("ord", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 1);
|
||||
_vm->bindBuiltinFunc<1>("ord", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_Str s = vm->PyStr_AS_C(args[0]);
|
||||
if (s.size() != 1) vm->typeError("ord() expected an ASCII character");
|
||||
return vm->PyInt((i64)s[0]);
|
||||
});
|
||||
|
||||
_vm->bindBuiltinFunc("globals", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 0);
|
||||
_vm->bindBuiltinFunc<0>("globals", [](VM* vm, const pkpy::ArgList& args) {
|
||||
const auto& d = vm->top_frame()->f_globals();
|
||||
PyVar obj = vm->call(vm->builtins->attribs["dict"]);
|
||||
for (const auto& [k, v] : d) {
|
||||
@ -109,8 +100,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
|
||||
return obj;
|
||||
});
|
||||
|
||||
_vm->bindBuiltinFunc("locals", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 0);
|
||||
_vm->bindBuiltinFunc<0>("locals", [](VM* vm, const pkpy::ArgList& args) {
|
||||
const auto& d = vm->top_frame()->f_locals;
|
||||
PyVar obj = vm->call(vm->builtins->attribs["dict"]);
|
||||
for (const auto& [k, v] : d) {
|
||||
@ -119,15 +109,13 @@ void __initializeBuiltinFunctions(VM* _vm) {
|
||||
return obj;
|
||||
});
|
||||
|
||||
_vm->bindBuiltinFunc("hex", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 1);
|
||||
_vm->bindBuiltinFunc<1>("hex", [](VM* vm, const pkpy::ArgList& args) {
|
||||
std::stringstream ss;
|
||||
ss << std::hex << vm->PyInt_AS_C(args[0]);
|
||||
return vm->PyStr("0x" + ss.str());
|
||||
});
|
||||
|
||||
_vm->bindBuiltinFunc("dir", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 1);
|
||||
_vm->bindBuiltinFunc<1>("dir", [](VM* vm, const pkpy::ArgList& args) {
|
||||
std::vector<_Str> names;
|
||||
for (auto& [k, _] : args[0]->attribs) names.push_back(k);
|
||||
for (auto& [k, _] : args[0]->_type->attribs) {
|
||||
@ -142,7 +130,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
|
||||
return vm->PyList(ret);
|
||||
});
|
||||
|
||||
_vm->bindMethod("object", "__repr__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<0>("object", "__repr__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
PyVar _self = args[0];
|
||||
std::stringstream ss;
|
||||
ss << std::hex << (uintptr_t)_self.get();
|
||||
@ -150,17 +138,15 @@ void __initializeBuiltinFunctions(VM* _vm) {
|
||||
return vm->PyStr(s);
|
||||
});
|
||||
|
||||
_vm->bindMethod("type", "__new__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 1);
|
||||
_vm->bindStaticMethod<1>("type", "__new__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return args[0]->_type;
|
||||
});
|
||||
|
||||
_vm->bindMethod("type", "__eq__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 2, true);
|
||||
_vm->bindMethod<1>("type", "__eq__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->PyBool(args[0] == args[1]);
|
||||
});
|
||||
|
||||
_vm->bindMethod("range", "__new__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindStaticMethod<-1>("range", "__new__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_Range r;
|
||||
switch (args.size()) {
|
||||
case 1: r.stop = vm->PyInt_AS_C(args[0]); break;
|
||||
@ -171,26 +157,25 @@ void __initializeBuiltinFunctions(VM* _vm) {
|
||||
return vm->PyRange(r);
|
||||
});
|
||||
|
||||
_vm->bindMethod("range", "__iter__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_type(args[0], vm->_tp_range);
|
||||
_vm->bindMethod<0>("range", "__iter__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->PyIter(
|
||||
pkpy::make_shared<BaseIterator, RangeIterator>(vm, args[0])
|
||||
);
|
||||
});
|
||||
|
||||
_vm->bindMethod("NoneType", "__repr__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<0>("NoneType", "__repr__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->PyStr("None");
|
||||
});
|
||||
|
||||
_vm->bindMethod("NoneType", "__json__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<0>("NoneType", "__json__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->PyStr("null");
|
||||
});
|
||||
|
||||
_vm->bindMethod("NoneType", "__eq__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<1>("NoneType", "__eq__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->PyBool(args[0] == args[1]);
|
||||
});
|
||||
|
||||
_vm->bindMethodMulti({"int", "float"}, "__truediv__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethodMulti<1>({"int", "float"}, "__truediv__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
if(!vm->is_int_or_float(args[0], args[1]))
|
||||
vm->typeError("unsupported operand type(s) for " "/" );
|
||||
f64 rhs = vm->num_to_float(args[1]);
|
||||
@ -198,7 +183,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
|
||||
return vm->PyFloat(vm->num_to_float(args[0]) / rhs);
|
||||
});
|
||||
|
||||
_vm->bindMethodMulti({"int", "float"}, "__pow__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethodMulti<1>({"int", "float"}, "__pow__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
if(!vm->is_int_or_float(args[0], args[1]))
|
||||
vm->typeError("unsupported operand type(s) for " "**" );
|
||||
if(args[0]->is_type(vm->_tp_int) && args[1]->is_type(vm->_tp_int)){
|
||||
@ -209,9 +194,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
|
||||
});
|
||||
|
||||
/************ PyInt ************/
|
||||
_vm->bindMethod("int", "__new__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
if(args.size() == 0) return vm->PyInt(0);
|
||||
vm->check_args_size(args, 1);
|
||||
_vm->bindStaticMethod<1>("int", "__new__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
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_bool)) return vm->PyInt(vm->PyBool_AS_C(args[0]) ? 1 : 0);
|
||||
@ -230,7 +213,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
|
||||
return vm->None;
|
||||
});
|
||||
|
||||
_vm->bindMethod("int", "__floordiv__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<1>("int", "__floordiv__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
if(!args[0]->is_type(vm->_tp_int) || !args[1]->is_type(vm->_tp_int))
|
||||
vm->typeError("unsupported operand type(s) for " "//" );
|
||||
i64 rhs = vm->PyInt_AS_C(args._index(1));
|
||||
@ -238,7 +221,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
|
||||
return vm->PyInt(vm->PyInt_AS_C(args._index(0)) / rhs);
|
||||
});
|
||||
|
||||
_vm->bindMethod("int", "__mod__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<1>("int", "__mod__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
if(!args[0]->is_type(vm->_tp_int) || !args[1]->is_type(vm->_tp_int))
|
||||
vm->typeError("unsupported operand type(s) for " "%" );
|
||||
i64 rhs = vm->PyInt_AS_C(args._index(1));
|
||||
@ -246,17 +229,16 @@ void __initializeBuiltinFunctions(VM* _vm) {
|
||||
return vm->PyInt(vm->PyInt_AS_C(args._index(0)) % rhs);
|
||||
});
|
||||
|
||||
_vm->bindMethod("int", "__repr__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<0>("int", "__repr__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->PyStr(std::to_string(vm->PyInt_AS_C(args[0])));
|
||||
});
|
||||
|
||||
_vm->bindMethod("int", "__json__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<0>("int", "__json__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->PyStr(std::to_string((int)vm->PyInt_AS_C(args[0])));
|
||||
});
|
||||
|
||||
#define __INT_BITWISE_OP(name,op) \
|
||||
_vm->bindMethod("int", #name, [](VM* vm, const pkpy::ArgList& args) { \
|
||||
vm->check_args_size(args, 2, true); \
|
||||
_vm->bindMethod<1>("int", #name, [](VM* vm, const pkpy::ArgList& args) { \
|
||||
return vm->PyInt(vm->PyInt_AS_C(args._index(0)) op vm->PyInt_AS_C(args._index(1))); \
|
||||
});
|
||||
|
||||
@ -269,9 +251,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
|
||||
#undef __INT_BITWISE_OP
|
||||
|
||||
/************ PyFloat ************/
|
||||
_vm->bindMethod("float", "__new__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
if(args.size() == 0) return vm->PyFloat(0.0);
|
||||
vm->check_args_size(args, 1);
|
||||
_vm->bindStaticMethod<1>("float", "__new__", [](VM* vm, const pkpy::ArgList& 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_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);
|
||||
@ -290,7 +270,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
|
||||
return vm->None;
|
||||
});
|
||||
|
||||
_vm->bindMethod("float", "__repr__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<0>("float", "__repr__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
f64 val = vm->PyFloat_AS_C(args[0]);
|
||||
if(std::isinf(val) || std::isnan(val)) return vm->PyStr(std::to_string(val));
|
||||
_StrStream ss;
|
||||
@ -300,60 +280,59 @@ void __initializeBuiltinFunctions(VM* _vm) {
|
||||
return vm->PyStr(s);
|
||||
});
|
||||
|
||||
_vm->bindMethod("float", "__json__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<0>("float", "__json__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
f64 val = vm->PyFloat_AS_C(args[0]);
|
||||
if(std::isinf(val) || std::isnan(val)) vm->valueError("cannot jsonify 'nan' or 'inf'");
|
||||
return vm->PyStr(std::to_string(val));
|
||||
});
|
||||
|
||||
/************ PyString ************/
|
||||
_vm->bindMethod("str", "__new__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 1);
|
||||
_vm->bindStaticMethod<1>("str", "__new__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->asStr(args._index(0));
|
||||
});
|
||||
|
||||
_vm->bindMethod("str", "__add__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<1>("str", "__add__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
const _Str& lhs = vm->PyStr_AS_C(args[0]);
|
||||
const _Str& rhs = vm->PyStr_AS_C(args[1]);
|
||||
return vm->PyStr(lhs + rhs);
|
||||
});
|
||||
|
||||
_vm->bindMethod("str", "__len__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<0>("str", "__len__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
const _Str& _self = vm->PyStr_AS_C(args[0]);
|
||||
return vm->PyInt(_self.u8_length());
|
||||
});
|
||||
|
||||
_vm->bindMethod("str", "__contains__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<1>("str", "__contains__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
const _Str& _self = vm->PyStr_AS_C(args[0]);
|
||||
const _Str& _other = vm->PyStr_AS_C(args[1]);
|
||||
return vm->PyBool(_self.find(_other) != _Str::npos);
|
||||
});
|
||||
|
||||
_vm->bindMethod("str", "__str__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<0>("str", "__str__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return args[0]; // str is immutable
|
||||
});
|
||||
|
||||
_vm->bindMethod("str", "__iter__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<0>("str", "__iter__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->PyIter(pkpy::make_shared<BaseIterator, StringIterator>(vm, args[0]));
|
||||
});
|
||||
|
||||
_vm->bindMethod("str", "__repr__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<0>("str", "__repr__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
const _Str& _self = vm->PyStr_AS_C(args[0]);
|
||||
return vm->PyStr(_self.__escape(true));
|
||||
});
|
||||
|
||||
_vm->bindMethod("str", "__json__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<0>("str", "__json__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
const _Str& _self = vm->PyStr_AS_C(args[0]);
|
||||
return vm->PyStr(_self.__escape(false));
|
||||
});
|
||||
|
||||
_vm->bindMethod("str", "__eq__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<1>("str", "__eq__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
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(args[0] == args[1]); // fallback
|
||||
});
|
||||
|
||||
_vm->bindMethod("str", "__getitem__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<1>("str", "__getitem__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
const _Str& _self (vm->PyStr_AS_C(args[0]));
|
||||
|
||||
if(args[1]->is_type(vm->_tp_slice)){
|
||||
@ -367,20 +346,19 @@ void __initializeBuiltinFunctions(VM* _vm) {
|
||||
return vm->PyStr(_self.u8_getitem(_index));
|
||||
});
|
||||
|
||||
_vm->bindMethod("str", "__gt__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<1>("str", "__gt__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
const _Str& _self (vm->PyStr_AS_C(args[0]));
|
||||
const _Str& _obj (vm->PyStr_AS_C(args[1]));
|
||||
return vm->PyBool(_self > _obj);
|
||||
});
|
||||
|
||||
_vm->bindMethod("str", "__lt__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<1>("str", "__lt__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
const _Str& _self (vm->PyStr_AS_C(args[0]));
|
||||
const _Str& _obj (vm->PyStr_AS_C(args[1]));
|
||||
return vm->PyBool(_self < _obj);
|
||||
});
|
||||
|
||||
_vm->bindMethod("str", "replace", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 3, true);
|
||||
_vm->bindMethod<2>("str", "replace", [](VM* vm, const pkpy::ArgList& args) {
|
||||
const _Str& _self = vm->PyStr_AS_C(args[0]);
|
||||
const _Str& _old = vm->PyStr_AS_C(args[1]);
|
||||
const _Str& _new = vm->PyStr_AS_C(args[2]);
|
||||
@ -394,22 +372,19 @@ void __initializeBuiltinFunctions(VM* _vm) {
|
||||
return vm->PyStr(_copy);
|
||||
});
|
||||
|
||||
_vm->bindMethod("str", "startswith", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 2, true);
|
||||
_vm->bindMethod<1>("str", "startswith", [](VM* vm, const pkpy::ArgList& args) {
|
||||
const _Str& _self = vm->PyStr_AS_C(args[0]);
|
||||
const _Str& _prefix = vm->PyStr_AS_C(args[1]);
|
||||
return vm->PyBool(_self.find(_prefix) == 0);
|
||||
});
|
||||
|
||||
_vm->bindMethod("str", "endswith", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 2, true);
|
||||
_vm->bindMethod<1>("str", "endswith", [](VM* vm, const pkpy::ArgList& args) {
|
||||
const _Str& _self = vm->PyStr_AS_C(args[0]);
|
||||
const _Str& _suffix = vm->PyStr_AS_C(args[1]);
|
||||
return vm->PyBool(_self.rfind(_suffix) == _self.length() - _suffix.length());
|
||||
});
|
||||
|
||||
_vm->bindMethod("str", "join", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 2, true);
|
||||
_vm->bindMethod<1>("str", "join", [](VM* vm, const pkpy::ArgList& args) {
|
||||
const _Str& _self = vm->PyStr_AS_C(args[0]);
|
||||
PyVarList* _list;
|
||||
if(args[1]->is_type(vm->_tp_list)){
|
||||
@ -428,22 +403,19 @@ void __initializeBuiltinFunctions(VM* _vm) {
|
||||
});
|
||||
|
||||
/************ PyList ************/
|
||||
_vm->bindMethod("list", "__iter__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_type(args[0], vm->_tp_list);
|
||||
_vm->bindMethod<0>("list", "__iter__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->PyIter(
|
||||
pkpy::make_shared<BaseIterator, VectorIterator>(vm, args[0])
|
||||
);
|
||||
});
|
||||
|
||||
_vm->bindMethod("list", "append", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 2, true);
|
||||
_vm->bindMethod<1>("list", "append", [](VM* vm, const pkpy::ArgList& args) {
|
||||
PyVarList& _self = vm->PyList_AS_C(args[0]);
|
||||
_self.push_back(args._index(1));
|
||||
return vm->None;
|
||||
});
|
||||
|
||||
_vm->bindMethod("list", "insert", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 3, true);
|
||||
_vm->bindMethod<2>("list", "insert", [](VM* vm, const pkpy::ArgList& args) {
|
||||
PyVarList& _self = vm->PyList_AS_C(args[0]);
|
||||
int _index = (int)vm->PyInt_AS_C(args[1]);
|
||||
if(_index < 0) _index += _self.size();
|
||||
@ -453,18 +425,16 @@ void __initializeBuiltinFunctions(VM* _vm) {
|
||||
return vm->None;
|
||||
});
|
||||
|
||||
_vm->bindMethod("list", "clear", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 1, true);
|
||||
_vm->bindMethod<0>("list", "clear", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->PyList_AS_C(args[0]).clear();
|
||||
return vm->None;
|
||||
});
|
||||
|
||||
_vm->bindMethod("list", "copy", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 1, true);
|
||||
_vm->bindMethod<0>("list", "copy", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->PyList(vm->PyList_AS_C(args[0]));
|
||||
});
|
||||
|
||||
_vm->bindMethod("list", "__add__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<1>("list", "__add__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
const PyVarList& _self = vm->PyList_AS_C(args[0]);
|
||||
const PyVarList& _obj = vm->PyList_AS_C(args[1]);
|
||||
PyVarList _new_list = _self;
|
||||
@ -472,12 +442,12 @@ void __initializeBuiltinFunctions(VM* _vm) {
|
||||
return vm->PyList(_new_list);
|
||||
});
|
||||
|
||||
_vm->bindMethod("list", "__len__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<0>("list", "__len__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
const PyVarList& _self = vm->PyList_AS_C(args[0]);
|
||||
return vm->PyInt(_self.size());
|
||||
});
|
||||
|
||||
_vm->bindMethod("list", "__getitem__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<1>("list", "__getitem__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
const PyVarList& _self = vm->PyList_AS_C(args[0]);
|
||||
|
||||
if(args[1]->is_type(vm->_tp_slice)){
|
||||
@ -494,7 +464,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
|
||||
return _self[_index];
|
||||
});
|
||||
|
||||
_vm->bindMethod("list", "__setitem__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<2>("list", "__setitem__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
PyVarList& _self = vm->PyList_AS_C(args[0]);
|
||||
int _index = (int)vm->PyInt_AS_C(args[1]);
|
||||
_index = vm->normalizedIndex(_index, _self.size());
|
||||
@ -502,7 +472,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
|
||||
return vm->None;
|
||||
});
|
||||
|
||||
_vm->bindMethod("list", "__delitem__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<1>("list", "__delitem__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
PyVarList& _self = vm->PyList_AS_C(args[0]);
|
||||
int _index = (int)vm->PyInt_AS_C(args[1]);
|
||||
_index = vm->normalizedIndex(_index, _self.size());
|
||||
@ -511,25 +481,21 @@ void __initializeBuiltinFunctions(VM* _vm) {
|
||||
});
|
||||
|
||||
/************ PyTuple ************/
|
||||
_vm->bindMethod("tuple", "__new__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 1);
|
||||
_vm->bindStaticMethod<1>("tuple", "__new__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
PyVarList _list = vm->PyList_AS_C(vm->call(vm->builtins->attribs["list"], args));
|
||||
return vm->PyTuple(_list);
|
||||
});
|
||||
|
||||
_vm->bindMethod("tuple", "__iter__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_type(args[0], vm->_tp_tuple);
|
||||
return vm->PyIter(
|
||||
pkpy::make_shared<BaseIterator, VectorIterator>(vm, args[0])
|
||||
);
|
||||
_vm->bindMethod<0>("tuple", "__iter__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->PyIter(pkpy::make_shared<BaseIterator, VectorIterator>(vm, args[0]));
|
||||
});
|
||||
|
||||
_vm->bindMethod("tuple", "__len__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<0>("tuple", "__len__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
const PyVarList& _self = vm->PyTuple_AS_C(args[0]);
|
||||
return vm->PyInt(_self.size());
|
||||
});
|
||||
|
||||
_vm->bindMethod("tuple", "__getitem__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<1>("tuple", "__getitem__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
const PyVarList& _self = vm->PyTuple_AS_C(args[0]);
|
||||
int _index = (int)vm->PyInt_AS_C(args[1]);
|
||||
_index = vm->normalizedIndex(_index, _self.size());
|
||||
@ -537,52 +503,33 @@ void __initializeBuiltinFunctions(VM* _vm) {
|
||||
});
|
||||
|
||||
/************ PyBool ************/
|
||||
_vm->bindMethod("bool", "__new__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 1);
|
||||
_vm->bindStaticMethod<1>("bool", "__new__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->asBool(args[0]);
|
||||
});
|
||||
|
||||
_vm->bindMethod("bool", "__repr__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<0>("bool", "__repr__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
bool val = vm->PyBool_AS_C(args[0]);
|
||||
return vm->PyStr(val ? "True" : "False");
|
||||
});
|
||||
|
||||
_vm->bindMethod("bool", "__json__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<0>("bool", "__json__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
bool val = vm->PyBool_AS_C(args[0]);
|
||||
return vm->PyStr(val ? "true" : "false");
|
||||
});
|
||||
|
||||
_vm->bindMethod("bool", "__eq__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<1>("bool", "__eq__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->PyBool(args[0] == args[1]);
|
||||
});
|
||||
|
||||
_vm->bindMethod("bool", "__xor__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<1>("bool", "__xor__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
bool _self = vm->PyBool_AS_C(args[0]);
|
||||
bool _obj = vm->PyBool_AS_C(args[1]);
|
||||
return vm->PyBool(_self ^ _obj);
|
||||
});
|
||||
|
||||
_vm->bindMethod("ellipsis", "__repr__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
_vm->bindMethod<0>("ellipsis", "__repr__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->PyStr("Ellipsis");
|
||||
});
|
||||
|
||||
_vm->bindMethod("_native_function", "__call__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
const _CppFunc& _self = vm->PyNativeFunction_AS_C(args[0]);
|
||||
return _self(vm, args.subList(1));
|
||||
});
|
||||
|
||||
_vm->bindMethod("function", "__call__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->call(args[0], args.subList(1));
|
||||
});
|
||||
|
||||
_vm->bindMethod("_bounded_method", "__call__", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_type(args[0], vm->_tp_bounded_method);
|
||||
const _BoundedMethod& _self = vm->PyBoundedMethod_AS_C(args[0]);
|
||||
pkpy::ArgList newArgs(args.size());
|
||||
newArgs[0] = _self.obj;
|
||||
for(int i = 1; i < args.size(); i++) newArgs[i] = args[i];
|
||||
return vm->call(_self.method, newArgs);
|
||||
});
|
||||
}
|
||||
|
||||
#include "builtins.h"
|
||||
@ -601,7 +548,7 @@ void __initializeBuiltinFunctions(VM* _vm) {
|
||||
|
||||
void __addModuleTime(VM* vm){
|
||||
PyVar mod = vm->newModule("time");
|
||||
vm->bindFunc(mod, "time", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->bindFunc<0>(mod, "time", [](VM* vm, const pkpy::ArgList& args) {
|
||||
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);
|
||||
});
|
||||
@ -609,18 +556,15 @@ void __addModuleTime(VM* vm){
|
||||
|
||||
void __addModuleSys(VM* vm){
|
||||
PyVar mod = vm->newModule("sys");
|
||||
vm->bindFunc(mod, "getrefcount", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 1);
|
||||
vm->bindFunc<1>(mod, "getrefcount", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->PyInt(args[0].use_count());
|
||||
});
|
||||
|
||||
vm->bindFunc(mod, "getrecursionlimit", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 0);
|
||||
vm->bindFunc<0>(mod, "getrecursionlimit", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->PyInt(vm->maxRecursionDepth);
|
||||
});
|
||||
|
||||
vm->bindFunc(mod, "setrecursionlimit", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 1);
|
||||
vm->bindFunc<1>(mod, "setrecursionlimit", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->maxRecursionDepth = (int)vm->PyInt_AS_C(args[0]);
|
||||
return vm->None;
|
||||
});
|
||||
@ -630,15 +574,13 @@ void __addModuleSys(VM* vm){
|
||||
|
||||
void __addModuleJson(VM* vm){
|
||||
PyVar mod = vm->newModule("json");
|
||||
vm->bindFunc(mod, "loads", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 1);
|
||||
vm->bindFunc<1>(mod, "loads", [](VM* vm, const pkpy::ArgList& args) {
|
||||
const _Str& expr = vm->PyStr_AS_C(args[0]);
|
||||
_Code code = vm->compile(expr, "<json>", JSON_MODE);
|
||||
return vm->_exec(code, vm->top_frame()->_module, vm->top_frame()->f_locals_copy());
|
||||
});
|
||||
|
||||
vm->bindFunc(mod, "dumps", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 1);
|
||||
vm->bindFunc<1>(mod, "dumps", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->asJson(args[0]);
|
||||
});
|
||||
}
|
||||
@ -648,63 +590,88 @@ void __addModuleMath(VM* vm){
|
||||
vm->setattr(mod, "pi", vm->PyFloat(3.1415926535897932384));
|
||||
vm->setattr(mod, "e" , vm->PyFloat(2.7182818284590452354));
|
||||
|
||||
vm->bindFunc(mod, "log", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 1);
|
||||
vm->bindFunc<1>(mod, "log", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->PyFloat(log(vm->num_to_float(args[0])));
|
||||
});
|
||||
|
||||
vm->bindFunc(mod, "log10", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 1);
|
||||
vm->bindFunc<1>(mod, "log10", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->PyFloat(log10(vm->num_to_float(args[0])));
|
||||
});
|
||||
|
||||
vm->bindFunc(mod, "log2", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 1);
|
||||
vm->bindFunc<1>(mod, "log2", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->PyFloat(log2(vm->num_to_float(args[0])));
|
||||
});
|
||||
|
||||
vm->bindFunc(mod, "sin", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 1);
|
||||
vm->bindFunc<1>(mod, "sin", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->PyFloat(sin(vm->num_to_float(args[0])));
|
||||
});
|
||||
|
||||
vm->bindFunc(mod, "cos", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 1);
|
||||
vm->bindFunc<1>(mod, "cos", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->PyFloat(cos(vm->num_to_float(args[0])));
|
||||
});
|
||||
|
||||
vm->bindFunc(mod, "tan", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 1);
|
||||
vm->bindFunc<1>(mod, "tan", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->PyFloat(tan(vm->num_to_float(args[0])));
|
||||
});
|
||||
|
||||
vm->bindFunc(mod, "isclose", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 2);
|
||||
vm->bindFunc<2>(mod, "isclose", [](VM* vm, const pkpy::ArgList& args) {
|
||||
f64 a = vm->num_to_float(args[0]);
|
||||
f64 b = vm->num_to_float(args[1]);
|
||||
return vm->PyBool(fabs(a - b) < 1e-9);
|
||||
});
|
||||
|
||||
vm->bindFunc(mod, "isnan", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 1);
|
||||
vm->bindFunc<1>(mod, "isnan", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->PyBool(std::isnan(vm->num_to_float(args[0])));
|
||||
});
|
||||
|
||||
vm->bindFunc(mod, "isinf", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 1);
|
||||
vm->bindFunc<1>(mod, "isinf", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->PyBool(std::isinf(vm->num_to_float(args[0])));
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
#define PY_CLASS(mod, name) inline static PyVar _tp(VM* vm) { return vm->_modules[#mod]->attribs[#name]; }
|
||||
|
||||
struct ReMatch {
|
||||
PY_CLASS(re, Match)
|
||||
|
||||
i64 start;
|
||||
i64 end;
|
||||
std::smatch m;
|
||||
ReMatch(i64 start, i64 end, std::smatch m) : start(start), end(end), m(m) {}
|
||||
|
||||
static PyVar _bind(VM* vm){
|
||||
PyVar _tp_match = vm->new_user_type_object(vm->_modules["re"], "Match", vm->_tp_object);
|
||||
vm->bindMethod<0>(_tp_match, "start", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->PyInt(UNION_GET(ReMatch, args[0]).start);
|
||||
});
|
||||
|
||||
vm->bindMethod<0>(_tp_match, "end", [](VM* vm, const pkpy::ArgList& args) {
|
||||
return vm->PyInt(UNION_GET(ReMatch, args[0]).end);
|
||||
});
|
||||
|
||||
vm->bindMethod<0>(_tp_match, "span", [](VM* vm, const pkpy::ArgList& args) {
|
||||
auto& m = UNION_GET(ReMatch, args[0]);
|
||||
PyVarList vec = { vm->PyInt(m.start), vm->PyInt(m.end) };
|
||||
return vm->PyTuple(vec);
|
||||
});
|
||||
|
||||
vm->bindMethod<1>(_tp_match, "group", [](VM* vm, const pkpy::ArgList& args) {
|
||||
auto& m = UNION_GET(ReMatch, args[0]);
|
||||
int index = (int)vm->PyInt_AS_C(args[1]);
|
||||
vm->normalizedIndex(index, m.m.size());
|
||||
return vm->PyStr(m.m[index].str());
|
||||
});
|
||||
return _tp_match;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
// C绑定过程
|
||||
// 一个C原生类
|
||||
// static PyVar _tp(VM* vm); 实现从VM中获取该类的类型对象
|
||||
// static PyVar _bind(VM* vm); 实现初始化该类的绑定，在VM中注册该类的类型对象，并返回生成的类型对象
|
||||
|
||||
PyVar __regex_search(const _Str& pattern, const _Str& string, bool fromStart, VM* vm){
|
||||
std::regex re(pattern);
|
||||
std::smatch m;
|
||||
@ -712,55 +679,28 @@ PyVar __regex_search(const _Str& pattern, const _Str& string, bool fromStart, VM
|
||||
if(fromStart && m.position() != 0) return vm->None;
|
||||
i64 start = string.__to_u8_index(m.position());
|
||||
i64 end = string.__to_u8_index(m.position() + m.length());
|
||||
return vm->new_object(vm->_userTypes["re.Match"], ReMatch(start, end, m));
|
||||
return vm->new_object_c<ReMatch>(start, end, m);
|
||||
}
|
||||
return vm->None;
|
||||
};
|
||||
|
||||
void __addModuleRe(VM* vm){
|
||||
PyVar mod = vm->newModule("re");
|
||||
PyVar _tp_match = vm->new_user_type_object(mod, "Match", vm->_tp_object);
|
||||
vm->bindMethod("re.Match", "start", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 1, true);
|
||||
return vm->PyInt(UNION_GET(ReMatch, args[0]).start);
|
||||
});
|
||||
ReMatch::_bind(vm);
|
||||
|
||||
vm->bindMethod("re.Match", "end", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 1, true);
|
||||
return vm->PyInt(UNION_GET(ReMatch, args[0]).end);
|
||||
});
|
||||
|
||||
vm->bindMethod("re.Match", "span", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 1, true);
|
||||
auto& m = UNION_GET(ReMatch, args[0]);
|
||||
PyVarList vec = { vm->PyInt(m.start), vm->PyInt(m.end) };
|
||||
return vm->PyTuple(vec);
|
||||
});
|
||||
|
||||
vm->bindMethod("re.Match", "group", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 2, true);
|
||||
auto& m = UNION_GET(ReMatch, args[0]);
|
||||
int index = (int)vm->PyInt_AS_C(args[1]);
|
||||
vm->normalizedIndex(index, m.m.size());
|
||||
return vm->PyStr(m.m[index].str());
|
||||
});
|
||||
|
||||
vm->bindFunc(mod, "match", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 2);
|
||||
vm->bindFunc<2>(mod, "match", [](VM* vm, const pkpy::ArgList& args) {
|
||||
const _Str& pattern = vm->PyStr_AS_C(args[0]);
|
||||
const _Str& string = vm->PyStr_AS_C(args[1]);
|
||||
return __regex_search(pattern, string, true, vm);
|
||||
});
|
||||
|
||||
vm->bindFunc(mod, "search", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 2);
|
||||
vm->bindFunc<2>(mod, "search", [](VM* vm, const pkpy::ArgList& args) {
|
||||
const _Str& pattern = vm->PyStr_AS_C(args[0]);
|
||||
const _Str& string = vm->PyStr_AS_C(args[1]);
|
||||
return __regex_search(pattern, string, false, vm);
|
||||
});
|
||||
|
||||
vm->bindFunc(mod, "sub", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 3);
|
||||
vm->bindFunc<3>(mod, "sub", [](VM* vm, const pkpy::ArgList& args) {
|
||||
const _Str& pattern = vm->PyStr_AS_C(args[0]);
|
||||
const _Str& repl = vm->PyStr_AS_C(args[1]);
|
||||
const _Str& string = vm->PyStr_AS_C(args[2]);
|
||||
@ -768,8 +708,7 @@ void __addModuleRe(VM* vm){
|
||||
return vm->PyStr(std::regex_replace(string, re, repl));
|
||||
});
|
||||
|
||||
vm->bindFunc(mod, "split", [](VM* vm, const pkpy::ArgList& args) {
|
||||
vm->check_args_size(args, 2);
|
||||
vm->bindFunc<2>(mod, "split", [](VM* vm, const pkpy::ArgList& args) {
|
||||
const _Str& pattern = vm->PyStr_AS_C(args[0]);
|
||||
const _Str& string = vm->PyStr_AS_C(args[1]);
|
||||
std::regex re(pattern);
|
||||
|
||||
66
src/vm.h
66
src/vm.h
@ -22,7 +22,6 @@
|
||||
|
||||
class VM {
|
||||
std::vector<PyVar> _small_integers; // [-5, 256]
|
||||
PyVarDict _modules; // loaded modules
|
||||
emhash8::HashMap<_Str, _Str> _lazy_modules; // lazy loaded modules
|
||||
protected:
|
||||
std::deque< std::unique_ptr<Frame> > callstack;
|
||||
@ -340,7 +339,7 @@ protected:
|
||||
|
||||
public:
|
||||
PyVarDict _types;
|
||||
PyVarDict _userTypes;
|
||||
PyVarDict _modules; // loaded modules
|
||||
PyVar None, True, False, Ellipsis;
|
||||
|
||||
bool use_stdio;
|
||||
@ -578,7 +577,6 @@ public:
|
||||
setattr(obj, __base__, base);
|
||||
_Str fullName = UNION_NAME(mod) + "." +name;
|
||||
setattr(obj, __name__, PyStr(fullName));
|
||||
_userTypes[fullName] = obj;
|
||||
setattr(mod, name, obj);
|
||||
return obj;
|
||||
}
|
||||
@ -597,6 +595,11 @@ public:
|
||||
return pkpy::make_shared<PyObject, Py_<T>>(_value, type);
|
||||
}
|
||||
|
||||
template<typename T, typename... Args>
|
||||
inline PyVar new_object_c(Args&&... args) {
|
||||
return new_object(T::_tp(this), T(std::forward<Args>(args)...));
|
||||
}
|
||||
|
||||
PyVar newModule(_Str name) {
|
||||
PyVar obj = new_object(_tp_module, (i64)-2);
|
||||
setattr(obj, __name__, PyStr(name));
|
||||
@ -658,28 +661,35 @@ public:
|
||||
setattr(obj.get(), name, value);
|
||||
}
|
||||
|
||||
void bindMethod(_Str typeName, _Str funcName, _CppFunc fn) {
|
||||
PyVar* type = _types.try_get(typeName);
|
||||
if(type == nullptr) type = _userTypes.try_get(typeName);
|
||||
if(type == nullptr) UNREACHABLE();
|
||||
PyVar func = PyNativeFunction(fn);
|
||||
setattr(*type, funcName, func);
|
||||
template<int ARGC>
|
||||
void bindMethod(PyVar obj, _Str funcName, _CppFuncRaw fn) {
|
||||
check_type(obj, _tp_type);
|
||||
setattr(obj, funcName, PyNativeFunction(_CppFunc(fn, ARGC, true)));
|
||||
}
|
||||
|
||||
void bindMethodMulti(std::vector<_Str> typeNames, _Str funcName, _CppFunc fn) {
|
||||
for(auto& typeName : typeNames){
|
||||
bindMethod(typeName, funcName, fn);
|
||||
}
|
||||
template<int ARGC>
|
||||
void bindFunc(PyVar obj, _Str funcName, _CppFuncRaw fn) {
|
||||
setattr(obj, funcName, PyNativeFunction(_CppFunc(fn, ARGC, false)));
|
||||
}
|
||||
|
||||
void bindBuiltinFunc(_Str funcName, _CppFunc fn) {
|
||||
bindFunc(builtins, funcName, fn);
|
||||
template<int ARGC>
|
||||
void bindMethod(_Str typeName, _Str funcName, _CppFuncRaw fn) {
|
||||
bindMethod<ARGC>(_types[typeName], funcName, fn);
|
||||
}
|
||||
|
||||
void bindFunc(PyVar module, _Str funcName, _CppFunc fn) {
|
||||
check_type(module, _tp_module);
|
||||
PyVar func = PyNativeFunction(fn);
|
||||
setattr(module, funcName, func);
|
||||
template<int ARGC>
|
||||
void bindStaticMethod(_Str typeName, _Str funcName, _CppFuncRaw fn) {
|
||||
bindFunc<ARGC>(_types[typeName], funcName, fn);
|
||||
}
|
||||
|
||||
template<int ARGC>
|
||||
void bindMethodMulti(std::vector<_Str> typeNames, _Str funcName, _CppFuncRaw fn) {
|
||||
for(auto& typeName : typeNames) bindMethod<ARGC>(typeName, funcName, fn);
|
||||
}
|
||||
|
||||
template<int ARGC>
|
||||
void bindBuiltinFunc(_Str funcName, _CppFuncRaw fn) {
|
||||
bindFunc<ARGC>(builtins, funcName, fn);
|
||||
}
|
||||
|
||||
inline bool is_int_or_float(const PyVar& obj) const{
|
||||
@ -848,8 +858,8 @@ public:
|
||||
_tp_bounded_method = new_type_object("_bounded_method");
|
||||
_tp_super = new_type_object("super");
|
||||
|
||||
this->None = new_object(_types["NoneType"], (i64)0);
|
||||
this->Ellipsis = new_object(_types["ellipsis"], (i64)0);
|
||||
this->None = new_object(_types["NoneType"], DUMMY_VAL);
|
||||
this->Ellipsis = new_object(_types["ellipsis"], DUMMY_VAL);
|
||||
this->True = new_object(_tp_bool, true);
|
||||
this->False = new_object(_tp_bool, false);
|
||||
this->builtins = newModule("builtins");
|
||||
@ -925,12 +935,6 @@ public:
|
||||
if(!obj->is_type(type)) typeError("expected '" + UNION_NAME(type) + "', but got '" + UNION_TP_NAME(obj) + "'");
|
||||
}
|
||||
|
||||
inline void check_args_size(const pkpy::ArgList& args, int size, bool method=false){
|
||||
if(args.size() == size) return;
|
||||
if(method) typeError(args.size()>size ? "too many arguments" : "too few arguments");
|
||||
else typeError("expected " + std::to_string(size) + " arguments, but got " + std::to_string(args.size()));
|
||||
}
|
||||
|
||||
virtual ~VM() {
|
||||
if(!use_stdio){
|
||||
delete _stdout;
|
||||
@ -1058,4 +1062,12 @@ PyVar RangeIterator::next(){
|
||||
|
||||
PyVar StringIterator::next(){
|
||||
return vm->PyStr(str.u8_getitem(index++));
|
||||
}
|
||||
|
||||
PyVar _CppFunc::operator()(VM* vm, const pkpy::ArgList& args) const{
|
||||
int args_size = args.size() - (int)method; // remove self
|
||||
if(argc != -1 && args_size != argc) {
|
||||
vm->typeError("expected " + std::to_string(argc) + " arguments, but got " + std::to_string(args_size));
|
||||
}
|
||||
return f(vm, args);
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user