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

up

Browse Source
This commit is contained in:
blueloveTH 2023-02-27 19:22:03 +08:00
parent f13caf5c48
commit 3c972c9f46
4 changed files with 80 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
src/cffi.h
View File

@ -141,20 +141,20 @@ struct Pointer{
PyVar get(VM* vm){
switch(ctype.index){
case C_TYPE("char_"): return vm->PyInt(ref<char>());
case C_TYPE("int_"): return vm->PyInt(ref<int>());
case C_TYPE("char_"): return py_object(vm, ref<char>());
case C_TYPE("int_"): return py_object(vm, ref<int>());
case C_TYPE("float_"): return vm->PyFloat(ref<float>());
case C_TYPE("double_"): return vm->PyFloat(ref<double>());
case C_TYPE("bool_"): return vm->PyBool(ref<bool>());
case C_TYPE("void_"): vm->ValueError("cannot get void*"); break;
case C_TYPE("int8_"): return vm->PyInt(ref<int8_t>());
case C_TYPE("int16_"): return vm->PyInt(ref<int16_t>());
case C_TYPE("int32_"): return vm->PyInt(ref<int32_t>());
case C_TYPE("int64_"): return vm->PyInt(ref<int64_t>());
case C_TYPE("uint8_"): return vm->PyInt(ref<uint8_t>());
case C_TYPE("uint16_"): return vm->PyInt(ref<uint16_t>());
case C_TYPE("uint32_"): return vm->PyInt(ref<uint32_t>());
case C_TYPE("uint64_"): return vm->PyInt(ref<uint64_t>());
case C_TYPE("int8_"): return py_object(vm, ref<int8_t>());
case C_TYPE("int16_"): return py_object(vm, ref<int16_t>());
case C_TYPE("int32_"): return py_object(vm, ref<int32_t>());
case C_TYPE("int64_"): return py_object(vm, ref<int64_t>());
case C_TYPE("uint8_"): return py_object(vm, ref<uint8_t>());
case C_TYPE("uint16_"): return py_object(vm, ref<uint16_t>());
case C_TYPE("uint32_"): return py_object(vm, ref<uint32_t>());
case C_TYPE("uint64_"): return py_object(vm, ref<uint64_t>());
case C_TYPE("void_p_"): return vm->new_object<Pointer>(ref<void*>(), C_TYPE_T("void_"));
// use macro here to do extension
default: UNREACHABLE();
@ -274,7 +274,7 @@ void add_module_c(VM* vm){
vm->bind_func<1>(mod, "sizeof", [](VM* vm, Args& args) {
CType& ctype = vm->py_cast<CType>(args[0]);
return vm->PyInt(ctype.size);
return py_object(vm, ctype.size);
});
vm->bind_func<3>(mod, "memcpy", [](VM* vm, Args& args) {
@ -309,12 +309,12 @@ void add_module_c(VM* vm){
vm->bind_func<2>(mod, "strcmp", [](VM* vm, Args& args) {
Pointer& p1 = vm->py_cast<Pointer>(args[0]);
Pointer& p2 = vm->py_cast<Pointer>(args[1]);
return vm->PyInt(strcmp(p1.cast<char*>(), p2.cast<char*>()));
return py_object(vm, strcmp(p1.cast<char*>(), p2.cast<char*>()));
});
vm->bind_func<1>(mod, "strlen", [](VM* vm, Args& args) {
Pointer& p = vm->py_cast<Pointer>(args[0]);
return vm->PyInt(strlen(p.cast<char*>()));
return py_object(vm, strlen(p.cast<char*>()));
});
}

2
src/iter.h
View File

@ -20,7 +20,7 @@ public:
PyVar next(){
if(!_has_next()) return nullptr;
current += r.step;
return vm->PyInt(current-r.step);
return py_object(vm, current-r.step);
}
};

48
src/pocketpy.h
View File

@ -22,7 +22,7 @@ CodeObject_ VM::compile(Str source, Str filename, CompileMode mode) {
#define BIND_NUM_ARITH_OPT(name, op) \
_vm->_bind_methods<1>({"int","float"}, #name, [](VM* vm, Args& args){ \
if(is_both_int(args[0], args[1])){ \
return vm->PyInt(vm->_PyInt_AS_C(args[0]) op vm->_PyInt_AS_C(args[1])); \
return py_object(vm, vm->_PyInt_AS_C(args[0]) op vm->_PyInt_AS_C(args[1])); \
}else{ \
return vm->PyFloat(vm->num_to_float(args[0]) op vm->num_to_float(args[1])); \
} \
@ -73,8 +73,8 @@ void init_builtins(VM* _vm) {
_vm->bind_builtin_func<1>("id", [](VM* vm, Args& args) {
const PyVar& obj = args[0];
if(obj.is_tagged()) return vm->PyInt((i64)0);
return vm->PyInt(obj.bits);
if(obj.is_tagged()) return py_object(vm, (i64)0);
return py_object(vm, obj.bits);
});
_vm->bind_builtin_func<1>("eval", [](VM* vm, Args& args) {
@ -101,7 +101,7 @@ void init_builtins(VM* _vm) {
_vm->bind_builtin_func<1>("hash", [](VM* vm, Args& args){
i64 value = vm->hash(args[0]);
if(((value << 2) >> 2) != value) value >>= 2;
return vm->PyInt(value);
return py_object(vm, value);
});
_vm->bind_builtin_func<1>("chr", [](VM* vm, Args& args) {
@ -113,7 +113,7 @@ void init_builtins(VM* _vm) {
_vm->bind_builtin_func<1>("ord", [](VM* vm, Args& 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.c_str()[0]));
return py_object(vm, (i64)(s.c_str()[0]));
});
_vm->bind_builtin_func<2>("hasattr", [](VM* vm, Args& args) {
@ -201,7 +201,7 @@ void init_builtins(VM* _vm) {
rhs >>= 1;
}
if(flag) return vm->PyFloat((f64)(1.0 / ret));
return vm->PyInt(ret);
return py_object(vm, ret);
}else{
return vm->PyFloat((f64)std::pow(vm->num_to_float(args[0]), vm->num_to_float(args[1])));
}
@ -210,15 +210,15 @@ void init_builtins(VM* _vm) {
/************ PyInt ************/
_vm->bind_static_method<1>("int", "__new__", [](VM* vm, Args& args) {
if (is_type(args[0], vm->tp_int)) return args[0];
if (is_type(args[0], vm->tp_float)) return vm->PyInt((i64)vm->PyFloat_AS_C(args[0]));
if (is_type(args[0], vm->tp_bool)) return vm->PyInt(vm->_PyBool_AS_C(args[0]) ? 1 : 0);
if (is_type(args[0], vm->tp_float)) return py_object(vm, (i64)vm->PyFloat_AS_C(args[0]));
if (is_type(args[0], vm->tp_bool)) return py_object(vm, vm->_PyBool_AS_C(args[0]) ? 1 : 0);
if (is_type(args[0], vm->tp_str)) {
const Str& s = vm->PyStr_AS_C(args[0]);
try{
size_t parsed = 0;
i64 val = S_TO_INT(s, &parsed, 10);
if(parsed != s.size()) throw std::invalid_argument("<?>");
return vm->PyInt(val);
return py_object(vm, val);
}catch(std::invalid_argument&){
vm->ValueError("invalid literal for int(): " + s.escape(true));
}
@ -230,20 +230,20 @@ void init_builtins(VM* _vm) {
_vm->bind_method<1>("int", "__floordiv__", [](VM* vm, Args& args) {
i64 rhs = vm->PyInt_AS_C(args[1]);
if(rhs == 0) vm->ZeroDivisionError();
return vm->PyInt(vm->PyInt_AS_C(args[0]) / rhs);
return py_object(vm, vm->PyInt_AS_C(args[0]) / rhs);
});
_vm->bind_method<1>("int", "__mod__", [](VM* vm, Args& args) {
i64 rhs = vm->PyInt_AS_C(args[1]);
if(rhs == 0) vm->ZeroDivisionError();
return vm->PyInt(vm->PyInt_AS_C(args[0]) % rhs);
return py_object(vm, vm->PyInt_AS_C(args[0]) % rhs);
});
_vm->bind_method<0>("int", "__repr__", CPP_LAMBDA(vm->PyStr(std::to_string(vm->PyInt_AS_C(args[0])))));
_vm->bind_method<0>("int", "__json__", CPP_LAMBDA(vm->PyStr(std::to_string(vm->PyInt_AS_C(args[0])))));
#define INT_BITWISE_OP(name,op) \
_vm->bind_method<1>("int", #name, CPP_LAMBDA(vm->PyInt(vm->PyInt_AS_C(args[0]) op vm->PyInt_AS_C(args[1]))));
_vm->bind_method<1>("int", #name, CPP_LAMBDA(py_object(vm, vm->PyInt_AS_C(args[0]) op vm->PyInt_AS_C(args[1]))));
INT_BITWISE_OP(__lshift__, <<)
INT_BITWISE_OP(__rshift__, >>)
@ -300,7 +300,7 @@ void init_builtins(VM* _vm) {
_vm->bind_method<0>("str", "__len__", [](VM* vm, Args& args) {
const Str& self = vm->PyStr_AS_C(args[0]);
return vm->PyInt(self.u8_length());
return py_object(vm, self.u8_length());
});
_vm->bind_method<1>("str", "__contains__", [](VM* vm, Args& args) {
@ -447,7 +447,7 @@ void init_builtins(VM* _vm) {
_vm->bind_method<0>("list", "__len__", [](VM* vm, Args& args) {
const List& self = vm->PyList_AS_C(args[0]);
return vm->PyInt(self.size());
return py_object(vm, self.size());
});
_vm->bind_method<0>("list", "__iter__", [](VM* vm, Args& args) {
@ -514,7 +514,7 @@ void init_builtins(VM* _vm) {
_vm->bind_method<0>("tuple", "__len__", [](VM* vm, Args& args) {
const Tuple& self = vm->PyTuple_AS_C(args[0]);
return vm->PyInt(self.size());
return py_object(vm, self.size());
});
/************ PyBool ************/
@ -565,8 +565,8 @@ void add_module_sys(VM* vm){
PyVar mod = vm->new_module("sys");
vm->setattr(mod, "version", vm->PyStr(PK_VERSION));
vm->bind_func<1>(mod, "getrefcount", CPP_LAMBDA(vm->PyInt(args[0].use_count())));
vm->bind_func<0>(mod, "getrecursionlimit", CPP_LAMBDA(vm->PyInt(vm->recursionlimit)));
vm->bind_func<1>(mod, "getrefcount", CPP_LAMBDA(py_object(vm, args[0].use_count())));
vm->bind_func<0>(mod, "getrecursionlimit", CPP_LAMBDA(py_object(vm, vm->recursionlimit)));
vm->bind_func<1>(mod, "setrecursionlimit", [](VM* vm, Args& args) {
vm->recursionlimit = (int)vm->PyInt_AS_C(args[0]);
@ -599,8 +599,8 @@ void add_module_math(VM* vm){
vm->bind_func<1>(mod, "isnan", CPP_LAMBDA(vm->PyBool(std::isnan(vm->num_to_float(args[0])))));
vm->bind_func<1>(mod, "isinf", CPP_LAMBDA(vm->PyBool(std::isinf(vm->num_to_float(args[0])))));
vm->bind_func<1>(mod, "fabs", CPP_LAMBDA(vm->PyFloat(std::fabs(vm->num_to_float(args[0])))));
vm->bind_func<1>(mod, "floor", CPP_LAMBDA(vm->PyInt((i64)std::floor(vm->num_to_float(args[0])))));
vm->bind_func<1>(mod, "ceil", CPP_LAMBDA(vm->PyInt((i64)std::ceil(vm->num_to_float(args[0])))));
vm->bind_func<1>(mod, "floor", CPP_LAMBDA(py_object(vm, (i64)std::floor(vm->num_to_float(args[0])))));
vm->bind_func<1>(mod, "ceil", CPP_LAMBDA(py_object(vm, (i64)std::ceil(vm->num_to_float(args[0])))));
vm->bind_func<1>(mod, "sqrt", CPP_LAMBDA(vm->PyFloat(std::sqrt(vm->num_to_float(args[0])))));
}
@ -688,12 +688,12 @@ 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(vm->PyInt(vm->py_cast<ReMatch>(args[0]).start)));
vm->bind_method<0>(type, "end", CPP_LAMBDA(vm->PyInt(vm->py_cast<ReMatch>(args[0]).end)));
vm->bind_method<0>(type, "start", CPP_LAMBDA(py_object(vm, vm->py_cast<ReMatch>(args[0]).start)));
vm->bind_method<0>(type, "end", CPP_LAMBDA(py_object(vm, vm->py_cast<ReMatch>(args[0]).end)));
vm->bind_method<0>(type, "span", [](VM* vm, Args& args) {
auto& self = vm->py_cast<ReMatch>(args[0]);
return vm->PyTuple({ vm->PyInt(self.start), vm->PyInt(self.end) });
return vm->PyTuple({ py_object(vm, self.start), py_object(vm, self.end) });
});
vm->bind_method<1>(type, "group", [](VM* vm, Args& args) {
@ -768,7 +768,7 @@ void add_module_random(VM* vm){
i64 a = vm->PyInt_AS_C(args[0]);
i64 b = vm->PyInt_AS_C(args[1]);
if(a > b) std::swap(a, b);
return vm->PyInt(a + std::rand() % (b - a + 1));
return py_object(vm, a + std::rand() % (b - a + 1));
});
vm->bind_func<2>(mod, "uniform", [](VM* vm, Args& args) {
@ -975,7 +975,7 @@ extern "C" {
}
char* packet = strdup(ss.str().c_str());
switch(ret_code){
case 'i': return vm->PyInt(f_int(packet));
case 'i': return py_object(vm, f_int(packet));
case 'f': return vm->PyFloat(f_float(packet));
case 'b': return vm->PyBool(f_bool(packet));
case 's': {

64
src/vm.h
View File

@ -4,7 +4,7 @@
#include "error.h"
namespace pkpy{
#define DEF_NATIVE(type, ctype, ptype) \
inline ctype& Py##type##_AS_C(const PyVar& obj) { \
check_type(obj, ptype); \
@ -13,6 +13,17 @@ namespace pkpy{
inline PyVar Py##type(const ctype& value) { return new_object(ptype, value);} \
inline PyVar Py##type(ctype&& value) { return new_object(ptype, std::move(value));}
#define DEF_NATIVE_2(ctype, ptype) \
template<> ctype& py_cast<ctype>(VM* vm, const PyVar& obj) { \
vm->check_type(obj, vm->ptype); \
return OBJ_GET(ctype, obj); \
} \
template<> ctype& _py_cast<ctype>(VM* vm, const PyVar& obj) { \
return OBJ_GET(ctype, obj); \
} \
PyVar py_object(VM* vm, const ctype& value) { return vm->new_object(vm->ptype, value);} \
PyVar py_object(VM* vm, ctype&& value) { return vm->new_object(vm->ptype, std::move(value));}
class Generator: public BaseIter {
std::unique_ptr<Frame> frame;
int state; // 0,1,2
@ -307,12 +318,16 @@ public:
template<typename T>
inline PyVar new_object(const PyVar& type, const T& _value) {
#ifdef PK_EXTRA_CHECK
if(!is_type(type, tp_type)) UNREACHABLE();
#endif
return make_sp<PyObject, Py_<RAW(T)>>(OBJ_GET(Type, type), _value);
}
template<typename T>
inline PyVar new_object(const PyVar& type, T&& _value) {
#ifdef PK_EXTRA_CHECK
if(!is_type(type, tp_type)) UNREACHABLE();
#endif
return make_sp<PyObject, Py_<RAW(T)>>(OBJ_GET(Type, type), std::move(_value));
}
@ -436,16 +451,6 @@ public:
return 0;
}
PyVar num_negated(const PyVar& obj){
if (is_int(obj)){
return PyInt(-PyInt_AS_C(obj));
}else if(is_float(obj)){
return PyFloat(-PyFloat_AS_C(obj));
}
TypeError("expected 'int' or 'float', got " + OBJ_NAME(_t(obj)).escape(true));
return nullptr;
}
int normalized_index(int index, int size){
if(index < 0) index += size;
if(index < 0 || index >= size){
@ -567,14 +572,6 @@ public:
return new_object(tp_str, value);
}
inline PyVar PyInt(i64 value) {
if(((value << 2) >> 2) != value){
_error("OverflowError", std::to_string(value) + " is out of range");
}
value = (value << 2) | 0b01;
return PyVar(reinterpret_cast<int*>(value));
}
inline i64 PyInt_AS_C(const PyVar& obj){
check_type(obj, tp_int);
return obj.bits >> 2;
@ -679,8 +676,6 @@ public:
for(auto [k, v]: _modules.items()) v->attr()._try_perfect_rehash();
}
void post_init();
i64 hash(const PyVar& obj){
if (is_type(obj, tp_str)) return PyStr_AS_C(obj).hash();
if (is_int(obj)) return PyInt_AS_C(obj);
@ -792,6 +787,8 @@ public:
}
CodeObject_ compile(Str source, Str filename, CompileMode mode);
void post_init();
PyVar num_negated(const PyVar& obj);
};
/***** Pointers' Impl *****/
@ -958,7 +955,9 @@ void CodeObject::optimize(VM* vm){
template<typename T>
std::enable_if_t<std::is_integral_v<T>, PyVar> py_object(VM* vm, T _val){
i64 val = static_cast<i64>(_val);
if(((val << 2) >> 2) != val) vm->_error("OverflowError", std::to_string(val));
if(((val << 2) >> 2) != val){
vm->_error("OverflowError", std::to_string(val) + " is out of range");
}
val = (val << 2) | 0b01;
return PyVar(reinterpret_cast<int*>(val));
}
@ -999,4 +998,25 @@ template<> bool _py_cast<bool>(VM* vm, const PyVar& obj){
return obj == vm->True;
}
DEF_NATIVE_2(List, tp_list)
DEF_NATIVE_2(Tuple, tp_tuple)
DEF_NATIVE_2(Function, tp_function)
DEF_NATIVE_2(NativeFunc, tp_native_function)
DEF_NATIVE_2(BoundMethod, tp_bound_method)
DEF_NATIVE_2(Range, tp_range)
DEF_NATIVE_2(Slice, tp_slice)
DEF_NATIVE_2(Exception, tp_exception)
DEF_NATIVE_2(StarWrapper, tp_star_wrapper)
PyVar VM::num_negated(const PyVar& obj){
if (is_int(obj)){
return py_object(this, -PyInt_AS_C(obj));
}else if(is_float(obj)){
return py_object(this, -PyFloat_AS_C(obj));
}
TypeError("expected 'int' or 'float', got " + OBJ_NAME(_t(obj)).escape(true));
return nullptr;
}
} // namespace pkpy