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

refactor

Browse Source
This commit is contained in:
blueloveTH 2023-02-28 21:47:13 +08:00
parent 1ad12abbe1
commit 1e15cb2af2
4 changed files with 94 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
src/cffi.h
View File

@ -5,7 +5,7 @@
namespace pkpy {
struct CType{
PY_CLASS(c, type_)
PY_CLASS(CType, c, type_)
const char* name; // must be a literal
const int size;
@ -16,7 +16,7 @@ struct CType{
vm->bind_static_method<-1>(type, "__new__", CPP_NOT_IMPLEMENTED());
vm->bind_method<0>(type, "__repr__", [](VM* vm, Args& args) {
CType& self = vm->_cast<CType>(args[0]);
CType& self = CAST(CType, args[0]);
StrStream ss;
ss << "<c._type '" << self.name << "' (" << self.size*8 << " bits)>";
return VAR(ss.str());
@ -51,7 +51,7 @@ constexpr int C_TYPE(const char name[]){
#define C_TYPE_T(x) (kCTypes[C_TYPE(x)])
struct Pointer{
PY_CLASS(c, ptr_)
PY_CLASS(Pointer, c, ptr_)
void* ptr;
CType ctype; // base type
@ -70,61 +70,61 @@ struct Pointer{
vm->bind_static_method<-1>(type, "__new__", CPP_NOT_IMPLEMENTED());
vm->bind_method<0>(type, "__repr__", [](VM* vm, Args& args) {
Pointer& self = vm->_cast<Pointer>(args[0]);
Pointer& self = CAST(Pointer, args[0]);
StrStream ss;
ss << "<" << self.ctype.name << "* at " << (i64)self.ptr << ">";
return VAR(ss.str());
});
vm->bind_method<1>(type, "__add__", [](VM* vm, Args& args) {
Pointer& self = vm->_cast<Pointer>(args[0]);
return vm->new_object<Pointer>(self + CAST(i64, args[1]));
Pointer& self = CAST(Pointer, args[0]);
return VAR_T(Pointer, self + CAST(i64, args[1]));
});
vm->bind_method<1>(type, "__sub__", [](VM* vm, Args& args) {
Pointer& self = vm->_cast<Pointer>(args[0]);
return vm->new_object<Pointer>(self - CAST_V(i64, args[1]));
Pointer& self = CAST(Pointer, args[0]);
return VAR_T(Pointer, self - CAST_V(i64, args[1]));
});
vm->bind_method<1>(type, "__eq__", [](VM* vm, Args& args) {
Pointer& self = vm->_cast<Pointer>(args[0]);
Pointer& other = vm->_cast<Pointer>(args[1]);
Pointer& self = CAST(Pointer, args[0]);
Pointer& other = CAST(Pointer, args[1]);
return VAR(self.ptr == other.ptr);
});
vm->bind_method<1>(type, "__ne__", [](VM* vm, Args& args) {
Pointer& self = vm->_cast<Pointer>(args[0]);
Pointer& other = vm->_cast<Pointer>(args[1]);
Pointer& self = CAST(Pointer, args[0]);
Pointer& other = CAST(Pointer, args[1]);
return VAR(self.ptr != other.ptr);
});
// https://docs.python.org/zh-cn/3/library/ctypes.html
vm->bind_method<1>(type, "__getitem__", [](VM* vm, Args& args) {
Pointer& self = vm->_cast<Pointer>(args[0]);
Pointer& self = CAST(Pointer, args[0]);
i64 index = CAST_V(i64, args[1]);
return (self+index).get(vm);
});
vm->bind_method<2>(type, "__setitem__", [](VM* vm, Args& args) {
Pointer& self = vm->_cast<Pointer>(args[0]);
Pointer& self = CAST(Pointer, args[0]);
i64 index = CAST_V(i64, args[1]);
(self+index).set(vm, args[2]);
return vm->None;
});
vm->bind_method<1>(type, "cast", [](VM* vm, Args& args) {
Pointer& self = vm->_cast<Pointer>(args[0]);
CType& ctype = vm->_cast<CType>(args[1]);
return vm->new_object<Pointer>(self.ptr, ctype);
Pointer& self = CAST(Pointer, args[0]);
CType& ctype = CAST(CType, args[1]);
return VAR_T(Pointer, self.ptr, ctype);
});
vm->bind_method<0>(type, "get", [](VM* vm, Args& args) {
Pointer& self = vm->_cast<Pointer>(args[0]);
Pointer& self = CAST(Pointer, args[0]);
return self.get(vm);
});
vm->bind_method<1>(type, "set", [](VM* vm, Args& args) {
Pointer& self = vm->_cast<Pointer>(args[0]);
Pointer& self = CAST(Pointer, args[0]);
self.set(vm, args[1]);
return vm->None;
});
@ -155,7 +155,7 @@ struct Pointer{
case C_TYPE("uint16_"): return VAR(ref<uint16_t>());
case C_TYPE("uint32_"): return VAR(ref<uint32_t>());
case C_TYPE("uint64_"): return VAR(ref<uint64_t>());
case C_TYPE("void_p_"): return vm->new_object<Pointer>(ref<void*>(), C_TYPE_T("void_"));
case C_TYPE("void_p_"): return VAR_T(Pointer, ref<void*>(), C_TYPE_T("void_"));
// use macro here to do extension
default: UNREACHABLE();
}
@ -178,7 +178,7 @@ struct Pointer{
case C_TYPE("uint16_"): ref<uint16_t>() = CAST_V(i64, val); break;
case C_TYPE("uint32_"): ref<uint32_t>() = CAST_V(i64, val); break;
case C_TYPE("uint64_"): ref<uint64_t>() = CAST_V(i64, val); break;
case C_TYPE("void_p_"): ref<void*>() = vm->_cast<Pointer>(val).ptr; break;
case C_TYPE("void_p_"): ref<void*>() = CAST(Pointer, val).ptr; break;
// use macro here to do extension
default: UNREACHABLE();
}
@ -209,7 +209,7 @@ static const StructMetaInfo _Point2_info = {
};
struct Struct {
PY_CLASS(c, struct_)
PY_CLASS(Struct, c, struct_)
const StructMetaInfo* info;
int8_t* _data; // store any `struct`
@ -238,11 +238,11 @@ struct Struct {
static void _register(VM* vm, PyVar mod, PyVar type){
vm->bind_static_method<-1>(type, "__new__", [](VM* vm, Args& args) {
return vm->new_object<Struct>();
return VAR_T(Struct);
});
vm->bind_method<0>(type, "__repr__", [](VM* vm, Args& args) {
Struct& self = vm->_cast<Struct>(args[0]);
Struct& self = CAST(Struct, args[0]);
StrStream ss;
ss << self.info->name << "(" << ")";
return VAR(ss.str());
@ -252,41 +252,41 @@ struct Struct {
void add_module_c(VM* vm){
PyVar mod = vm->new_module("c");
PyVar ptr_t = vm->register_class<Pointer>(mod);
vm->register_class<CType>(mod);
vm->register_class<Struct>(mod);
PyVar ptr_t = Pointer::register_class(vm, mod);
CType::register_class(vm, mod);
Struct::register_class(vm, mod);
for(int i=0; i<kCTypeCount; i++){
vm->setattr(mod, kCTypes[i].name, vm->new_object<CType>(kCTypes[i]));
vm->setattr(mod, kCTypes[i].name, VAR_T(CType, kCTypes[i]));
}
vm->setattr(mod, "nullptr", vm->new_object<Pointer>(nullptr, C_TYPE_T("void_")));
vm->setattr(mod, "nullptr", VAR_T(Pointer, nullptr, C_TYPE_T("void_")));
vm->bind_func<1>(mod, "malloc", [](VM* vm, Args& args) {
i64 size = CAST_V(i64, args[0]);
return vm->new_object<Pointer>(malloc(size), C_TYPE_T("void_"));
return VAR_T(Pointer, malloc(size), C_TYPE_T("void_"));
});
vm->bind_func<1>(mod, "free", [](VM* vm, Args& args) {
Pointer& self = vm->_cast<Pointer>(args[0]);
Pointer& self = CAST(Pointer, args[0]);
free(self.ptr);
return vm->None;
});
vm->bind_func<1>(mod, "sizeof", [](VM* vm, Args& args) {
CType& ctype = vm->_cast<CType>(args[0]);
CType& ctype = CAST(CType, args[0]);
return VAR(ctype.size);
});
vm->bind_func<3>(mod, "memcpy", [](VM* vm, Args& args) {
Pointer& dst = vm->_cast<Pointer>(args[0]);
Pointer& src = vm->_cast<Pointer>(args[1]);
Pointer& dst = CAST(Pointer, args[0]);
Pointer& src = CAST(Pointer, args[1]);
i64 size = CAST_V(i64, args[2]);
memcpy(dst.ptr, src.ptr, size);
return vm->None;
});
vm->bind_func<3>(mod, "memset", [](VM* vm, Args& args) {
Pointer& dst = vm->_cast<Pointer>(args[0]);
Pointer& dst = CAST(Pointer, args[0]);
i64 val = CAST_V(i64, args[1]);
i64 size = CAST_V(i64, args[2]);
memset(dst.ptr, (int)val, size);
@ -296,10 +296,10 @@ void add_module_c(VM* vm){
vm->bind_func<1>(mod, "strdup", [ptr_t](VM* vm, Args& args) {
if(is_type(args[0], vm->tp_str)){
const Str& s = CAST(Str, args[0]);
return vm->new_object<Pointer>(strdup(s.c_str()), C_TYPE_T("char_"));
return VAR_T(Pointer, strdup(s.c_str()), C_TYPE_T("char_"));
}else if(is_type(args[0], OBJ_GET(Type, ptr_t))){
Pointer& p = vm->_cast<Pointer>(args[0]);
return vm->new_object<Pointer>(strdup(p.cast<char*>()), C_TYPE_T("char_"));
Pointer& p = CAST(Pointer, args[0]);
return VAR_T(Pointer, strdup(p.cast<char*>()), C_TYPE_T("char_"));
}else{
vm->TypeError("strdup() argument must be 'str' or 'char*'");
return vm->None;
@ -307,13 +307,13 @@ void add_module_c(VM* vm){
});
vm->bind_func<2>(mod, "strcmp", [](VM* vm, Args& args) {
Pointer& p1 = vm->_cast<Pointer>(args[0]);
Pointer& p2 = vm->_cast<Pointer>(args[1]);
Pointer& p1 = CAST(Pointer, args[0]);
Pointer& p2 = CAST(Pointer, args[1]);
return VAR(strcmp(p1.cast<char*>(), p2.cast<char*>()));
});
vm->bind_func<1>(mod, "strlen", [](VM* vm, Args& args) {
Pointer& p = vm->_cast<Pointer>(args[0]);
Pointer& p = CAST(Pointer, args[0]);
return VAR(strlen(p.cast<char*>()));
});
}

42
src/obj.h
View File

@ -149,14 +149,19 @@ inline bool is_float(const PyVar& obj) noexcept {
return obj.is_tag_10();
}
#define PY_CLASS(mod, name) \
inline static Type _type(VM* vm) { \
#define PY_CLASS(T, mod, name) \
static Type _type(VM* vm) { \
static StrName __x0(#mod); \
static StrName __x1(#name); \
return OBJ_GET(Type, vm->_modules[__x0]->attr(__x1)); \
} \
inline static const char* _mod() { return #mod; } \
inline static const char* _name() { return #name; }
return OBJ_GET(Type, vm->_modules[__x0]->attr(__x1)); \
} \
static PyVar register_class(VM* vm, PyVar mod) { \
PyVar type = vm->new_type_object(mod, #name, vm->_t(vm->tp_object));\
if(OBJ_NAME(mod) != #mod) UNREACHABLE(); \
T::_register(vm, mod, type); \
type->attr()._try_perfect_rehash(); \
return type; \
}
union __8B {
i64 _int;
@ -165,16 +170,37 @@ union __8B {
__8B(f64 val) : _float(val) {}
};
template <typename, typename = void> struct is_py_class : std::false_type {};
template <typename T> struct is_py_class<T, std::void_t<decltype(T::_type)>> : std::true_type {};
template<typename T>
T py_cast_v(VM* vm, const PyVar& var) { UNREACHABLE(); }
template<typename T>
T _py_cast_v(VM* vm, const PyVar& var) { UNREACHABLE(); }
template<typename T>
T& py_cast(VM* vm, const PyVar& var) { UNREACHABLE(); }
void _check_py_class(VM* vm, const PyVar& var);
template<typename T>
T& _py_cast(VM* vm, const PyVar& var) { UNREACHABLE(); }
T& py_cast(VM* vm, const PyVar& obj) {
if constexpr(is_py_class<T>::value){
_check_py_class<T>(vm, obj);
return OBJ_GET(T, obj);
}else{
throw std::runtime_error("bad py_cast() call");
}
}
template<typename T>
T& _py_cast(VM* vm, const PyVar& obj) {
if constexpr(is_py_class<T>::value){
return OBJ_GET(T, obj);
}else{
throw std::runtime_error("bad py_cast() call");
}
}
#define VAR(x) py_var(vm, x)
#define VAR_T(T, ...) vm->new_object(T::_type(vm), T(__VA_ARGS__))
#define CAST(T, x) py_cast<T>(vm, x)
#define CAST_V(T, x) py_cast_v<T>(vm, x)
#define _CAST(T, x) _py_cast<T>(vm, x)

28
src/pocketpy.h
View File

@ -611,7 +611,7 @@ void add_module_dis(VM* vm){
}
struct FileIO {
PY_CLASS(io, FileIO)
PY_CLASS(FileIO, io, FileIO)
Str file;
Str mode;
@ -630,32 +630,32 @@ struct FileIO {
static void _register(VM* vm, PyVar mod, PyVar type){
vm->bind_static_method<2>(type, "__new__", [](VM* vm, Args& args){
return vm->new_object<FileIO>(
return VAR_T(FileIO,
vm, CAST(Str, args[0]), CAST(Str, args[1])
);
});
vm->bind_method<0>(type, "read", [](VM* vm, Args& args){
FileIO& io = vm->_cast<FileIO>(args[0]);
FileIO& io = CAST(FileIO, args[0]);
std::string buffer;
io._fs >> buffer;
return VAR(buffer);
});
vm->bind_method<1>(type, "write", [](VM* vm, Args& args){
FileIO& io = vm->_cast<FileIO>(args[0]);
FileIO& io = CAST(FileIO, args[0]);
io._fs << CAST(Str, args[1]);
return vm->None;
});
vm->bind_method<0>(type, "close", [](VM* vm, Args& args){
FileIO& io = vm->_cast<FileIO>(args[0]);
FileIO& io = CAST(FileIO, args[0]);
io._fs.close();
return vm->None;
});
vm->bind_method<0>(type, "__exit__", [](VM* vm, Args& args){
FileIO& io = vm->_cast<FileIO>(args[0]);
FileIO& io = CAST(FileIO, args[0]);
io._fs.close();
return vm->None;
});
@ -665,7 +665,7 @@ struct FileIO {
};
void add_module_io(VM* vm){
PyVar mod = vm->new_module("io");
PyVar type = vm->register_class<FileIO>(mod);
PyVar type = FileIO::register_class(vm, mod);
vm->bind_builtin_func<2>("open", [type](VM* vm, const Args& args){
return vm->call(type, args);
});
@ -674,7 +674,7 @@ void add_module_io(VM* vm){
void add_module_os(VM* vm){}
struct ReMatch {
PY_CLASS(re, Match)
PY_CLASS(ReMatch, re, Match)
i64 start;
i64 end;
@ -683,16 +683,16 @@ struct ReMatch {
static void _register(VM* vm, PyVar mod, PyVar type){
vm->bind_method<-1>(type, "__init__", CPP_NOT_IMPLEMENTED());
vm->bind_method<0>(type, "start", CPP_LAMBDA(VAR(vm->_cast<ReMatch>(args[0]).start)));
vm->bind_method<0>(type, "end", CPP_LAMBDA(VAR(vm->_cast<ReMatch>(args[0]).end)));
vm->bind_method<0>(type, "start", CPP_LAMBDA(VAR(CAST(ReMatch, args[0]).start)));
vm->bind_method<0>(type, "end", CPP_LAMBDA(VAR(CAST(ReMatch, args[0]).end)));
vm->bind_method<0>(type, "span", [](VM* vm, Args& args) {
auto& self = vm->_cast<ReMatch>(args[0]);
auto& self = CAST(ReMatch, args[0]);
return VAR(two_args(VAR(self.start), VAR(self.end)));
});
vm->bind_method<1>(type, "group", [](VM* vm, Args& args) {
auto& self = vm->_cast<ReMatch>(args[0]);
auto& self = CAST(ReMatch, args[0]);
int index = (int)CAST_V(i64, args[1]);
index = vm->normalized_index(index, self.m.size());
return VAR(self.m[index].str());
@ -707,14 +707,14 @@ PyVar _regex_search(const Str& pattern, const Str& string, bool fromStart, VM* v
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<ReMatch>(start, end, m);
return VAR_T(ReMatch, start, end, m);
}
return vm->None;
};
void add_module_re(VM* vm){
PyVar mod = vm->new_module("re");
vm->register_class<ReMatch>(mod);
ReMatch::register_class(vm, mod);
vm->bind_func<2>(mod, "match", [](VM* vm, Args& args) {
const Str& pattern = CAST(Str, args[0]);

25
src/vm.h
View File

@ -192,11 +192,6 @@ public:
return make_sp<PyObject, Py_<RAW(T)>>(type, std::move(_value));
}
template<typename T, typename... Args>
inline PyVar new_object(Args&&... args) {
return new_object(T::_type(this), T(std::forward<Args>(args)...));
}
template<int ARGC>
void bind_func(Str typeName, Str funcName, NativeFuncRaw fn) {
bind_func<ARGC>(_types[typeName], funcName, fn);
@ -290,21 +285,6 @@ public:
return _all_types[OBJ_GET(Type, _t(obj->type)).index];
}
template<typename T>
PyVar register_class(PyVar mod){
PyVar type = new_type_object(mod, T::_name(), _t(tp_object));
if(OBJ_NAME(mod) != T::_mod()) UNREACHABLE();
T::_register(this, mod, type);
type->attr()._try_perfect_rehash();
return type;
}
template<typename T>
inline T& _cast(const PyVar& obj){
check_type(obj, T::_type(this));
return OBJ_GET(T, obj);
}
~VM() {
if(!use_stdio){
delete _stdout;
@ -446,6 +426,11 @@ PyVar py_var(VM* vm, const char* val){
return VAR(Str(val));
}
template<typename T>
void _check_py_class(VM* vm, const PyVar& obj){
vm->check_type(obj, T::_type(vm));
}
PyVar VM::num_negated(const PyVar& obj){
if (is_int(obj)){
return VAR(-CAST_V(i64, obj));