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

macros

Browse Source
This commit is contained in:
blueloveTH 2023-02-28 00:53:49 +08:00
parent a16afde3ea
commit 1ad12abbe1
6 changed files with 189 additions and 194 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
src/ceval.h
View File

@ -18,12 +18,12 @@ PyVar VM::run_frame(Frame* frame){
case OP_LOAD_CONST: frame->push(frame->co->consts[byte.arg]); continue; case OP_LOAD_CONST: frame->push(frame->co->consts[byte.arg]); continue;
case OP_LOAD_FUNCTION: { case OP_LOAD_FUNCTION: {
const PyVar obj = frame->co->consts[byte.arg]; const PyVar obj = frame->co->consts[byte.arg];
Function f = py_cast_v<Function>(this, obj); // copy Function f = CAST_V(Function, obj); // copy
f._module = frame->_module; f._module = frame->_module;
frame->push(py_var(this, f)); frame->push(VAR(f));
} continue; } continue;
case OP_SETUP_CLOSURE: { case OP_SETUP_CLOSURE: {
Function& f = py_cast<Function>(this, frame->top()); // reference Function& f = CAST(Function, frame->top()); // reference
f._closure = frame->_locals; f._closure = frame->_locals;
} continue; } continue;
case OP_LOAD_NAME_REF: { case OP_LOAD_NAME_REF: {
@ -70,7 +70,7 @@ PyVar VM::run_frame(Frame* frame){
continue; continue;
case OP_BUILD_TUPLE: { case OP_BUILD_TUPLE: {
Args items = frame->pop_n_values_reversed(this, byte.arg); Args items = frame->pop_n_values_reversed(this, byte.arg);
frame->push(py_var(this, std::move(items))); frame->push(VAR(std::move(items)));
} continue; } continue;
case OP_BUILD_TUPLE_REF: { case OP_BUILD_TUPLE_REF: {
Args items = frame->pop_n_reversed(byte.arg); Args items = frame->pop_n_reversed(byte.arg);
@ -79,13 +79,13 @@ PyVar VM::run_frame(Frame* frame){
case OP_BUILD_STRING: { case OP_BUILD_STRING: {
Args items = frame->pop_n_values_reversed(this, byte.arg); Args items = frame->pop_n_values_reversed(this, byte.arg);
StrStream ss; StrStream ss;
for(int i=0; i<items.size(); i++) ss << py_cast<Str>(this, asStr(items[i])); for(int i=0; i<items.size(); i++) ss << CAST(Str, asStr(items[i]));
frame->push(py_var(this, ss.str())); frame->push(VAR(ss.str()));
} continue; } continue;
case OP_LOAD_EVAL_FN: frame->push(builtins->attr(m_eval)); continue; case OP_LOAD_EVAL_FN: frame->push(builtins->attr(m_eval)); continue;
case OP_LIST_APPEND: { case OP_LIST_APPEND: {
PyVar obj = frame->pop_value(this); PyVar obj = frame->pop_value(this);
List& list = py_cast<List>(this, frame->top_1()); List& list = CAST(List, frame->top_1());
list.push_back(std::move(obj)); list.push_back(std::move(obj));
} continue; } continue;
case OP_BEGIN_CLASS: { case OP_BEGIN_CLASS: {
@ -109,7 +109,7 @@ PyVar VM::run_frame(Frame* frame){
case OP_RETURN_VALUE: return frame->pop_value(this); case OP_RETURN_VALUE: return frame->pop_value(this);
case OP_PRINT_EXPR: { case OP_PRINT_EXPR: {
const PyVar expr = frame->top_value(this); const PyVar expr = frame->top_value(this);
if(expr != None) *_stdout << py_cast<Str>(this, asRepr(expr)) << '\n'; if(expr != None) *_stdout << CAST(Str, asRepr(expr)) << '\n';
} continue; } continue;
case OP_POP_TOP: frame->_pop(); continue; case OP_POP_TOP: frame->_pop(); continue;
case OP_BINARY_OP: { case OP_BINARY_OP: {
@ -150,13 +150,13 @@ PyVar VM::run_frame(Frame* frame){
PyVar rhs = frame->pop_value(this); PyVar rhs = frame->pop_value(this);
bool ret_c = rhs == frame->top_value(this); bool ret_c = rhs == frame->top_value(this);
if(byte.arg == 1) ret_c = !ret_c; if(byte.arg == 1) ret_c = !ret_c;
frame->top() = py_var(this, ret_c); frame->top() = VAR(ret_c);
} continue; } continue;
case OP_CONTAINS_OP: { case OP_CONTAINS_OP: {
PyVar rhs = frame->pop_value(this); PyVar rhs = frame->pop_value(this);
bool ret_c = py_cast_v<bool>(this, call(rhs, __contains__, one_arg(frame->pop_value(this)))); bool ret_c = CAST_V(bool, call(rhs, __contains__, one_arg(frame->pop_value(this))));
if(byte.arg == 1) ret_c = !ret_c; if(byte.arg == 1) ret_c = !ret_c;
frame->push(py_var(this, ret_c)); frame->push(VAR(ret_c));
} continue; } continue;
case OP_UNARY_NEGATIVE: case OP_UNARY_NEGATIVE:
frame->top() = num_negated(frame->top_value(this)); frame->top() = num_negated(frame->top_value(this));
@ -164,10 +164,10 @@ PyVar VM::run_frame(Frame* frame){
case OP_UNARY_NOT: { case OP_UNARY_NOT: {
PyVar obj = frame->pop_value(this); PyVar obj = frame->pop_value(this);
const PyVar& obj_bool = asBool(obj); const PyVar& obj_bool = asBool(obj);
frame->push(py_var(this, !_py_cast_v<bool>(this, obj_bool))); frame->push(VAR(!_CAST_V(bool, obj_bool)));
} continue; } continue;
case OP_POP_JUMP_IF_FALSE: case OP_POP_JUMP_IF_FALSE:
if(!_py_cast_v<bool>(this, asBool(frame->pop_value(this)))) frame->jump_abs(byte.arg); if(!_CAST_V(bool, asBool(frame->pop_value(this)))) frame->jump_abs(byte.arg);
continue; continue;
case OP_LOAD_NONE: frame->push(None); continue; case OP_LOAD_NONE: frame->push(None); continue;
case OP_LOAD_TRUE: frame->push(True); continue; case OP_LOAD_TRUE: frame->push(True); continue;
@ -175,24 +175,24 @@ PyVar VM::run_frame(Frame* frame){
case OP_LOAD_ELLIPSIS: frame->push(Ellipsis); continue; case OP_LOAD_ELLIPSIS: frame->push(Ellipsis); continue;
case OP_ASSERT: { case OP_ASSERT: {
PyVar _msg = frame->pop_value(this); PyVar _msg = frame->pop_value(this);
Str msg = py_cast<Str>(this, asStr(_msg)); Str msg = CAST(Str, asStr(_msg));
PyVar expr = frame->pop_value(this); PyVar expr = frame->pop_value(this);
if(asBool(expr) != True) _error("AssertionError", msg); if(asBool(expr) != True) _error("AssertionError", msg);
} continue; } continue;
case OP_EXCEPTION_MATCH: { case OP_EXCEPTION_MATCH: {
const auto& e = py_cast<Exception>(this, frame->top()); const auto& e = CAST(Exception, frame->top());
StrName name = frame->co->names[byte.arg].first; StrName name = frame->co->names[byte.arg].first;
frame->push(py_var(this, e.match_type(name))); frame->push(VAR(e.match_type(name)));
} continue; } continue;
case OP_RAISE: { case OP_RAISE: {
PyVar obj = frame->pop_value(this); PyVar obj = frame->pop_value(this);
Str msg = obj == None ? "" : py_cast<Str>(this, asStr(obj)); Str msg = obj == None ? "" : CAST(Str, asStr(obj));
StrName type = frame->co->names[byte.arg].first; StrName type = frame->co->names[byte.arg].first;
_error(type, msg); _error(type, msg);
} continue; } continue;
case OP_RE_RAISE: _raise(); continue; case OP_RE_RAISE: _raise(); continue;
case OP_BUILD_LIST: case OP_BUILD_LIST:
frame->push(py_var(this, frame->pop_n_values_reversed(this, byte.arg).move_to_list())); frame->push(VAR(frame->pop_n_values_reversed(this, byte.arg).move_to_list()));
continue; continue;
case OP_BUILD_MAP: { case OP_BUILD_MAP: {
Args items = frame->pop_n_values_reversed(this, byte.arg*2); Args items = frame->pop_n_values_reversed(this, byte.arg*2);
@ -203,7 +203,7 @@ PyVar VM::run_frame(Frame* frame){
frame->push(obj); frame->push(obj);
} continue; } continue;
case OP_BUILD_SET: { case OP_BUILD_SET: {
PyVar list = py_var(this, PyVar list = VAR(
frame->pop_n_values_reversed(this, byte.arg).move_to_list() frame->pop_n_values_reversed(this, byte.arg).move_to_list()
); );
PyVar obj = call(builtins->attr("set"), one_arg(list)); PyVar obj = call(builtins->attr("set"), one_arg(list));
@ -212,10 +212,10 @@ PyVar VM::run_frame(Frame* frame){
case OP_DUP_TOP_VALUE: frame->push(frame->top_value(this)); continue; case OP_DUP_TOP_VALUE: frame->push(frame->top_value(this)); continue;
case OP_UNARY_STAR: { case OP_UNARY_STAR: {
if(byte.arg > 0){ // rvalue if(byte.arg > 0){ // rvalue
frame->top() = py_var(this, StarWrapper(frame->top_value(this), true)); frame->top() = VAR(StarWrapper(frame->top_value(this), true));
}else{ }else{
PyRef_AS_C(frame->top()); // check ref PyRef_AS_C(frame->top()); // check ref
frame->top() = py_var(this, StarWrapper(frame->top(), false)); frame->top() = VAR(StarWrapper(frame->top(), false));
} }
} continue; } continue;
case OP_CALL_KWARGS_UNPACK: case OP_CALL_KWARGS: { case OP_CALL_KWARGS_UNPACK: case OP_CALL_KWARGS: {
@ -284,9 +284,9 @@ PyVar VM::run_frame(Frame* frame){
PyVar stop = frame->pop_value(this); PyVar stop = frame->pop_value(this);
PyVar start = frame->pop_value(this); PyVar start = frame->pop_value(this);
Slice s; Slice s;
if(start != None) { s.start = (int)py_cast_v<i64>(this, start);} if(start != None) { s.start = (int)CAST_V(i64, start);}
if(stop != None) { s.stop = (int)py_cast_v<i64>(this, stop);} if(stop != None) { s.stop = (int)CAST_V(i64, stop);}
frame->push(py_var(this, s)); frame->push(VAR(s));
} continue; } continue;
case OP_IMPORT_NAME: { case OP_IMPORT_NAME: {
StrName name = frame->co->names[byte.arg].first; StrName name = frame->co->names[byte.arg].first;

44
src/cffi.h
View File

@ -78,12 +78,12 @@ struct Pointer{
vm->bind_method<1>(type, "__add__", [](VM* vm, Args& args) { vm->bind_method<1>(type, "__add__", [](VM* vm, Args& args) {
Pointer& self = vm->_cast<Pointer>(args[0]); Pointer& self = vm->_cast<Pointer>(args[0]);
return vm->new_object<Pointer>(self + py_cast<i64>(vm, args[1])); return vm->new_object<Pointer>(self + CAST(i64, args[1]));
}); });
vm->bind_method<1>(type, "__sub__", [](VM* vm, Args& args) { vm->bind_method<1>(type, "__sub__", [](VM* vm, Args& args) {
Pointer& self = vm->_cast<Pointer>(args[0]); Pointer& self = vm->_cast<Pointer>(args[0]);
return vm->new_object<Pointer>(self - py_cast_v<i64>(vm, args[1])); return vm->new_object<Pointer>(self - CAST_V(i64, args[1]));
}); });
vm->bind_method<1>(type, "__eq__", [](VM* vm, Args& args) { vm->bind_method<1>(type, "__eq__", [](VM* vm, Args& args) {
@ -101,13 +101,13 @@ struct Pointer{
// https://docs.python.org/zh-cn/3/library/ctypes.html // https://docs.python.org/zh-cn/3/library/ctypes.html
vm->bind_method<1>(type, "__getitem__", [](VM* vm, Args& args) { vm->bind_method<1>(type, "__getitem__", [](VM* vm, Args& args) {
Pointer& self = vm->_cast<Pointer>(args[0]); Pointer& self = vm->_cast<Pointer>(args[0]);
i64 index = py_cast_v<i64>(vm, args[1]); i64 index = CAST_V(i64, args[1]);
return (self+index).get(vm); return (self+index).get(vm);
}); });
vm->bind_method<2>(type, "__setitem__", [](VM* vm, Args& args) { vm->bind_method<2>(type, "__setitem__", [](VM* vm, Args& args) {
Pointer& self = vm->_cast<Pointer>(args[0]); Pointer& self = vm->_cast<Pointer>(args[0]);
i64 index = py_cast_v<i64>(vm, args[1]); i64 index = CAST_V(i64, args[1]);
(self+index).set(vm, args[2]); (self+index).set(vm, args[2]);
return vm->None; return vm->None;
}); });
@ -164,20 +164,20 @@ struct Pointer{
void set(VM* vm, const PyVar& val){ void set(VM* vm, const PyVar& val){
switch(ctype.index){ switch(ctype.index){
case C_TYPE("char_"): ref<char>() = py_cast_v<i64>(vm, val); break; case C_TYPE("char_"): ref<char>() = CAST_V(i64, val); break;
case C_TYPE("int_"): ref<int>() = py_cast_v<i64>(vm, val); break; case C_TYPE("int_"): ref<int>() = CAST_V(i64, val); break;
case C_TYPE("float_"): ref<float>() = py_cast_v<f64>(vm, val); break; case C_TYPE("float_"): ref<float>() = CAST_V(f64, val); break;
case C_TYPE("double_"): ref<double>() = py_cast_v<f64>(vm, val); break; case C_TYPE("double_"): ref<double>() = CAST_V(f64, val); break;
case C_TYPE("bool_"): ref<bool>() = py_cast_v<bool>(vm, val); break; case C_TYPE("bool_"): ref<bool>() = CAST_V(bool, val); break;
case C_TYPE("void_"): vm->ValueError("cannot set void*"); break; case C_TYPE("void_"): vm->ValueError("cannot set void*"); break;
case C_TYPE("int8_"): ref<int8_t>() = py_cast_v<i64>(vm, val); break; case C_TYPE("int8_"): ref<int8_t>() = CAST_V(i64, val); break;
case C_TYPE("int16_"): ref<int16_t>() = py_cast_v<i64>(vm, val); break; case C_TYPE("int16_"): ref<int16_t>() = CAST_V(i64, val); break;
case C_TYPE("int32_"): ref<int32_t>() = py_cast_v<i64>(vm, val); break; case C_TYPE("int32_"): ref<int32_t>() = CAST_V(i64, val); break;
case C_TYPE("int64_"): ref<int64_t>() = py_cast_v<i64>(vm, val); break; case C_TYPE("int64_"): ref<int64_t>() = CAST_V(i64, val); break;
case C_TYPE("uint8_"): ref<uint8_t>() = py_cast_v<i64>(vm, val); break; case C_TYPE("uint8_"): ref<uint8_t>() = CAST_V(i64, val); break;
case C_TYPE("uint16_"): ref<uint16_t>() = py_cast_v<i64>(vm, val); break; case C_TYPE("uint16_"): ref<uint16_t>() = CAST_V(i64, val); break;
case C_TYPE("uint32_"): ref<uint32_t>() = py_cast_v<i64>(vm, val); break; case C_TYPE("uint32_"): ref<uint32_t>() = CAST_V(i64, val); break;
case C_TYPE("uint64_"): ref<uint64_t>() = py_cast_v<i64>(vm, 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*>() = vm->_cast<Pointer>(val).ptr; break;
// use macro here to do extension // use macro here to do extension
default: UNREACHABLE(); default: UNREACHABLE();
@ -262,7 +262,7 @@ void add_module_c(VM* vm){
vm->setattr(mod, "nullptr", vm->new_object<Pointer>(nullptr, C_TYPE_T("void_"))); vm->setattr(mod, "nullptr", vm->new_object<Pointer>(nullptr, C_TYPE_T("void_")));
vm->bind_func<1>(mod, "malloc", [](VM* vm, Args& args) { vm->bind_func<1>(mod, "malloc", [](VM* vm, Args& args) {
i64 size = py_cast_v<i64>(vm, args[0]); i64 size = CAST_V(i64, args[0]);
return vm->new_object<Pointer>(malloc(size), C_TYPE_T("void_")); return vm->new_object<Pointer>(malloc(size), C_TYPE_T("void_"));
}); });
@ -280,22 +280,22 @@ void add_module_c(VM* vm){
vm->bind_func<3>(mod, "memcpy", [](VM* vm, Args& args) { vm->bind_func<3>(mod, "memcpy", [](VM* vm, Args& args) {
Pointer& dst = vm->_cast<Pointer>(args[0]); Pointer& dst = vm->_cast<Pointer>(args[0]);
Pointer& src = vm->_cast<Pointer>(args[1]); Pointer& src = vm->_cast<Pointer>(args[1]);
i64 size = py_cast_v<i64>(vm, args[2]); i64 size = CAST_V(i64, args[2]);
memcpy(dst.ptr, src.ptr, size); memcpy(dst.ptr, src.ptr, size);
return vm->None; return vm->None;
}); });
vm->bind_func<3>(mod, "memset", [](VM* vm, Args& args) { vm->bind_func<3>(mod, "memset", [](VM* vm, Args& args) {
Pointer& dst = vm->_cast<Pointer>(args[0]); Pointer& dst = vm->_cast<Pointer>(args[0]);
i64 val = py_cast_v<i64>(vm, args[1]); i64 val = CAST_V(i64, args[1]);
i64 size = py_cast_v<i64>(vm, args[2]); i64 size = CAST_V(i64, args[2]);
memset(dst.ptr, (int)val, size); memset(dst.ptr, (int)val, size);
return vm->None; return vm->None;
}); });
vm->bind_func<1>(mod, "strdup", [ptr_t](VM* vm, Args& args) { vm->bind_func<1>(mod, "strdup", [ptr_t](VM* vm, Args& args) {
if(is_type(args[0], vm->tp_str)){ if(is_type(args[0], vm->tp_str)){
const Str& s = py_cast<Str>(vm, args[0]); const Str& s = CAST(Str, args[0]);
return vm->new_object<Pointer>(strdup(s.c_str()), C_TYPE_T("char_")); return vm->new_object<Pointer>(strdup(s.c_str()), C_TYPE_T("char_"));
}else if(is_type(args[0], OBJ_GET(Type, ptr_t))){ }else if(is_type(args[0], OBJ_GET(Type, ptr_t))){
Pointer& p = vm->_cast<Pointer>(args[0]); Pointer& p = vm->_cast<Pointer>(args[0]);

2
src/compiler.h
View File

@ -360,7 +360,7 @@ private:
void exprFString() { void exprFString() {
static const std::regex pattern(R"(\{(.*?)\})"); static const std::regex pattern(R"(\{(.*?)\})");
PyVar value = parser->prev.value; PyVar value = parser->prev.value;
Str s = py_cast<Str>(vm, value); Str s = CAST(Str, value);
std::sregex_iterator begin(s.begin(), s.end(), pattern); std::sregex_iterator begin(s.begin(), s.end(), pattern);
std::sregex_iterator end; std::sregex_iterator end;
int size = 0; int size = 0;

223
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) \ #define BIND_NUM_ARITH_OPT(name, op) \
_vm->_bind_methods<1>({"int","float"}, #name, [](VM* vm, Args& args){ \ _vm->_bind_methods<1>({"int","float"}, #name, [](VM* vm, Args& args){ \
if(is_both_int(args[0], args[1])){ \ if(is_both_int(args[0], args[1])){ \
return VAR(_py_cast_v<i64>(vm, args[0]) op _py_cast_v<i64>(vm, args[1])); \ return VAR(_CAST_V(i64, args[0]) op _CAST_V(i64, args[1])); \
}else{ \ }else{ \
return VAR(vm->num_to_float(args[0]) op vm->num_to_float(args[1])); \ return VAR(vm->num_to_float(args[0]) op vm->num_to_float(args[1])); \
} \ } \
@ -35,7 +35,7 @@ CodeObject_ VM::compile(Str source, Str filename, CompileMode mode) {
vm->TypeError("unsupported operand type(s) for " #op ); \ vm->TypeError("unsupported operand type(s) for " #op ); \
} \ } \
if(is_both_int(args[0], args[1])) \ if(is_both_int(args[0], args[1])) \
return VAR(_py_cast_v<i64>(vm, args[0]) op _py_cast_v<i64>(vm, args[1])); \ return VAR(_CAST_V(i64, args[0]) op _CAST_V(i64, args[1])); \
return VAR(vm->num_to_float(args[0]) op vm->num_to_float(args[1])); \ return VAR(vm->num_to_float(args[0]) op vm->num_to_float(args[1])); \
}); });
@ -56,15 +56,10 @@ void init_builtins(VM* _vm) {
#undef BIND_NUM_LOGICAL_OPT #undef BIND_NUM_LOGICAL_OPT
_vm->bind_builtin_func<1>("__sys_stdout_write", [](VM* vm, Args& args) { _vm->bind_builtin_func<1>("__sys_stdout_write", [](VM* vm, Args& args) {
(*vm->_stdout) << py_cast<Str>(vm, args[0]); (*vm->_stdout) << CAST(Str, args[0]);
return vm->None; return vm->None;
}); });
// _vm->bind_builtin_func<1>("test", [](VM* vm, Args& args) {
// args[0]->attr().print_stats();
// return vm->None;
// });
_vm->bind_builtin_func<0>("super", [](VM* vm, Args& args) { _vm->bind_builtin_func<0>("super", [](VM* vm, Args& args) {
const PyVar* self = vm->top_frame()->f_locals().try_get(m_self); const PyVar* self = vm->top_frame()->f_locals().try_get(m_self);
if(self == nullptr) vm->TypeError("super() can only be called in a class"); if(self == nullptr) vm->TypeError("super() can only be called in a class");
@ -78,19 +73,19 @@ void init_builtins(VM* _vm) {
}); });
_vm->bind_builtin_func<1>("eval", [](VM* vm, Args& args) { _vm->bind_builtin_func<1>("eval", [](VM* vm, Args& args) {
CodeObject_ code = vm->compile(py_cast<Str>(vm, args[0]), "<eval>", EVAL_MODE); CodeObject_ code = vm->compile(CAST(Str, 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->bind_builtin_func<1>("exec", [](VM* vm, Args& args) { _vm->bind_builtin_func<1>("exec", [](VM* vm, Args& args) {
CodeObject_ code = vm->compile(py_cast<Str>(vm, args[0]), "<exec>", EXEC_MODE); CodeObject_ code = vm->compile(CAST(Str, 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;
}); });
_vm->bind_builtin_func<-1>("exit", [](VM* vm, Args& args) { _vm->bind_builtin_func<-1>("exit", [](VM* vm, Args& args) {
if(args.size() == 0) std::exit(0); if(args.size() == 0) std::exit(0);
else if(args.size() == 1) std::exit((int)py_cast_v<i64>(vm, args[0])); else if(args.size() == 1) std::exit((int)CAST_V(i64, args[0]));
else vm->TypeError("exit() takes at most 1 argument"); else vm->TypeError("exit() takes at most 1 argument");
return vm->None; return vm->None;
}); });
@ -105,34 +100,34 @@ void init_builtins(VM* _vm) {
}); });
_vm->bind_builtin_func<1>("chr", [](VM* vm, Args& args) { _vm->bind_builtin_func<1>("chr", [](VM* vm, Args& args) {
i64 i = py_cast_v<i64>(vm, args[0]); i64 i = CAST_V(i64, 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 VAR(std::string(1, (char)i)); return VAR(std::string(1, (char)i));
}); });
_vm->bind_builtin_func<1>("ord", [](VM* vm, Args& args) { _vm->bind_builtin_func<1>("ord", [](VM* vm, Args& args) {
Str s = py_cast<Str>(vm, args[0]); Str s = CAST(Str, 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 VAR((i64)(s.c_str()[0])); return VAR((i64)(s.c_str()[0]));
}); });
_vm->bind_builtin_func<2>("hasattr", [](VM* vm, Args& args) { _vm->bind_builtin_func<2>("hasattr", [](VM* vm, Args& args) {
return VAR(vm->getattr(args[0], py_cast<Str>(vm, args[1]), false) != nullptr); return VAR(vm->getattr(args[0], CAST(Str, args[1]), false) != nullptr);
}); });
_vm->bind_builtin_func<3>("setattr", [](VM* vm, Args& args) { _vm->bind_builtin_func<3>("setattr", [](VM* vm, Args& args) {
vm->setattr(args[0], py_cast<Str>(vm, args[1]), args[2]); vm->setattr(args[0], CAST(Str, args[1]), args[2]);
return vm->None; return vm->None;
}); });
_vm->bind_builtin_func<2>("getattr", [](VM* vm, Args& args) { _vm->bind_builtin_func<2>("getattr", [](VM* vm, Args& args) {
Str name = py_cast<Str>(vm, args[1]); Str name = CAST(Str, args[1]);
return vm->getattr(args[0], name); return vm->getattr(args[0], name);
}); });
_vm->bind_builtin_func<1>("hex", [](VM* vm, Args& args) { _vm->bind_builtin_func<1>("hex", [](VM* vm, Args& args) {
std::stringstream ss; std::stringstream ss;
ss << std::hex << py_cast_v<i64>(vm, args[0]); ss << std::hex << CAST_V(i64, args[0]);
return VAR("0x" + ss.str()); return VAR("0x" + ss.str());
}); });
@ -167,9 +162,9 @@ void init_builtins(VM* _vm) {
_vm->bind_static_method<-1>("range", "__new__", [](VM* vm, Args& args) { _vm->bind_static_method<-1>("range", "__new__", [](VM* vm, Args& args) {
Range r; Range r;
switch (args.size()) { switch (args.size()) {
case 1: r.stop = py_cast_v<i64>(vm, args[0]); break; case 1: r.stop = CAST_V(i64, args[0]); break;
case 2: r.start = py_cast_v<i64>(vm, args[0]); r.stop = py_cast_v<i64>(vm, args[1]); break; case 2: r.start = CAST_V(i64, args[0]); r.stop = CAST_V(i64, args[1]); break;
case 3: r.start = py_cast_v<i64>(vm, args[0]); r.stop = py_cast_v<i64>(vm, args[1]); r.step = py_cast_v<i64>(vm, args[2]); break; case 3: r.start = CAST_V(i64, args[0]); r.stop = CAST_V(i64, args[1]); r.step = CAST_V(i64, args[2]); break;
default: vm->TypeError("expected 1-3 arguments, but got " + std::to_string(args.size())); default: vm->TypeError("expected 1-3 arguments, but got " + std::to_string(args.size()));
} }
return VAR(r); return VAR(r);
@ -190,8 +185,8 @@ void init_builtins(VM* _vm) {
_vm->_bind_methods<1>({"int", "float"}, "__pow__", [](VM* vm, Args& args) { _vm->_bind_methods<1>({"int", "float"}, "__pow__", [](VM* vm, Args& args) {
if(is_both_int(args[0], args[1])){ if(is_both_int(args[0], args[1])){
i64 lhs = _py_cast_v<i64>(vm, args[0]); i64 lhs = _CAST_V(i64, args[0]);
i64 rhs = _py_cast_v<i64>(vm, args[1]); i64 rhs = _CAST_V(i64, args[1]);
bool flag = false; bool flag = false;
if(rhs < 0) {flag = true; rhs = -rhs;} if(rhs < 0) {flag = true; rhs = -rhs;}
i64 ret = 1; i64 ret = 1;
@ -210,10 +205,10 @@ void init_builtins(VM* _vm) {
/************ PyInt ************/ /************ PyInt ************/
_vm->bind_static_method<1>("int", "__new__", [](VM* vm, Args& args) { _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_int)) return args[0];
if (is_type(args[0], vm->tp_float)) return VAR((i64)py_cast_v<f64>(vm, args[0])); if (is_type(args[0], vm->tp_float)) return VAR((i64)CAST_V(f64, args[0]));
if (is_type(args[0], vm->tp_bool)) return VAR(_py_cast_v<bool>(vm, args[0]) ? 1 : 0); if (is_type(args[0], vm->tp_bool)) return VAR(_CAST_V(bool, args[0]) ? 1 : 0);
if (is_type(args[0], vm->tp_str)) { if (is_type(args[0], vm->tp_str)) {
const Str& s = py_cast<Str>(vm, args[0]); const Str& s = CAST(Str, args[0]);
try{ try{
size_t parsed = 0; size_t parsed = 0;
i64 val = S_TO_INT(s, &parsed, 10); i64 val = S_TO_INT(s, &parsed, 10);
@ -228,22 +223,22 @@ void init_builtins(VM* _vm) {
}); });
_vm->bind_method<1>("int", "__floordiv__", [](VM* vm, Args& args) { _vm->bind_method<1>("int", "__floordiv__", [](VM* vm, Args& args) {
i64 rhs = py_cast_v<i64>(vm, args[1]); i64 rhs = CAST_V(i64, args[1]);
if(rhs == 0) vm->ZeroDivisionError(); if(rhs == 0) vm->ZeroDivisionError();
return VAR(py_cast_v<i64>(vm, args[0]) / rhs); return VAR(CAST_V(i64, args[0]) / rhs);
}); });
_vm->bind_method<1>("int", "__mod__", [](VM* vm, Args& args) { _vm->bind_method<1>("int", "__mod__", [](VM* vm, Args& args) {
i64 rhs = py_cast_v<i64>(vm, args[1]); i64 rhs = CAST_V(i64, args[1]);
if(rhs == 0) vm->ZeroDivisionError(); if(rhs == 0) vm->ZeroDivisionError();
return VAR(py_cast_v<i64>(vm, args[0]) % rhs); return VAR(CAST_V(i64, args[0]) % rhs);
}); });
_vm->bind_method<0>("int", "__repr__", CPP_LAMBDA(VAR(std::to_string(py_cast_v<i64>(vm, args[0]))))); _vm->bind_method<0>("int", "__repr__", CPP_LAMBDA(VAR(std::to_string(CAST_V(i64, args[0])))));
_vm->bind_method<0>("int", "__json__", CPP_LAMBDA(VAR(std::to_string(py_cast_v<i64>(vm, args[0]))))); _vm->bind_method<0>("int", "__json__", CPP_LAMBDA(VAR(std::to_string(CAST_V(i64, args[0])))));
#define INT_BITWISE_OP(name,op) \ #define INT_BITWISE_OP(name,op) \
_vm->bind_method<1>("int", #name, CPP_LAMBDA(VAR(py_cast_v<i64>(vm, args[0]) op py_cast_v<i64>(vm, args[1])))); _vm->bind_method<1>("int", #name, CPP_LAMBDA(VAR(CAST_V(i64, args[0]) op CAST_V(i64, args[1]))));
INT_BITWISE_OP(__lshift__, <<) INT_BITWISE_OP(__lshift__, <<)
INT_BITWISE_OP(__rshift__, >>) INT_BITWISE_OP(__rshift__, >>)
@ -255,11 +250,11 @@ void init_builtins(VM* _vm) {
/************ PyFloat ************/ /************ PyFloat ************/
_vm->bind_static_method<1>("float", "__new__", [](VM* vm, Args& args) { _vm->bind_static_method<1>("float", "__new__", [](VM* vm, Args& args) {
if (is_type(args[0], vm->tp_int)) return VAR((f64)py_cast_v<i64>(vm, args[0])); if (is_type(args[0], vm->tp_int)) return VAR((f64)CAST_V(i64, args[0]));
if (is_type(args[0], vm->tp_float)) return args[0]; if (is_type(args[0], vm->tp_float)) return args[0];
if (is_type(args[0], vm->tp_bool)) return VAR(_py_cast_v<bool>(vm, args[0]) ? 1.0 : 0.0); if (is_type(args[0], vm->tp_bool)) return VAR(_CAST_V(bool, args[0]) ? 1.0 : 0.0);
if (is_type(args[0], vm->tp_str)) { if (is_type(args[0], vm->tp_str)) {
const Str& s = py_cast<Str>(vm, args[0]); const Str& s = CAST(Str, args[0]);
if(s == "inf") return VAR(INFINITY); if(s == "inf") return VAR(INFINITY);
if(s == "-inf") return VAR(-INFINITY); if(s == "-inf") return VAR(-INFINITY);
try{ try{
@ -274,7 +269,7 @@ void init_builtins(VM* _vm) {
}); });
_vm->bind_method<0>("float", "__repr__", [](VM* vm, Args& args) { _vm->bind_method<0>("float", "__repr__", [](VM* vm, Args& args) {
f64 val = py_cast_v<f64>(vm, args[0]); f64 val = CAST_V(f64, args[0]);
if(std::isinf(val) || std::isnan(val)) return VAR(std::to_string(val)); if(std::isinf(val) || std::isnan(val)) return VAR(std::to_string(val));
StrStream ss; StrStream ss;
ss << std::setprecision(std::numeric_limits<f64>::max_digits10-1-2) << val; ss << std::setprecision(std::numeric_limits<f64>::max_digits10-1-2) << val;
@ -284,7 +279,7 @@ void init_builtins(VM* _vm) {
}); });
_vm->bind_method<0>("float", "__json__", [](VM* vm, Args& args) { _vm->bind_method<0>("float", "__json__", [](VM* vm, Args& args) {
f64 val = py_cast_v<f64>(vm, args[0]); f64 val = CAST_V(f64, 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 VAR(std::to_string(val)); return VAR(std::to_string(val));
}); });
@ -293,19 +288,19 @@ void init_builtins(VM* _vm) {
_vm->bind_static_method<1>("str", "__new__", CPP_LAMBDA(vm->asStr(args[0]))); _vm->bind_static_method<1>("str", "__new__", CPP_LAMBDA(vm->asStr(args[0])));
_vm->bind_method<1>("str", "__add__", [](VM* vm, Args& args) { _vm->bind_method<1>("str", "__add__", [](VM* vm, Args& args) {
const Str& lhs = py_cast<Str>(vm, args[0]); const Str& lhs = CAST(Str, args[0]);
const Str& rhs = py_cast<Str>(vm, args[1]); const Str& rhs = CAST(Str, args[1]);
return VAR(lhs + rhs); return VAR(lhs + rhs);
}); });
_vm->bind_method<0>("str", "__len__", [](VM* vm, Args& args) { _vm->bind_method<0>("str", "__len__", [](VM* vm, Args& args) {
const Str& self = py_cast<Str>(vm, args[0]); const Str& self = CAST(Str, args[0]);
return VAR(self.u8_length()); return VAR(self.u8_length());
}); });
_vm->bind_method<1>("str", "__contains__", [](VM* vm, Args& args) { _vm->bind_method<1>("str", "__contains__", [](VM* vm, Args& args) {
const Str& self = py_cast<Str>(vm, args[0]); const Str& self = CAST(Str, args[0]);
const Str& other = py_cast<Str>(vm, args[1]); const Str& other = CAST(Str, args[1]);
return VAR(self.find(other) != Str::npos); return VAR(self.find(other) != Str::npos);
}); });
@ -313,57 +308,57 @@ void init_builtins(VM* _vm) {
_vm->bind_method<0>("str", "__iter__", CPP_LAMBDA(vm->PyIter(StringIter(vm, args[0])))); _vm->bind_method<0>("str", "__iter__", CPP_LAMBDA(vm->PyIter(StringIter(vm, args[0]))));
_vm->bind_method<0>("str", "__repr__", [](VM* vm, Args& args) { _vm->bind_method<0>("str", "__repr__", [](VM* vm, Args& args) {
const Str& _self = py_cast<Str>(vm, args[0]); const Str& _self = CAST(Str, args[0]);
return VAR(_self.escape(true)); return VAR(_self.escape(true));
}); });
_vm->bind_method<0>("str", "__json__", [](VM* vm, Args& args) { _vm->bind_method<0>("str", "__json__", [](VM* vm, Args& args) {
const Str& _self = py_cast<Str>(vm, args[0]); const Str& _self = CAST(Str, args[0]);
return VAR(_self.escape(false)); return VAR(_self.escape(false));
}); });
_vm->bind_method<1>("str", "__eq__", [](VM* vm, Args& args) { _vm->bind_method<1>("str", "__eq__", [](VM* vm, Args& args) {
if(is_type(args[0], vm->tp_str) && is_type(args[1], vm->tp_str)) if(is_type(args[0], vm->tp_str) && is_type(args[1], vm->tp_str))
return VAR(py_cast<Str>(vm, args[0]) == py_cast<Str>(vm, args[1])); return VAR(CAST(Str, args[0]) == CAST(Str, args[1]));
return VAR(args[0] == args[1]); return VAR(args[0] == args[1]);
}); });
_vm->bind_method<1>("str", "__ne__", [](VM* vm, Args& args) { _vm->bind_method<1>("str", "__ne__", [](VM* vm, Args& args) {
if(is_type(args[0], vm->tp_str) && is_type(args[1], vm->tp_str)) if(is_type(args[0], vm->tp_str) && is_type(args[1], vm->tp_str))
return VAR(py_cast<Str>(vm, args[0]) != py_cast<Str>(vm, args[1])); return VAR(CAST(Str, args[0]) != CAST(Str, args[1]));
return VAR(args[0] != args[1]); return VAR(args[0] != args[1]);
}); });
_vm->bind_method<1>("str", "__getitem__", [](VM* vm, Args& args) { _vm->bind_method<1>("str", "__getitem__", [](VM* vm, Args& args) {
const Str& self (py_cast<Str>(vm, args[0])); const Str& self (CAST(Str, args[0]));
if(is_type(args[1], vm->tp_slice)){ if(is_type(args[1], vm->tp_slice)){
Slice s = _py_cast_v<Slice>(vm, args[1]); Slice s = _CAST_V(Slice, args[1]);
s.normalize(self.u8_length()); s.normalize(self.u8_length());
return VAR(self.u8_substr(s.start, s.stop)); return VAR(self.u8_substr(s.start, s.stop));
} }
int index = (int)py_cast_v<i64>(vm, args[1]); int index = (int)CAST_V(i64, args[1]);
index = vm->normalized_index(index, self.u8_length()); index = vm->normalized_index(index, self.u8_length());
return VAR(self.u8_getitem(index)); return VAR(self.u8_getitem(index));
}); });
_vm->bind_method<1>("str", "__gt__", [](VM* vm, Args& args) { _vm->bind_method<1>("str", "__gt__", [](VM* vm, Args& args) {
const Str& self (py_cast<Str>(vm, args[0])); const Str& self (CAST(Str, args[0]));
const Str& obj (py_cast<Str>(vm, args[1])); const Str& obj (CAST(Str, args[1]));
return VAR(self > obj); return VAR(self > obj);
}); });
_vm->bind_method<1>("str", "__lt__", [](VM* vm, Args& args) { _vm->bind_method<1>("str", "__lt__", [](VM* vm, Args& args) {
const Str& self (py_cast<Str>(vm, args[0])); const Str& self (CAST(Str, args[0]));
const Str& obj (py_cast<Str>(vm, args[1])); const Str& obj (CAST(Str, args[1]));
return VAR(self < obj); return VAR(self < obj);
}); });
_vm->bind_method<2>("str", "replace", [](VM* vm, Args& args) { _vm->bind_method<2>("str", "replace", [](VM* vm, Args& args) {
const Str& _self = py_cast<Str>(vm, args[0]); const Str& _self = CAST(Str, args[0]);
const Str& _old = py_cast<Str>(vm, args[1]); const Str& _old = CAST(Str, args[1]);
const Str& _new = py_cast<Str>(vm, args[2]); const Str& _new = CAST(Str, args[2]);
Str _copy = _self; Str _copy = _self;
// replace all occurences of _old with _new in _copy // replace all occurences of _old with _new in _copy
size_t pos = 0; size_t pos = 0;
@ -375,45 +370,45 @@ void init_builtins(VM* _vm) {
}); });
_vm->bind_method<1>("str", "startswith", [](VM* vm, Args& args) { _vm->bind_method<1>("str", "startswith", [](VM* vm, Args& args) {
const Str& _self = py_cast<Str>(vm, args[0]); const Str& _self = CAST(Str, args[0]);
const Str& _prefix = py_cast<Str>(vm, args[1]); const Str& _prefix = CAST(Str, args[1]);
return VAR(_self.find(_prefix) == 0); return VAR(_self.find(_prefix) == 0);
}); });
_vm->bind_method<1>("str", "endswith", [](VM* vm, Args& args) { _vm->bind_method<1>("str", "endswith", [](VM* vm, Args& args) {
const Str& _self = py_cast<Str>(vm, args[0]); const Str& _self = CAST(Str, args[0]);
const Str& _suffix = py_cast<Str>(vm, args[1]); const Str& _suffix = CAST(Str, args[1]);
return VAR(_self.rfind(_suffix) == _self.length() - _suffix.length()); return VAR(_self.rfind(_suffix) == _self.length() - _suffix.length());
}); });
_vm->bind_method<1>("str", "join", [](VM* vm, Args& args) { _vm->bind_method<1>("str", "join", [](VM* vm, Args& args) {
const Str& self = py_cast<Str>(vm, args[0]); const Str& self = CAST(Str, args[0]);
StrStream ss; StrStream ss;
PyVar obj = vm->asList(args[1]); PyVar obj = vm->asList(args[1]);
const List& list = py_cast<List>(vm, obj); const List& list = CAST(List, obj);
for (int i = 0; i < list.size(); ++i) { for (int i = 0; i < list.size(); ++i) {
if (i > 0) ss << self; if (i > 0) ss << self;
ss << py_cast<Str>(vm, list[i]); ss << CAST(Str, list[i]);
} }
return VAR(ss.str()); return VAR(ss.str());
}); });
/************ PyList ************/ /************ PyList ************/
_vm->bind_method<1>("list", "append", [](VM* vm, Args& args) { _vm->bind_method<1>("list", "append", [](VM* vm, Args& args) {
List& self = py_cast<List>(vm, args[0]); List& self = CAST(List, args[0]);
self.push_back(args[1]); self.push_back(args[1]);
return vm->None; return vm->None;
}); });
_vm->bind_method<0>("list", "reverse", [](VM* vm, Args& args) { _vm->bind_method<0>("list", "reverse", [](VM* vm, Args& args) {
List& self = py_cast<List>(vm, args[0]); List& self = CAST(List, args[0]);
std::reverse(self.begin(), self.end()); std::reverse(self.begin(), self.end());
return vm->None; return vm->None;
}); });
_vm->bind_method<1>("list", "__mul__", [](VM* vm, Args& args) { _vm->bind_method<1>("list", "__mul__", [](VM* vm, Args& args) {
const List& self = py_cast<List>(vm, args[0]); const List& self = CAST(List, args[0]);
int n = (int)py_cast_v<i64>(vm, args[1]); int n = (int)CAST_V(i64, args[1]);
List result; List result;
result.reserve(self.size() * n); result.reserve(self.size() * n);
for(int i = 0; i < n; i++) result.insert(result.end(), self.begin(), self.end()); for(int i = 0; i < n; i++) result.insert(result.end(), self.begin(), self.end());
@ -421,8 +416,8 @@ void init_builtins(VM* _vm) {
}); });
_vm->bind_method<2>("list", "insert", [](VM* vm, Args& args) { _vm->bind_method<2>("list", "insert", [](VM* vm, Args& args) {
List& self = py_cast<List>(vm, args[0]); List& self = CAST(List, args[0]);
int index = (int)py_cast_v<i64>(vm, args[1]); int index = (int)CAST_V(i64, args[1]);
if(index < 0) index += self.size(); if(index < 0) index += self.size();
if(index < 0) index = 0; if(index < 0) index = 0;
if(index > self.size()) index = self.size(); if(index > self.size()) index = self.size();
@ -431,22 +426,22 @@ void init_builtins(VM* _vm) {
}); });
_vm->bind_method<0>("list", "clear", [](VM* vm, Args& args) { _vm->bind_method<0>("list", "clear", [](VM* vm, Args& args) {
py_cast<List>(vm, args[0]).clear(); CAST(List, args[0]).clear();
return vm->None; return vm->None;
}); });
_vm->bind_method<0>("list", "copy", CPP_LAMBDA(VAR(py_cast<List>(vm, args[0])))); _vm->bind_method<0>("list", "copy", CPP_LAMBDA(VAR(CAST(List, args[0]))));
_vm->bind_method<1>("list", "__add__", [](VM* vm, Args& args) { _vm->bind_method<1>("list", "__add__", [](VM* vm, Args& args) {
const List& self = py_cast<List>(vm, args[0]); const List& self = CAST(List, args[0]);
const List& obj = py_cast<List>(vm, args[1]); const List& obj = CAST(List, args[1]);
List new_list = self; List new_list = self;
new_list.insert(new_list.end(), obj.begin(), obj.end()); new_list.insert(new_list.end(), obj.begin(), obj.end());
return VAR(new_list); return VAR(new_list);
}); });
_vm->bind_method<0>("list", "__len__", [](VM* vm, Args& args) { _vm->bind_method<0>("list", "__len__", [](VM* vm, Args& args) {
const List& self = py_cast<List>(vm, args[0]); const List& self = CAST(List, args[0]);
return VAR(self.size()); return VAR(self.size());
}); });
@ -455,32 +450,32 @@ void init_builtins(VM* _vm) {
}); });
_vm->bind_method<1>("list", "__getitem__", [](VM* vm, Args& args) { _vm->bind_method<1>("list", "__getitem__", [](VM* vm, Args& args) {
const List& self = py_cast<List>(vm, args[0]); const List& self = CAST(List, args[0]);
if(is_type(args[1], vm->tp_slice)){ if(is_type(args[1], vm->tp_slice)){
Slice s = _py_cast_v<Slice>(vm, args[1]); Slice s = _CAST_V(Slice, args[1]);
s.normalize(self.size()); s.normalize(self.size());
List new_list; List new_list;
for(size_t i = s.start; i < s.stop; i++) new_list.push_back(self[i]); for(size_t i = s.start; i < s.stop; i++) new_list.push_back(self[i]);
return VAR(std::move(new_list)); return VAR(std::move(new_list));
} }
int index = (int)py_cast_v<i64>(vm, args[1]); int index = (int)CAST_V(i64, args[1]);
index = vm->normalized_index(index, self.size()); index = vm->normalized_index(index, self.size());
return self[index]; return self[index];
}); });
_vm->bind_method<2>("list", "__setitem__", [](VM* vm, Args& args) { _vm->bind_method<2>("list", "__setitem__", [](VM* vm, Args& args) {
List& self = py_cast<List>(vm, args[0]); List& self = CAST(List, args[0]);
int index = (int)py_cast_v<i64>(vm, args[1]); int index = (int)CAST_V(i64, args[1]);
index = vm->normalized_index(index, self.size()); index = vm->normalized_index(index, self.size());
self[index] = args[2]; self[index] = args[2];
return vm->None; return vm->None;
}); });
_vm->bind_method<1>("list", "__delitem__", [](VM* vm, Args& args) { _vm->bind_method<1>("list", "__delitem__", [](VM* vm, Args& args) {
List& self = py_cast<List>(vm, args[0]); List& self = CAST(List, args[0]);
int index = (int)py_cast_v<i64>(vm, args[1]); int index = (int)CAST_V(i64, args[1]);
index = vm->normalized_index(index, self.size()); index = vm->normalized_index(index, self.size());
self.erase(self.begin() + index); self.erase(self.begin() + index);
return vm->None; return vm->None;
@ -488,7 +483,7 @@ void init_builtins(VM* _vm) {
/************ PyTuple ************/ /************ PyTuple ************/
_vm->bind_static_method<1>("tuple", "__new__", [](VM* vm, Args& args) { _vm->bind_static_method<1>("tuple", "__new__", [](VM* vm, Args& args) {
List list = py_cast<List>(vm, vm->asList(args[0])); List list = CAST(List, vm->asList(args[0]));
return VAR(std::move(list)); return VAR(std::move(list));
}); });
@ -497,23 +492,23 @@ void init_builtins(VM* _vm) {
}); });
_vm->bind_method<1>("tuple", "__getitem__", [](VM* vm, Args& args) { _vm->bind_method<1>("tuple", "__getitem__", [](VM* vm, Args& args) {
const Tuple& self = py_cast<Tuple>(vm, args[0]); const Tuple& self = CAST(Tuple, args[0]);
if(is_type(args[1], vm->tp_slice)){ if(is_type(args[1], vm->tp_slice)){
Slice s = _py_cast_v<Slice>(vm, args[1]); Slice s = _CAST_V(Slice, args[1]);
s.normalize(self.size()); s.normalize(self.size());
List new_list; List new_list;
for(size_t i = s.start; i < s.stop; i++) new_list.push_back(self[i]); for(size_t i = s.start; i < s.stop; i++) new_list.push_back(self[i]);
return VAR(std::move(new_list)); return VAR(std::move(new_list));
} }
int index = (int)py_cast_v<i64>(vm, args[1]); int index = (int)CAST_V(i64, args[1]);
index = vm->normalized_index(index, self.size()); index = vm->normalized_index(index, self.size());
return self[index]; return self[index];
}); });
_vm->bind_method<0>("tuple", "__len__", [](VM* vm, Args& args) { _vm->bind_method<0>("tuple", "__len__", [](VM* vm, Args& args) {
const Tuple& self = py_cast<Tuple>(vm, args[0]); const Tuple& self = CAST(Tuple, args[0]);
return VAR(self.size()); return VAR(self.size());
}); });
@ -521,18 +516,18 @@ void init_builtins(VM* _vm) {
_vm->bind_static_method<1>("bool", "__new__", CPP_LAMBDA(vm->asBool(args[0]))); _vm->bind_static_method<1>("bool", "__new__", CPP_LAMBDA(vm->asBool(args[0])));
_vm->bind_method<0>("bool", "__repr__", [](VM* vm, Args& args) { _vm->bind_method<0>("bool", "__repr__", [](VM* vm, Args& args) {
bool val = py_cast_v<bool>(vm, args[0]); bool val = CAST_V(bool, args[0]);
return VAR(val ? "True" : "False"); return VAR(val ? "True" : "False");
}); });
_vm->bind_method<0>("bool", "__json__", [](VM* vm, Args& args) { _vm->bind_method<0>("bool", "__json__", [](VM* vm, Args& args) {
bool val = py_cast_v<bool>(vm, args[0]); bool val = CAST_V(bool, args[0]);
return VAR(val ? "true" : "false"); return VAR(val ? "true" : "false");
}); });
_vm->bind_method<1>("bool", "__xor__", [](VM* vm, Args& args) { _vm->bind_method<1>("bool", "__xor__", [](VM* vm, Args& args) {
bool self = py_cast_v<bool>(vm, args[0]); bool self = CAST_V(bool, args[0]);
bool other = py_cast_v<bool>(vm, args[1]); bool other = CAST_V(bool, args[1]);
return VAR(self ^ other); return VAR(self ^ other);
}); });
@ -569,7 +564,7 @@ void add_module_sys(VM* vm){
vm->bind_func<0>(mod, "getrecursionlimit", CPP_LAMBDA(VAR(vm->recursionlimit))); vm->bind_func<0>(mod, "getrecursionlimit", CPP_LAMBDA(VAR(vm->recursionlimit)));
vm->bind_func<1>(mod, "setrecursionlimit", [](VM* vm, Args& args) { vm->bind_func<1>(mod, "setrecursionlimit", [](VM* vm, Args& args) {
vm->recursionlimit = (int)py_cast_v<i64>(vm, args[0]); vm->recursionlimit = (int)CAST_V(i64, args[0]);
return vm->None; return vm->None;
}); });
} }
@ -577,7 +572,7 @@ 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->bind_func<1>(mod, "loads", [](VM* vm, Args& args) { vm->bind_func<1>(mod, "loads", [](VM* vm, Args& args) {
const Str& expr = py_cast<Str>(vm, args[0]); const Str& expr = CAST(Str, args[0]);
CodeObject_ code = vm->compile(expr, "<json>", JSON_MODE); CodeObject_ 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);
}); });
@ -608,8 +603,8 @@ void add_module_dis(VM* vm){
PyVar mod = vm->new_module("dis"); PyVar mod = vm->new_module("dis");
vm->bind_func<1>(mod, "dis", [](VM* vm, Args& args) { vm->bind_func<1>(mod, "dis", [](VM* vm, Args& args) {
PyVar f = args[0]; PyVar f = args[0];
if(is_type(f, vm->tp_bound_method)) f = py_cast<BoundMethod>(vm, args[0]).method; if(is_type(f, vm->tp_bound_method)) f = CAST(BoundMethod, args[0]).method;
CodeObject_ code = py_cast<Function>(vm, f).code; CodeObject_ code = CAST(Function, f).code;
(*vm->_stdout) << vm->disassemble(code); (*vm->_stdout) << vm->disassemble(code);
return vm->None; return vm->None;
}); });
@ -636,7 +631,7 @@ struct FileIO {
static void _register(VM* vm, PyVar mod, PyVar type){ static void _register(VM* vm, PyVar mod, PyVar type){
vm->bind_static_method<2>(type, "__new__", [](VM* vm, Args& args){ vm->bind_static_method<2>(type, "__new__", [](VM* vm, Args& args){
return vm->new_object<FileIO>( return vm->new_object<FileIO>(
vm, py_cast<Str>(vm, args[0]), py_cast<Str>(vm, args[1]) vm, CAST(Str, args[0]), CAST(Str, args[1])
); );
}); });
@ -649,7 +644,7 @@ struct FileIO {
vm->bind_method<1>(type, "write", [](VM* vm, Args& args){ vm->bind_method<1>(type, "write", [](VM* vm, Args& args){
FileIO& io = vm->_cast<FileIO>(args[0]); FileIO& io = vm->_cast<FileIO>(args[0]);
io._fs << py_cast<Str>(vm, args[1]); io._fs << CAST(Str, args[1]);
return vm->None; return vm->None;
}); });
@ -698,7 +693,7 @@ struct ReMatch {
vm->bind_method<1>(type, "group", [](VM* vm, Args& args) { vm->bind_method<1>(type, "group", [](VM* vm, Args& args) {
auto& self = vm->_cast<ReMatch>(args[0]); auto& self = vm->_cast<ReMatch>(args[0]);
int index = (int)py_cast_v<i64>(vm, args[1]); int index = (int)CAST_V(i64, args[1]);
index = vm->normalized_index(index, self.m.size()); index = vm->normalized_index(index, self.m.size());
return VAR(self.m[index].str()); return VAR(self.m[index].str());
}); });
@ -722,28 +717,28 @@ void add_module_re(VM* vm){
vm->register_class<ReMatch>(mod); vm->register_class<ReMatch>(mod);
vm->bind_func<2>(mod, "match", [](VM* vm, Args& args) { vm->bind_func<2>(mod, "match", [](VM* vm, Args& args) {
const Str& pattern = py_cast<Str>(vm, args[0]); const Str& pattern = CAST(Str, args[0]);
const Str& string = py_cast<Str>(vm, args[1]); const Str& string = CAST(Str, args[1]);
return _regex_search(pattern, string, true, vm); return _regex_search(pattern, string, true, vm);
}); });
vm->bind_func<2>(mod, "search", [](VM* vm, Args& args) { vm->bind_func<2>(mod, "search", [](VM* vm, Args& args) {
const Str& pattern = py_cast<Str>(vm, args[0]); const Str& pattern = CAST(Str, args[0]);
const Str& string = py_cast<Str>(vm, args[1]); const Str& string = CAST(Str, args[1]);
return _regex_search(pattern, string, false, vm); return _regex_search(pattern, string, false, vm);
}); });
vm->bind_func<3>(mod, "sub", [](VM* vm, Args& args) { vm->bind_func<3>(mod, "sub", [](VM* vm, Args& args) {
const Str& pattern = py_cast<Str>(vm, args[0]); const Str& pattern = CAST(Str, args[0]);
const Str& repl = py_cast<Str>(vm, args[1]); const Str& repl = CAST(Str, args[1]);
const Str& string = py_cast<Str>(vm, args[2]); const Str& string = CAST(Str, args[2]);
std::regex re(pattern); std::regex re(pattern);
return VAR(std::regex_replace(string, re, repl)); return VAR(std::regex_replace(string, re, repl));
}); });
vm->bind_func<2>(mod, "split", [](VM* vm, Args& args) { vm->bind_func<2>(mod, "split", [](VM* vm, Args& args) {
const Str& pattern = py_cast<Str>(vm, args[0]); const Str& pattern = CAST(Str, args[0]);
const Str& string = py_cast<Str>(vm, args[1]); const Str& string = CAST(Str, args[1]);
std::regex re(pattern); std::regex re(pattern);
std::sregex_token_iterator it(string.begin(), string.end(), re, -1); std::sregex_token_iterator it(string.begin(), string.end(), re, -1);
std::sregex_token_iterator end; std::sregex_token_iterator end;
@ -759,21 +754,21 @@ void add_module_random(VM* vm){
PyVar mod = vm->new_module("random"); PyVar mod = vm->new_module("random");
std::srand(std::time(0)); std::srand(std::time(0));
vm->bind_func<1>(mod, "seed", [](VM* vm, Args& args) { vm->bind_func<1>(mod, "seed", [](VM* vm, Args& args) {
std::srand((unsigned int)py_cast_v<i64>(vm, args[0])); std::srand((unsigned int)CAST_V(i64, args[0]));
return vm->None; return vm->None;
}); });
vm->bind_func<0>(mod, "random", CPP_LAMBDA(VAR(std::rand() / (f64)RAND_MAX))); vm->bind_func<0>(mod, "random", CPP_LAMBDA(VAR(std::rand() / (f64)RAND_MAX)));
vm->bind_func<2>(mod, "randint", [](VM* vm, Args& args) { vm->bind_func<2>(mod, "randint", [](VM* vm, Args& args) {
i64 a = py_cast_v<i64>(vm, args[0]); i64 a = CAST_V(i64, args[0]);
i64 b = py_cast_v<i64>(vm, args[1]); i64 b = CAST_V(i64, args[1]);
if(a > b) std::swap(a, b); if(a > b) std::swap(a, b);
return VAR(a + std::rand() % (b - a + 1)); return VAR(a + std::rand() % (b - a + 1));
}); });
vm->bind_func<2>(mod, "uniform", [](VM* vm, Args& args) { vm->bind_func<2>(mod, "uniform", [](VM* vm, Args& args) {
f64 a = py_cast_v<f64>(vm, args[0]); f64 a = CAST_V(f64, args[0]);
f64 b = py_cast_v<f64>(vm, args[1]); f64 b = CAST_V(f64, args[1]);
if(a > b) std::swap(a, b); if(a > b) std::swap(a, b);
return VAR(a + (b - a) * std::rand() / (f64)RAND_MAX); return VAR(a + (b - a) * std::rand() / (f64)RAND_MAX);
}); });
@ -868,7 +863,7 @@ extern "C" {
pkpy::PyVar* val = vm->_main->attr().try_get(name); pkpy::PyVar* val = vm->_main->attr().try_get(name);
if(val == nullptr) return nullptr; if(val == nullptr) return nullptr;
try{ try{
pkpy::Str& _repr = pkpy::py_cast<pkpy::Str>(vm, vm->asRepr(*val)); pkpy::Str& _repr = pkpy::CAST(pkpy::Str, vm->asRepr(*val));
return strdup(_repr.c_str()); return strdup(_repr.c_str());
}catch(...){ }catch(...){
return nullptr; return nullptr;
@ -884,7 +879,7 @@ extern "C" {
pkpy::PyVarOrNull ret = vm->exec(source, "<eval>", pkpy::EVAL_MODE); pkpy::PyVarOrNull ret = vm->exec(source, "<eval>", pkpy::EVAL_MODE);
if(ret == nullptr) return nullptr; if(ret == nullptr) return nullptr;
try{ try{
pkpy::Str& _repr = pkpy::py_cast<pkpy::Str>(vm, vm->asRepr(ret)); pkpy::Str& _repr = pkpy::CAST(pkpy::Str, vm->asRepr(ret));
return strdup(_repr.c_str()); return strdup(_repr.c_str());
}catch(...){ }catch(...){
return nullptr; return nullptr;
@ -971,7 +966,7 @@ extern "C" {
for(int i=0; i<args.size(); i++){ for(int i=0; i<args.size(); i++){
ss << ' '; ss << ' ';
pkpy::PyVar x = vm->call(args[i], pkpy::__json__); pkpy::PyVar x = vm->call(args[i], pkpy::__json__);
ss << pkpy::py_cast<pkpy::Str>(vm, x); ss << pkpy::CAST(pkpy::Str, x);
} }
char* packet = strdup(ss.str().c_str()); char* packet = strdup(ss.str().c_str());
switch(ret_code){ switch(ret_code){

2
src/ref.h
View File

@ -127,7 +127,7 @@ struct TupleRef : BaseRef {
for(int i=0; i<objs.size(); i++){ for(int i=0; i<objs.size(); i++){
PyVarOrNull x; PyVarOrNull x;
if(is_type(objs[i], vm->tp_star_wrapper)){ if(is_type(objs[i], vm->tp_star_wrapper)){
auto& star = _py_cast<StarWrapper>(vm, objs[i]); auto& star = _CAST(StarWrapper, objs[i]);
if(star.rvalue) vm->ValueError("can't use starred expression here"); if(star.rvalue) vm->ValueError("can't use starred expression here");
if(i != objs.size()-1) vm->ValueError("* can only be used at the end"); if(i != objs.size()-1) vm->ValueError("* can only be used at the end");
auto ref = vm->PyRef_AS_C(star.obj); auto ref = vm->PyRef_AS_C(star.obj);

64
src/vm.h
View File

@ -448,9 +448,9 @@ PyVar py_var(VM* vm, const char* val){
PyVar VM::num_negated(const PyVar& obj){ PyVar VM::num_negated(const PyVar& obj){
if (is_int(obj)){ if (is_int(obj)){
return py_var(this, -py_cast_v<i64>(this, obj)); return VAR(-CAST_V(i64, obj));
}else if(is_float(obj)){ }else if(is_float(obj)){
return py_var(this, -py_cast_v<f64>(this, obj)); return VAR(-CAST_V(f64, obj));
} }
TypeError("expected 'int' or 'float', got " + OBJ_NAME(_t(obj)).escape(true)); TypeError("expected 'int' or 'float', got " + OBJ_NAME(_t(obj)).escape(true));
return nullptr; return nullptr;
@ -458,9 +458,9 @@ PyVar VM::num_negated(const PyVar& obj){
f64 VM::num_to_float(const PyVar& obj){ f64 VM::num_to_float(const PyVar& obj){
if(is_float(obj)){ if(is_float(obj)){
return py_cast_v<f64>(this, obj); return CAST_V(f64, obj);
} else if (is_int(obj)){ } else if (is_int(obj)){
return (f64)py_cast_v<i64>(this, obj); return (f64)CAST_V(i64, obj);
} }
TypeError("expected 'int' or 'float', got " + OBJ_NAME(_t(obj)).escape(true)); TypeError("expected 'int' or 'float', got " + OBJ_NAME(_t(obj)).escape(true));
return 0; return 0;
@ -469,22 +469,22 @@ f64 VM::num_to_float(const PyVar& obj){
const PyVar& VM::asBool(const PyVar& obj){ const PyVar& VM::asBool(const PyVar& obj){
if(is_type(obj, tp_bool)) return obj; if(is_type(obj, tp_bool)) return obj;
if(obj == None) return False; if(obj == None) return False;
if(is_type(obj, tp_int)) return py_var(this, py_cast_v<i64>(this, obj) != 0); if(is_type(obj, tp_int)) return VAR(CAST_V(i64, obj) != 0);
if(is_type(obj, tp_float)) return py_var(this, py_cast_v<f64>(this, obj) != 0.0); if(is_type(obj, tp_float)) return VAR(CAST_V(f64, obj) != 0.0);
PyVarOrNull len_fn = getattr(obj, __len__, false); PyVarOrNull len_fn = getattr(obj, __len__, false);
if(len_fn != nullptr){ if(len_fn != nullptr){
PyVar ret = call(len_fn); PyVar ret = call(len_fn);
return py_var(this, py_cast_v<i64>(this, ret) > 0); return VAR(CAST_V(i64, ret) > 0);
} }
return True; return True;
} }
i64 VM::hash(const PyVar& obj){ i64 VM::hash(const PyVar& obj){
if (is_type(obj, tp_str)) return py_cast<Str>(this, obj).hash(); if (is_type(obj, tp_str)) return CAST(Str, obj).hash();
if (is_int(obj)) return py_cast_v<i64>(this, obj); if (is_int(obj)) return CAST_V(i64, obj);
if (is_type(obj, tp_tuple)) { if (is_type(obj, tp_tuple)) {
i64 x = 1000003; i64 x = 1000003;
const Tuple& items = py_cast<Tuple>(this, obj); const Tuple& items = CAST(Tuple, obj);
for (int i=0; i<items.size(); i++) { for (int i=0; i<items.size(); i++) {
i64 y = hash(items[i]); i64 y = hash(items[i]);
x = x ^ (y + 0x9e3779b9 + (x << 6) + (x >> 2)); // recommended by Github Copilot x = x ^ (y + 0x9e3779b9 + (x << 6) + (x >> 2)); // recommended by Github Copilot
@ -492,9 +492,9 @@ i64 VM::hash(const PyVar& obj){
return x; return x;
} }
if (is_type(obj, tp_type)) return obj.bits; if (is_type(obj, tp_type)) return obj.bits;
if (is_type(obj, tp_bool)) return _py_cast_v<bool>(this, obj) ? 1 : 0; if (is_type(obj, tp_bool)) return _CAST_V(bool, obj) ? 1 : 0;
if (is_float(obj)){ if (is_float(obj)){
f64 val = py_cast_v<f64>(this, obj); f64 val = CAST_V(f64, obj);
return (i64)std::hash<f64>()(val); return (i64)std::hash<f64>()(val);
} }
TypeError("unhashable type: " + OBJ_NAME(_t(obj)).escape(true)); TypeError("unhashable type: " + OBJ_NAME(_t(obj)).escape(true));
@ -502,7 +502,7 @@ i64 VM::hash(const PyVar& obj){
} }
PyVar VM::asRepr(const PyVar& obj){ PyVar VM::asRepr(const PyVar& obj){
if(is_type(obj, tp_type)) return py_var(this, "<class '" + OBJ_GET(Str, obj->attr(__name__)) + "'>"); if(is_type(obj, tp_type)) return VAR("<class '" + OBJ_GET(Str, obj->attr(__name__)) + "'>");
return call(obj, __repr__); return call(obj, __repr__);
} }
@ -512,7 +512,7 @@ PyVar VM::new_type_object(PyVar mod, StrName name, PyVar base){
setattr(obj, __base__, base); setattr(obj, __base__, base);
Str fullName = name.str(); Str fullName = name.str();
if(mod != builtins) fullName = OBJ_NAME(mod) + "." + name.str(); if(mod != builtins) fullName = OBJ_NAME(mod) + "." + name.str();
setattr(obj, __name__, py_var(this, fullName)); setattr(obj, __name__, VAR(fullName));
setattr(mod, name, obj); setattr(mod, name, obj);
_all_types.push_back(obj); _all_types.push_back(obj);
return obj; return obj;
@ -520,7 +520,7 @@ PyVar VM::new_type_object(PyVar mod, StrName name, PyVar base){
PyVar VM::new_module(StrName name) { PyVar VM::new_module(StrName name) {
PyVar obj = new_object(tp_module, DummyModule()); PyVar obj = new_object(tp_module, DummyModule());
setattr(obj, __name__, py_var(this, name.str())); setattr(obj, __name__, VAR(name.str()));
_modules.set(name, obj); _modules.set(name, obj);
return obj; return obj;
} }
@ -557,7 +557,7 @@ Str VM::disassemble(CodeObject_ co){
// ss << pad(byte.arg == -1 ? "" : std::to_string(byte.arg), 5); // ss << pad(byte.arg == -1 ? "" : std::to_string(byte.arg), 5);
std::string argStr = byte.arg == -1 ? "" : std::to_string(byte.arg); std::string argStr = byte.arg == -1 ? "" : std::to_string(byte.arg);
if(byte.op == OP_LOAD_CONST){ if(byte.op == OP_LOAD_CONST){
argStr += " (" + py_cast<Str>(this, asRepr(co->consts[byte.arg])) + ")"; argStr += " (" + CAST(Str, asRepr(co->consts[byte.arg])) + ")";
} }
if(byte.op == OP_LOAD_NAME_REF || byte.op == OP_LOAD_NAME || byte.op == OP_RAISE || byte.op == OP_STORE_NAME){ if(byte.op == OP_LOAD_NAME_REF || byte.op == OP_LOAD_NAME || byte.op == OP_RAISE || byte.op == OP_STORE_NAME){
argStr += " (" + co->names[byte.arg].first.str().escape(true) + ")"; argStr += " (" + co->names[byte.arg].first.str().escape(true) + ")";
@ -573,21 +573,21 @@ Str VM::disassemble(CodeObject_ co){
} }
StrStream consts; StrStream consts;
consts << "co_consts: "; consts << "co_consts: ";
consts << py_cast<Str>(this, asRepr(py_var(this, co->consts))); consts << CAST(Str, asRepr(VAR(co->consts)));
StrStream names; StrStream names;
names << "co_names: "; names << "co_names: ";
List list; List list;
for(int i=0; i<co->names.size(); i++){ for(int i=0; i<co->names.size(); i++){
list.push_back(py_var(this, co->names[i].first.str())); list.push_back(VAR(co->names[i].first.str()));
} }
names << py_cast<Str>(this, asRepr(py_var(this, list))); names << CAST(Str, asRepr(VAR(list)));
ss << '\n' << consts.str() << '\n' << names.str() << '\n'; ss << '\n' << consts.str() << '\n' << names.str() << '\n';
for(int i=0; i<co->consts.size(); i++){ for(int i=0; i<co->consts.size(); i++){
PyVar obj = co->consts[i]; PyVar obj = co->consts[i];
if(is_type(obj, tp_function)){ if(is_type(obj, tp_function)){
const auto& f = py_cast<Function>(this, obj); const auto& f = CAST(Function, obj);
ss << disassemble(f.code); ss << disassemble(f.code);
} }
} }
@ -638,7 +638,7 @@ void VM::init_builtin_types(){
setattr(_t(tp_object), __base__, None); setattr(_t(tp_object), __base__, None);
for(auto [k, v]: _types.items()){ for(auto [k, v]: _types.items()){
setattr(v, __name__, py_var(this, k.str())); setattr(v, __name__, VAR(k.str()));
} }
std::vector<Str> pb_types = {"type", "object", "bool", "int", "float", "str", "list", "tuple", "range"}; std::vector<Str> pb_types = {"type", "object", "bool", "int", "float", "str", "list", "tuple", "range"};
@ -667,7 +667,7 @@ PyVar VM::call(const PyVar& _callable, Args args, const Args& kwargs, bool opCal
const PyVar* callable = &_callable; const PyVar* callable = &_callable;
if(is_type(*callable, tp_bound_method)){ if(is_type(*callable, tp_bound_method)){
auto& bm = py_cast<BoundMethod>(this, *callable); auto& bm = CAST(BoundMethod, *callable);
callable = &bm.method; // get unbound method callable = &bm.method; // get unbound method
args.extend_self(bm.obj); args.extend_self(bm.obj);
} }
@ -677,7 +677,7 @@ PyVar VM::call(const PyVar& _callable, Args args, const Args& kwargs, bool opCal
if(kwargs.size() != 0) TypeError("native_function does not accept keyword arguments"); if(kwargs.size() != 0) TypeError("native_function does not accept keyword arguments");
return f(this, args); return f(this, args);
} else if(is_type(*callable, tp_function)){ } else if(is_type(*callable, tp_function)){
const Function& fn = py_cast<Function>(this, *callable); const Function& fn = CAST(Function, *callable);
NameDict_ locals = make_sp<NameDict>( NameDict_ locals = make_sp<NameDict>(
fn.code->perfect_locals_capacity, fn.code->perfect_locals_capacity,
kLocalsLoadFactor, kLocalsLoadFactor,
@ -698,7 +698,7 @@ PyVar VM::call(const PyVar& _callable, Args args, const Args& kwargs, bool opCal
if(!fn.starred_arg.empty()){ if(!fn.starred_arg.empty()){
List vargs; // handle *args List vargs; // handle *args
while(i < args.size()) vargs.push_back(std::move(args[i++])); while(i < args.size()) vargs.push_back(std::move(args[i++]));
locals->set(fn.starred_arg, py_var(this, Tuple::from_list(std::move(vargs)))); locals->set(fn.starred_arg, VAR(Tuple::from_list(std::move(vargs))));
}else{ }else{
for(StrName key : fn.kwargs_order){ for(StrName key : fn.kwargs_order){
if(i < args.size()){ if(i < args.size()){
@ -711,7 +711,7 @@ PyVar VM::call(const PyVar& _callable, Args args, const Args& kwargs, bool opCal
} }
for(int i=0; i<kwargs.size(); i+=2){ for(int i=0; i<kwargs.size(); i+=2){
const Str& key = py_cast<Str>(this, kwargs[i]); const Str& key = CAST(Str, kwargs[i]);
if(!fn.kwargs.contains(key)){ if(!fn.kwargs.contains(key)){
TypeError(key.escape(true) + " is an invalid keyword argument for " + fn.name.str() + "()"); TypeError(key.escape(true) + " is an invalid keyword argument for " + fn.name.str() + "()");
} }
@ -732,10 +732,10 @@ void VM::unpack_args(Args& args){
List unpacked; List unpacked;
for(int i=0; i<args.size(); i++){ for(int i=0; i<args.size(); i++){
if(is_type(args[i], tp_star_wrapper)){ if(is_type(args[i], tp_star_wrapper)){
auto& star = _py_cast<StarWrapper>(this, args[i]); auto& star = _CAST(StarWrapper, args[i]);
if(!star.rvalue) UNREACHABLE(); if(!star.rvalue) UNREACHABLE();
PyVar list = asList(star.obj); PyVar list = asList(star.obj);
List& list_c = py_cast<List>(this, list); List& list_c = CAST(List, list);
unpacked.insert(unpacked.end(), list_c.begin(), list_c.end()); unpacked.insert(unpacked.end(), list_c.begin(), list_c.end());
}else{ }else{
unpacked.push_back(args[i]); unpacked.push_back(args[i]);
@ -777,7 +777,7 @@ PyVarOrNull VM::getattr(const PyVar& obj, StrName name, bool throw_err) {
return call(descriptor, one_arg(obj)); return call(descriptor, one_arg(obj));
} }
if(is_type(*val, tp_function) || is_type(*val, tp_native_function)){ if(is_type(*val, tp_function) || is_type(*val, tp_native_function)){
return py_var(this, BoundMethod(obj, *val)); return VAR(BoundMethod(obj, *val));
}else{ }else{
return *val; return *val;
} }
@ -800,12 +800,12 @@ void VM::setattr(PyVar& obj, StrName name, T&& value) {
template<int ARGC> template<int ARGC>
void VM::bind_method(PyVar obj, Str funcName, NativeFuncRaw fn) { void VM::bind_method(PyVar obj, Str funcName, NativeFuncRaw fn) {
check_type(obj, tp_type); check_type(obj, tp_type);
setattr(obj, funcName, py_var(this, NativeFunc(fn, ARGC, true))); setattr(obj, funcName, VAR(NativeFunc(fn, ARGC, true)));
} }
template<int ARGC> template<int ARGC>
void VM::bind_func(PyVar obj, Str funcName, NativeFuncRaw fn) { void VM::bind_func(PyVar obj, Str funcName, NativeFuncRaw fn) {
setattr(obj, funcName, py_var(this, NativeFunc(fn, ARGC, false))); setattr(obj, funcName, VAR(NativeFunc(fn, ARGC, false)));
} }
void VM::_error(Exception e){ void VM::_error(Exception e){
@ -813,7 +813,7 @@ void VM::_error(Exception e){
e.is_re = false; e.is_re = false;
throw e; throw e;
} }
top_frame()->push(py_var(this, e)); top_frame()->push(VAR(e));
_raise(); _raise();
} }
@ -845,7 +845,7 @@ PyVar VM::_exec(){
continue; continue;
}catch(UnhandledException& e){ }catch(UnhandledException& e){
PyVar obj = frame->pop(); PyVar obj = frame->pop();
Exception& _e = py_cast<Exception>(this, obj); Exception& _e = CAST(Exception, obj);
_e.st_push(frame->snapshot()); _e.st_push(frame->snapshot());
callstack.pop(); callstack.pop();
if(callstack.empty()) throw _e; if(callstack.empty()) throw _e;