refactor

.gitignore

@@ -21,4 +21,5 @@ plugins/macos/pocketpy/pocketpy.h
 plugins/godot/godot-cpp/
 123.txt
 src/_generated.h
-profile.sh
+profile.sh
+test

src/ceval.h

@@ -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_FUNCTION: {
             const PyVar obj = frame->co->consts[byte.arg];
-            Function f = CAST_V(Function, obj);  // copy
+            Function f = CAST(Function, obj);  // copy
             f._module = frame->_module;
             frame->push(VAR(f));
         } continue;
         case OP_SETUP_CLOSURE: {
-            Function& f = CAST(Function, frame->top());    // reference
+            Function& f = CAST(Function&, frame->top());    // reference
             f._closure = frame->_locals;
         } continue;
         case OP_LOAD_NAME_REF: {
@@ -85,7 +85,7 @@ PyVar VM::run_frame(Frame* frame){
         case OP_LOAD_EVAL_FN: frame->push(builtins->attr(m_eval)); continue;
         case OP_LIST_APPEND: {
             PyVar obj = frame->pop_value(this);
-            List& list = CAST(List, frame->top_1());
+            List& list = CAST(List&, frame->top_1());
             list.push_back(std::move(obj));
         } continue;
         case OP_BEGIN_CLASS: {
@@ -154,7 +154,7 @@ PyVar VM::run_frame(Frame* frame){
         } continue;
         case OP_CONTAINS_OP: {
             PyVar rhs = frame->pop_value(this);
-            bool ret_c = CAST_V(bool, call(rhs, __contains__, one_arg(frame->pop_value(this))));
+            bool ret_c = CAST(bool, call(rhs, __contains__, one_arg(frame->pop_value(this))));
             if(byte.arg == 1) ret_c = !ret_c;
             frame->push(VAR(ret_c));
         } continue;
@@ -164,10 +164,10 @@ PyVar VM::run_frame(Frame* frame){
         case OP_UNARY_NOT: {
             PyVar obj = frame->pop_value(this);
             const PyVar& obj_bool = asBool(obj);
-            frame->push(VAR(!_CAST_V(bool, obj_bool)));
+            frame->push(VAR(!_CAST(bool, obj_bool)));
         } continue;
         case OP_POP_JUMP_IF_FALSE:
-            if(!_CAST_V(bool, asBool(frame->pop_value(this)))) frame->jump_abs(byte.arg);
+            if(!_CAST(bool, asBool(frame->pop_value(this)))) frame->jump_abs(byte.arg);
             continue;
         case OP_LOAD_NONE: frame->push(None); continue;
         case OP_LOAD_TRUE: frame->push(True); continue;
@@ -180,7 +180,7 @@ PyVar VM::run_frame(Frame* frame){
             if(asBool(expr) != True) _error("AssertionError", msg);
         } continue;
         case OP_EXCEPTION_MATCH: {
-            const auto& e = CAST(Exception, frame->top());
+            const auto& e = CAST(Exception&, frame->top());
             StrName name = frame->co->names[byte.arg].first;
             frame->push(VAR(e.match_type(name)));
         } continue;
@@ -284,8 +284,8 @@ PyVar VM::run_frame(Frame* frame){
             PyVar stop = frame->pop_value(this);
             PyVar start = frame->pop_value(this);
             Slice s;
-            if(start != None) { s.start = (int)CAST_V(i64, start);}
-            if(stop != None) { s.stop = (int)CAST_V(i64, stop);}
+            if(start != None) { s.start = CAST(int, start);}
+            if(stop != None) { s.stop = CAST(int, stop);}
             frame->push(VAR(s));
         } continue;
         case OP_IMPORT_NAME: {

src/cffi.h

@@ -1,130 +1,179 @@
 #pragma once
 
+#include "common.h"
 #include "vm.h"
+#include <vector>
 
 namespace pkpy {
 
-struct CType{
-    PY_CLASS(CType, c, type_)
+template<typename Ret, typename... Params>
+struct ProxyFunction {
+    using T = Ret(*)(Params...);
+    static constexpr int N = sizeof...(Params);
+    T func;
+    ProxyFunction(T func) : func(func) {}
 
-    const char* name;       // must be a literal
-    const int size;
-    const int index;
-    constexpr CType(const char name[], int size, int index) : name(name), size(size), index(index) {}
-
-    static void _register(VM* vm, PyVar mod, PyVar type){
-        vm->bind_static_method<-1>(type, "__new__", CPP_NOT_IMPLEMENTED());
+    PyVar operator()(VM* vm, Args& args) {
+        if (args.size() != N) vm->TypeError("invalid number of arguments");
+        return call(vm, args, std::make_index_sequence<N>());
+    }
 
-        vm->bind_method<0>(type, "__repr__", [](VM* vm, Args& args) {
-            CType& self = CAST(CType, args[0]);
-            StrStream ss;
-            ss << "<c._type '" << self.name << "' (" << self.size*8 << " bits)>";
-            return VAR(ss.str());
-        });
+    template<size_t... Is>
+    PyVar call(VM* vm, Args& args, std::index_sequence<Is...>) {
+        Ret ret = func(py_cast<Params>(vm, args[Is])...);
+        return VAR(std::move(ret));
     }
 };
 
-constexpr CType kCTypes[] = {
-    CType("char_", sizeof(char), 0), CType("int_", sizeof(int), 1),
-    CType("float_", sizeof(float), 2), CType("double_", sizeof(double), 3),
-    CType("bool_", sizeof(bool), 4), CType("void_", 1, 5),
-    CType("int8_", sizeof(int8_t), 6), CType("int16_", sizeof(int16_t), 7),
-    CType("int32_", sizeof(int32_t), 8), CType("int64_", sizeof(int64_t), 9), 
-    CType("uint8_", sizeof(uint8_t), 10), CType("uint16_", sizeof(uint16_t), 11),
-    CType("uint32_", sizeof(uint32_t), 12), CType("uint64_", sizeof(uint64_t), 13),
-    CType("void_p_", sizeof(intptr_t), 14),
-    // use macro here to do extension
+
+struct TypeInfo;
+
+struct MemberInfo{
+    TypeInfo* type;
+    int offset;
 };
 
-const int kCTypeCount = sizeof(kCTypes) / sizeof(CType);
+struct TypeInfo{
+    const char* name;
+    int size;
+    int index;      // for basic types only
+    std::map<StrName, MemberInfo> members;
 
-constexpr int C_TYPE(const char name[]){
-    for(int k=0; k<kCTypeCount; k++){
-        const char* i = kCTypes[k].name;
-        const char* j = name;
-        while(*i && *j && *i == *j) { i++; j++;}
-        if(*i == *j) return k;
-    }
-    UNREACHABLE();
-}
+    TypeInfo(const char name[], int size, int index) : name(name), size(size), index(index) {}
+    TypeInfo(const char name[], int size, std::map<StrName, MemberInfo> members)
+        : name(name), size(size), index(-1), members(members) {}
+    TypeInfo() : name(nullptr), size(0), index(-1) {}
+};
+
+template<typename T>
+constexpr int type_index() { return -1; }
+template<> constexpr int type_index<void>() { return 0; }
+template<> constexpr int type_index<char>() { return 1; }
+template<> constexpr int type_index<short>() { return 2; }
+template<> constexpr int type_index<int>() { return 3; }
+template<> constexpr int type_index<long>() { return 4; }
+template<> constexpr int type_index<long long>() { return 5; }
+template<> constexpr int type_index<unsigned char>() { return 6; }
+template<> constexpr int type_index<unsigned short>() { return 7; }
+template<> constexpr int type_index<unsigned int>() { return 8; }
+template<> constexpr int type_index<unsigned long>() { return 9; }
+template<> constexpr int type_index<unsigned long long>() { return 10; }
+template<> constexpr int type_index<float>() { return 11; }
+template<> constexpr int type_index<double>() { return 12; }
+template<> constexpr int type_index<bool>() { return 13; }
+
+struct Vec2 {
+    float x, y;
+};
+
+static std::map<std::string_view, TypeInfo> _type_infos;
+
+auto _ = [](){
+    #define REGISTER_BASIC_TYPE(T) _type_infos[#T] = TypeInfo(#T, sizeof(T), type_index<T>())
+    _type_infos["void"] = TypeInfo("void", 1, type_index<void>());
+    REGISTER_BASIC_TYPE(char);
+    REGISTER_BASIC_TYPE(short);
+    REGISTER_BASIC_TYPE(int);
+    REGISTER_BASIC_TYPE(long);
+    REGISTER_BASIC_TYPE(long long);
+    REGISTER_BASIC_TYPE(unsigned char);
+    REGISTER_BASIC_TYPE(unsigned short);
+    REGISTER_BASIC_TYPE(unsigned int);
+    REGISTER_BASIC_TYPE(unsigned long);
+    REGISTER_BASIC_TYPE(unsigned long long);
+    REGISTER_BASIC_TYPE(float);
+    REGISTER_BASIC_TYPE(double);
+    REGISTER_BASIC_TYPE(bool);
+    #undef REGISTER_BASIC_TYPE
+
+    _type_infos["Vec2"] = TypeInfo("Vec2", sizeof(Vec2), {
+        {"x", {&_type_infos["float"], offsetof(Vec2, x)}},
+        {"y", {&_type_infos["float"], offsetof(Vec2, y)}},
+    });
+    return 0;
+}();
 
-#define C_TYPE_T(x) (kCTypes[C_TYPE(x)])
 
 struct Pointer{
     PY_CLASS(Pointer, c, ptr_)
 
-    void* ptr;
-    CType ctype;       // base type
+    char* ptr;
+    TypeInfo* ctype;
+    int level;         // level of pointer
+
+    i64 unit_size() const {
+        return level == 1 ? ctype->size : sizeof(void*);
+    }
+
+    bool type_equal(const Pointer& other) const {
+        return level == other.level && ctype == other.ctype;
+    }
 
-    Pointer(void* ptr, CType ctype) : ptr(ptr), ctype(ctype) {}
+    Pointer() : ptr(nullptr), ctype(&_type_infos["void"]), level(1) {}
+    Pointer(char* ptr, TypeInfo* ctype, int level=1) : ptr(ptr), ctype(ctype), level(level) {}
 
-    Pointer operator+(i64 offset) const {
-        return Pointer((int8_t*)ptr + offset * ctype.size, ctype);
+    Pointer operator+(i64 offset) const { 
+        return Pointer(ptr + offset * unit_size(), ctype, level);
     }
 
-    Pointer operator-(i64 offset) const {
-        return Pointer((int8_t*)ptr - offset * ctype.size, ctype);
+    Pointer operator-(i64 offset) const { 
+        return Pointer(ptr - offset * unit_size(), ctype, level);
     }
 
     static void _register(VM* vm, PyVar mod, PyVar type){
         vm->bind_static_method<-1>(type, "__new__", CPP_NOT_IMPLEMENTED());
 
         vm->bind_method<0>(type, "__repr__", [](VM* vm, Args& args) {
-            Pointer& self = CAST(Pointer, args[0]);
+            Pointer& self = CAST(Pointer&, args[0]);
             StrStream ss;
-            ss << "<" << self.ctype.name << "* at " << (i64)self.ptr << ">";
+            ss << "<" << self.ctype->name;
+            for(int i=0; i<self.level; i++) ss << "*";
+            ss << " at " << (i64)self.ptr << ">";
             return VAR(ss.str());
         });
 
         vm->bind_method<1>(type, "__add__", [](VM* vm, Args& args) {
-            Pointer& self = CAST(Pointer, args[0]);
+            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 = CAST(Pointer, args[0]);
-            return VAR_T(Pointer, self - CAST_V(i64, args[1]));
+            Pointer& self = CAST(Pointer&, args[0]);
+            return VAR_T(Pointer, self - CAST(i64, args[1]));
         });
 
         vm->bind_method<1>(type, "__eq__", [](VM* vm, Args& args) {
-            Pointer& self = CAST(Pointer, args[0]);
-            Pointer& other = 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 = CAST(Pointer, args[0]);
-            Pointer& other = 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 = CAST(Pointer, args[0]);
-            i64 index = CAST_V(i64, args[1]);
+            Pointer& self = CAST(Pointer&, args[0]);
+            i64 index = CAST(i64, args[1]);
             return (self+index).get(vm);
         });
 
         vm->bind_method<2>(type, "__setitem__", [](VM* vm, Args& args) {
-            Pointer& self = CAST(Pointer, args[0]);
-            i64 index = CAST_V(i64, args[1]);
+            Pointer& self = CAST(Pointer&, args[0]);
+            i64 index = CAST(i64, args[1]);
             (self+index).set(vm, args[2]);
             return vm->None;
         });
 
-        vm->bind_method<1>(type, "cast", [](VM* vm, Args& args) {
-            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 = 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 = CAST(Pointer, args[0]);
+            Pointer& self = CAST(Pointer&, args[0]);
             self.set(vm, args[1]);
             return vm->None;
         });
@@ -133,118 +182,88 @@ struct Pointer{
     template<typename T>
     inline T& ref() noexcept { return *reinterpret_cast<T*>(ptr); }
 
-    template<typename TP>
-    inline TP cast() noexcept {
-        static_assert(std::is_pointer_v<TP>);
-        return reinterpret_cast<TP>(ptr);
-    }
-
     PyVar get(VM* vm){
-        switch(ctype.index){
-            case C_TYPE("char_"): return VAR(ref<char>());
-            case C_TYPE("int_"): return VAR(ref<int>());
-            case C_TYPE("float_"): return VAR(ref<float>());
-            case C_TYPE("double_"): return VAR(ref<double>());
-            case C_TYPE("bool_"): return VAR(ref<bool>());
-            case C_TYPE("void_"): vm->ValueError("cannot get void*"); break;
-            case C_TYPE("int8_"): return VAR(ref<int8_t>());
-            case C_TYPE("int16_"): return VAR(ref<int16_t>());
-            case C_TYPE("int32_"): return VAR(ref<int32_t>());
-            case C_TYPE("int64_"): return VAR(ref<int64_t>());
-            case C_TYPE("uint8_"): return VAR(ref<uint8_t>());
-            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 VAR_T(Pointer, ref<void*>(), C_TYPE_T("void_"));
-            // use macro here to do extension
-            default: UNREACHABLE();
+        if(level > 1) return VAR_T(Pointer, ptr, ctype, level-1);
+        switch(ctype->index){
+#define CASE(T) case type_index<T>(): return VAR(ref<T>())
+            case type_index<void>(): vm->ValueError("cannot get void*"); break;
+            CASE(char);
+            CASE(short);
+            CASE(int);
+            CASE(long);
+            CASE(long long);
+            CASE(unsigned char);
+            CASE(unsigned short);
+            CASE(unsigned int);
+            CASE(unsigned long);
+            CASE(unsigned long long);
+            CASE(float);
+            CASE(double);
+            CASE(bool);
+#undef CASE
         }
-        return vm->None;
+        return VAR_T(Pointer, *this);
     }
 
     void set(VM* vm, const PyVar& val){
-        switch(ctype.index){
-            case C_TYPE("char_"): ref<char>() = CAST_V(i64, val); break;
-            case C_TYPE("int_"): ref<int>() = CAST_V(i64, val); break;
-            case C_TYPE("float_"): ref<float>() = CAST_V(f64, val); break;
-            case C_TYPE("double_"): ref<double>() = CAST_V(f64, 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("int8_"): ref<int8_t>() = CAST_V(i64, val); break;
-            case C_TYPE("int16_"): ref<int16_t>() = CAST_V(i64, val); break;
-            case C_TYPE("int32_"): ref<int32_t>() = CAST_V(i64, val); break;
-            case C_TYPE("int64_"): ref<int64_t>() = CAST_V(i64, val); break;
-            case C_TYPE("uint8_"): ref<uint8_t>() = CAST_V(i64, val); break;
-            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*>() = CAST(Pointer, val).ptr; break;
-            // use macro here to do extension
-            default: UNREACHABLE();
+        if(level > 1) {
+            Pointer& p = CAST(Pointer&, val);
+            ref<void*>() = p.ptr;   // We don't check the type, just copy the underlying address
+            return;
+        }
+        switch(ctype->index){
+#define CASE(T1, T2) case type_index<T1>(): ref<T1>() = CAST(T2, val); break
+            case type_index<void>(): vm->ValueError("cannot set void*"); break;
+            CASE(char, i64);
+            CASE(short, i64);
+            CASE(int, i64);
+            CASE(long, i64);
+            CASE(long long, i64);
+            CASE(unsigned char, i64);
+            CASE(unsigned short, i64);
+            CASE(unsigned int, i64);
+            CASE(unsigned long, i64);
+            CASE(unsigned long long, i64);
+            CASE(float, f64);
+            CASE(double, f64);
+            CASE(bool, bool);
+#undef CASE
         }
+        UNREACHABLE();
     }
-};
 
-struct StructMemberInfo {
-    int offset;
-    CType type;
-};
-
-struct StructMetaInfo {
-    Str name;
-    std::map<StrName, StructMemberInfo> members;
-};
-
-struct Point2{
-    int x;
-    int y;
-};
-
-static const StructMetaInfo _Point2_info = {
-    "Point2",
-    {
-        {StrName("x"), {offsetof(Point2, x), C_TYPE_T("int_")}},
-        {StrName("y"), {offsetof(Point2, y), C_TYPE_T("int_")}},
+    Pointer address(VM* vm, StrName name){
+        auto it = ctype->members.find(name);
+        if(it == ctype->members.end()){
+            vm->AttributeError(Str("struct '") + ctype->name + "' has no member " + name.str().escape(true));
+        }
+        MemberInfo& info = it->second;
+        return {ptr+info.offset, info.type, level};
     }
 };
 
+
 struct Struct {
     PY_CLASS(Struct, c, struct_)
 
-    const StructMetaInfo* info;
-    int8_t* _data;      // store any `struct`
+    char* data;
+    Pointer head;
 
-    Struct(const StructMetaInfo* info, int8_t* data) : info(info), _data(data) {}
-    Struct(){
-        info = &_Point2_info;
-        _data = new int8_t[sizeof(Point2)];
-    }
-    ~Struct(){ delete[] _data; }
+    TypeInfo* ctype() const { return head.ctype; }
 
-    Pointer address(VM* vm, StrName name){
-        auto it = info->members.find(name);
-        if(it == info->members.end()) vm->AttributeError("struct " + info->name + " has no member " + name.str());
-        const StructMemberInfo& info = it->second;
-        return {_data+info.offset, info.type};
-    }
-
-    PyVarOrNull __getattr__(VM* vm, StrName name){
-        return address(vm, name).get(vm);
-    }
-
-    void __setattr__(VM* vm, StrName name, const PyVar& val){
-        address(vm, name).set(vm, val);
+    Struct(const Pointer& head) {
+        data = new char[head.ctype->size];
+        memcpy(data, head.ptr, head.ctype->size);
+        this->head = Pointer(data, head.ctype, head.level);
     }
 
     static void _register(VM* vm, PyVar mod, PyVar type){
-        vm->bind_static_method<-1>(type, "__new__", [](VM* vm, Args& args) {
-            return VAR_T(Struct);
-        });
+        vm->bind_static_method<-1>(type, "__new__", CPP_NOT_IMPLEMENTED());
 
         vm->bind_method<0>(type, "__repr__", [](VM* vm, Args& args) {
-            Struct& self = CAST(Struct, args[0]);
+            Struct& self = CAST(Struct&, args[0]);
             StrStream ss;
-            ss << self.info->name << "(" << ")";
+            ss << self.ctype()->name << "(" << ")";
             return VAR(ss.str());
         });
     }
@@ -253,69 +272,36 @@ struct Struct {
 void add_module_c(VM* vm){
     PyVar mod = vm->new_module("c");
     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, VAR_T(CType, kCTypes[i]));
-    }
-    vm->setattr(mod, "nullptr", VAR_T(Pointer, nullptr, C_TYPE_T("void_")));
+    vm->setattr(mod, "nullptr", VAR_T(Pointer, nullptr, &_type_infos["void"]));
 
     vm->bind_func<1>(mod, "malloc", [](VM* vm, Args& args) {
-        i64 size = CAST_V(i64, args[0]);
-        return VAR_T(Pointer, malloc(size), C_TYPE_T("void_"));
+        i64 size = CAST(i64, args[0]);
+        return VAR_T(Pointer, (char*)malloc(size), &_type_infos["void"]);
     });
 
     vm->bind_func<1>(mod, "free", [](VM* vm, Args& args) {
-        Pointer& self = 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 = CAST(CType, args[0]);
-        return VAR(ctype.size);
-    });
-
     vm->bind_func<3>(mod, "memcpy", [](VM* vm, Args& args) {
-        Pointer& dst = CAST(Pointer, args[0]);
-        Pointer& src = CAST(Pointer, args[1]);
-        i64 size = CAST_V(i64, args[2]);
+        Pointer& dst = CAST(Pointer&, args[0]);
+        Pointer& src = CAST(Pointer&, args[1]);
+        i64 size = CAST(i64, args[2]);
         memcpy(dst.ptr, src.ptr, size);
         return vm->None;
     });
 
     vm->bind_func<3>(mod, "memset", [](VM* vm, Args& args) {
-        Pointer& dst = CAST(Pointer, args[0]);
-        i64 val = CAST_V(i64, args[1]);
-        i64 size = CAST_V(i64, args[2]);
+        Pointer& dst = CAST(Pointer&, args[0]);
+        i64 val = CAST(i64, args[1]);
+        i64 size = CAST(i64, args[2]);
         memset(dst.ptr, (int)val, size);
         return vm->None;
     });
-
-    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 VAR_T(Pointer, strdup(s.c_str()), C_TYPE_T("char_"));
-        }else if(is_type(args[0], OBJ_GET(Type, ptr_t))){
-            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;
-        }
-    });
-
-    vm->bind_func<2>(mod, "strcmp", [](VM* vm, Args& args) {
-        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 = CAST(Pointer, args[0]);
-        return VAR(strlen(p.cast<char*>()));
-    });
 }
 
 }   // namespace pkpy

src/common.h

@@ -74,8 +74,6 @@ struct Type {
 #define UNREACHABLE() throw std::runtime_error( __FILE__ + std::string(":") + std::to_string(__LINE__) + " UNREACHABLE()!");
 #endif
 
-#define RAW(T) std::remove_const_t<std::remove_reference_t<T>>
-
 const float kLocalsLoadFactor = 0.67;
 const float kInstAttrLoadFactor = 0.67;
 const float kTypeAttrLoadFactor = 0.5;

src/obj.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "common.h"
 #include "namedict.h"
 #include "tuplelist.h"
 
@@ -173,16 +174,12 @@ union __8B {
 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>
 void _check_py_class(VM* vm, const PyVar& var);
 
-template<typename T>
-T& py_cast(VM* vm, const PyVar& obj) {
+template<typename __T>
+__T py_cast(VM* vm, const PyVar& obj) {
+    using T = std::decay_t<__T>;
     if constexpr(is_py_class<T>::value){
         _check_py_class<T>(vm, obj);
         return OBJ_GET(T, obj);
@@ -190,8 +187,9 @@ T& py_cast(VM* vm, const PyVar& obj) {
         throw std::runtime_error("bad py_cast() call");
     }
 }
-template<typename T>
-T& _py_cast(VM* vm, const PyVar& obj) {
+template<typename __T>
+__T _py_cast(VM* vm, const PyVar& obj) {
+    using T = std::decay_t<__T>;
     if constexpr(is_py_class<T>::value){
         return OBJ_GET(T, obj);
     }else{
@@ -202,8 +200,6 @@ T& _py_cast(VM* vm, const PyVar& obj) {
 #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)
-#define _CAST_V(T, x) _py_cast_v<T>(vm, x)
 
 }   // namespace pkpy

src/pocketpy.h

@@ -23,7 +23,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 VAR(_CAST_V(i64, args[0]) op _CAST_V(i64, args[1]));                     \
+            return VAR(_CAST(i64, args[0]) op _CAST(i64, args[1]));                     \
         }else{                                                                                          \
             return VAR(vm->num_to_float(args[0]) op vm->num_to_float(args[1]));                 \
         }                                                                                               \
@@ -36,7 +36,7 @@ CodeObject_ VM::compile(Str source, Str filename, CompileMode mode) {
             vm->TypeError("unsupported operand type(s) for " #op );                                     \
         }                                                                                               \
         if(is_both_int(args[0], args[1]))                                                               \
-            return VAR(_CAST_V(i64, args[0]) op _CAST_V(i64, args[1]));                    \
+            return VAR(_CAST(i64, args[0]) op _CAST(i64, args[1]));                    \
         return VAR(vm->num_to_float(args[0]) op vm->num_to_float(args[1]));                      \
     });
     
@@ -57,7 +57,7 @@ void init_builtins(VM* _vm) {
 #undef BIND_NUM_LOGICAL_OPT
 
     _vm->bind_builtin_func<1>("__sys_stdout_write", [](VM* vm, Args& args) {
-        (*vm->_stdout) << CAST(Str, args[0]);
+        (*vm->_stdout) << CAST(Str&, args[0]);
         return vm->None;
     });
 
@@ -74,19 +74,19 @@ void init_builtins(VM* _vm) {
     });
 
     _vm->bind_builtin_func<1>("eval", [](VM* vm, Args& args) {
-        CodeObject_ code = vm->compile(CAST(Str, 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);
     });
 
     _vm->bind_builtin_func<1>("exec", [](VM* vm, Args& args) {
-        CodeObject_ code = vm->compile(CAST(Str, 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);
         return vm->None;
     });
 
     _vm->bind_builtin_func<-1>("exit", [](VM* vm, Args& args) {
         if(args.size() == 0) std::exit(0);
-        else if(args.size() == 1) std::exit((int)CAST_V(i64, args[0]));
+        else if(args.size() == 1) std::exit(CAST(int, args[0]));
         else vm->TypeError("exit() takes at most 1 argument");
         return vm->None;
     });
@@ -101,34 +101,34 @@ void init_builtins(VM* _vm) {
     });
 
     _vm->bind_builtin_func<1>("chr", [](VM* vm, Args& args) {
-        i64 i = CAST_V(i64, args[0]);
+        i64 i = CAST(i64, args[0]);
         if (i < 0 || i > 128) vm->ValueError("chr() arg not in range(128)");
         return VAR(std::string(1, (char)i));
     });
 
     _vm->bind_builtin_func<1>("ord", [](VM* vm, Args& args) {
-        Str s = CAST(Str, args[0]);
+        const Str& s = CAST(Str&, args[0]);
         if (s.size() != 1) vm->TypeError("ord() expected an ASCII character");
         return VAR((i64)(s.c_str()[0]));
     });
 
     _vm->bind_builtin_func<2>("hasattr", [](VM* vm, Args& args) {
-        return VAR(vm->getattr(args[0], CAST(Str, 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->setattr(args[0], CAST(Str, args[1]), args[2]);
+        vm->setattr(args[0], CAST(Str&, args[1]), args[2]);
         return vm->None;
     });
 
     _vm->bind_builtin_func<2>("getattr", [](VM* vm, Args& args) {
-        Str name = CAST(Str, args[1]);
+        const Str& name = CAST(Str&, args[1]);
         return vm->getattr(args[0], name);
     });
 
     _vm->bind_builtin_func<1>("hex", [](VM* vm, Args& args) {
         std::stringstream ss;
-        ss << std::hex << CAST_V(i64, args[0]);
+        ss << std::hex << CAST(i64, args[0]);
         return VAR("0x" + ss.str());
     });
 
@@ -163,9 +163,9 @@ void init_builtins(VM* _vm) {
     _vm->bind_static_method<-1>("range", "__new__", [](VM* vm, Args& args) {
         Range r;
         switch (args.size()) {
-            case 1: r.stop = CAST_V(i64, args[0]); break;
-            case 2: r.start = CAST_V(i64, args[0]); r.stop = CAST_V(i64, args[1]); 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;
+            case 1: r.stop = CAST(i64, args[0]); break;
+            case 2: r.start = CAST(i64, args[0]); r.stop = CAST(i64, args[1]); break;
+            case 3: r.start = CAST(i64, args[0]); r.stop = CAST(i64, args[1]); r.step = CAST(i64, args[2]); break;
             default: vm->TypeError("expected 1-3 arguments, but got " + std::to_string(args.size()));
         }
         return VAR(r);
@@ -186,8 +186,8 @@ void init_builtins(VM* _vm) {
 
     _vm->_bind_methods<1>({"int", "float"}, "__pow__", [](VM* vm, Args& args) {
         if(is_both_int(args[0], args[1])){
-            i64 lhs = _CAST_V(i64, args[0]);
-            i64 rhs = _CAST_V(i64, args[1]);
+            i64 lhs = _CAST(i64, args[0]);
+            i64 rhs = _CAST(i64, args[1]);
             bool flag = false;
             if(rhs < 0) {flag = true; rhs = -rhs;}
             i64 ret = 1;
@@ -206,10 +206,10 @@ 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 VAR((i64)CAST_V(f64, args[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_float)) return VAR((i64)CAST(f64, args[0]));
+        if (is_type(args[0], vm->tp_bool)) return VAR(_CAST(bool, args[0]) ? 1 : 0);
         if (is_type(args[0], vm->tp_str)) {
-            const Str& s = CAST(Str, args[0]);
+            const Str& s = CAST(Str&, args[0]);
             try{
                 size_t parsed = 0;
                 i64 val = S_TO_INT(s, &parsed, 10);
@@ -224,22 +224,22 @@ void init_builtins(VM* _vm) {
     });
 
     _vm->bind_method<1>("int", "__floordiv__", [](VM* vm, Args& args) {
-        i64 rhs = CAST_V(i64, args[1]);
+        i64 rhs = CAST(i64, args[1]);
         if(rhs == 0) vm->ZeroDivisionError();
-        return VAR(CAST_V(i64, args[0]) / rhs);
+        return VAR(CAST(i64, args[0]) / rhs);
     });
 
     _vm->bind_method<1>("int", "__mod__", [](VM* vm, Args& args) {
-        i64 rhs = CAST_V(i64, args[1]);
+        i64 rhs = CAST(i64, args[1]);
         if(rhs == 0) vm->ZeroDivisionError();
-        return VAR(CAST_V(i64, args[0]) % rhs);
+        return VAR(CAST(i64, args[0]) % rhs);
     });
 
-    _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(CAST_V(i64, args[0])))));
+    _vm->bind_method<0>("int", "__repr__", CPP_LAMBDA(VAR(std::to_string(CAST(i64, args[0])))));
+    _vm->bind_method<0>("int", "__json__", CPP_LAMBDA(VAR(std::to_string(CAST(i64, args[0])))));
 
 #define INT_BITWISE_OP(name,op) \
-    _vm->bind_method<1>("int", #name, CPP_LAMBDA(VAR(CAST_V(i64, args[0]) op CAST_V(i64, args[1]))));
+    _vm->bind_method<1>("int", #name, CPP_LAMBDA(VAR(CAST(i64, args[0]) op CAST(i64, args[1]))));
 
     INT_BITWISE_OP(__lshift__, <<)
     INT_BITWISE_OP(__rshift__, >>)
@@ -251,11 +251,11 @@ void init_builtins(VM* _vm) {
 
     /************ PyFloat ************/
     _vm->bind_static_method<1>("float", "__new__", [](VM* vm, Args& args) {
-        if (is_type(args[0], vm->tp_int)) return VAR((f64)CAST_V(i64, args[0]));
+        if (is_type(args[0], vm->tp_int)) return VAR((f64)CAST(i64, args[0]));
         if (is_type(args[0], vm->tp_float)) return args[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_bool)) return VAR(_CAST(bool, args[0]) ? 1.0 : 0.0);
         if (is_type(args[0], vm->tp_str)) {
-            const Str& s = CAST(Str, args[0]);
+            const Str& s = CAST(Str&, args[0]);
             if(s == "inf") return VAR(INFINITY);
             if(s == "-inf") return VAR(-INFINITY);
             try{
@@ -270,7 +270,7 @@ void init_builtins(VM* _vm) {
     });
 
     _vm->bind_method<0>("float", "__repr__", [](VM* vm, Args& args) {
-        f64 val = CAST_V(f64, args[0]);
+        f64 val = CAST(f64, args[0]);
         if(std::isinf(val) || std::isnan(val)) return VAR(std::to_string(val));
         StrStream ss;
         ss << std::setprecision(std::numeric_limits<f64>::max_digits10-1-2) << val;
@@ -280,7 +280,7 @@ void init_builtins(VM* _vm) {
     });
 
     _vm->bind_method<0>("float", "__json__", [](VM* vm, Args& args) {
-        f64 val = CAST_V(f64, args[0]);
+        f64 val = CAST(f64, args[0]);
         if(std::isinf(val) || std::isnan(val)) vm->ValueError("cannot jsonify 'nan' or 'inf'");
         return VAR(std::to_string(val));
     });
@@ -289,19 +289,19 @@ void init_builtins(VM* _vm) {
     _vm->bind_static_method<1>("str", "__new__", CPP_LAMBDA(vm->asStr(args[0])));
 
     _vm->bind_method<1>("str", "__add__", [](VM* vm, Args& args) {
-        const Str& lhs = CAST(Str, args[0]);
-        const Str& rhs = CAST(Str, args[1]);
+        const Str& lhs = CAST(Str&, args[0]);
+        const Str& rhs = CAST(Str&, args[1]);
         return VAR(lhs + rhs);
     });
 
     _vm->bind_method<0>("str", "__len__", [](VM* vm, Args& args) {
-        const Str& self = CAST(Str, args[0]);
+        const Str& self = CAST(Str&, args[0]);
         return VAR(self.u8_length());
     });
 
     _vm->bind_method<1>("str", "__contains__", [](VM* vm, Args& args) {
-        const Str& self = CAST(Str, args[0]);
-        const Str& other = CAST(Str, args[1]);
+        const Str& self = CAST(Str&, args[0]);
+        const Str& other = CAST(Str&, args[1]);
         return VAR(self.find(other) != Str::npos);
     });
 
@@ -309,59 +309,58 @@ void init_builtins(VM* _vm) {
     _vm->bind_method<0>("str", "__iter__", CPP_LAMBDA(vm->PyIter(StringIter(vm, args[0]))));
 
     _vm->bind_method<0>("str", "__repr__", [](VM* vm, Args& args) {
-        const Str& _self = CAST(Str, args[0]);
+        const Str& _self = CAST(Str&, args[0]);
         return VAR(_self.escape(true));
     });
 
     _vm->bind_method<0>("str", "__json__", [](VM* vm, Args& args) {
-        const Str& _self = CAST(Str, args[0]);
-        return VAR(_self.escape(false));
+        const Str& self = CAST(Str&, args[0]);
+        return VAR(self.escape(false));
     });
 
     _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))
-            return VAR(CAST(Str, args[0]) == CAST(Str, args[1]));
+            return VAR(CAST(Str&, args[0]) == CAST(Str&, args[1]));
         return VAR(args[0] == args[1]);
     });
 
     _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))
-            return VAR(CAST(Str, args[0]) != CAST(Str, args[1]));
+            return VAR(CAST(Str&, args[0]) != CAST(Str&, args[1]));
         return VAR(args[0] != args[1]);
     });
 
     _vm->bind_method<1>("str", "__getitem__", [](VM* vm, Args& args) {
-        const Str& self (CAST(Str, args[0]));
+        const Str& self (CAST(Str&, args[0]));
 
         if(is_type(args[1], vm->tp_slice)){
-            Slice s = _CAST_V(Slice, args[1]);
+            Slice s = _CAST(Slice, args[1]);
             s.normalize(self.u8_length());
             return VAR(self.u8_substr(s.start, s.stop));
         }
 
-        int index = (int)CAST_V(i64, args[1]);
+        int index = CAST(int, args[1]);
         index = vm->normalized_index(index, self.u8_length());
         return VAR(self.u8_getitem(index));
     });
 
     _vm->bind_method<1>("str", "__gt__", [](VM* vm, Args& args) {
-        const Str& self (CAST(Str, args[0]));
-        const Str& obj (CAST(Str, args[1]));
+        const Str& self (CAST(Str&, args[0]));
+        const Str& obj (CAST(Str&, args[1]));
         return VAR(self > obj);
     });
 
     _vm->bind_method<1>("str", "__lt__", [](VM* vm, Args& args) {
-        const Str& self (CAST(Str, args[0]));
-        const Str& obj (CAST(Str, args[1]));
+        const Str& self (CAST(Str&, args[0]));
+        const Str& obj (CAST(Str&, args[1]));
         return VAR(self < obj);
     });
 
     _vm->bind_method<2>("str", "replace", [](VM* vm, Args& args) {
-        const Str& _self = CAST(Str, args[0]);
-        const Str& _old = CAST(Str, args[1]);
-        const Str& _new = CAST(Str, args[2]);
+        const Str& _self = CAST(Str&, args[0]);
+        const Str& _old = CAST(Str&, args[1]);
+        const Str& _new = CAST(Str&, args[2]);
         Str _copy = _self;
-        // replace all occurences of _old with _new in _copy
         size_t pos = 0;
         while ((pos = _copy.find(_old, pos)) != std::string::npos) {
             _copy.replace(pos, _old.length(), _new);
@@ -371,45 +370,45 @@ void init_builtins(VM* _vm) {
     });
 
     _vm->bind_method<1>("str", "startswith", [](VM* vm, Args& args) {
-        const Str& _self = CAST(Str, args[0]);
-        const Str& _prefix = CAST(Str, args[1]);
-        return VAR(_self.find(_prefix) == 0);
+        const Str& self = CAST(Str&, args[0]);
+        const Str& prefix = CAST(Str&, args[1]);
+        return VAR(self.find(prefix) == 0);
     });
 
     _vm->bind_method<1>("str", "endswith", [](VM* vm, Args& args) {
-        const Str& _self = CAST(Str, args[0]);
-        const Str& _suffix = CAST(Str, args[1]);
-        return VAR(_self.rfind(_suffix) == _self.length() - _suffix.length());
+        const Str& self = CAST(Str&, args[0]);
+        const Str& suffix = CAST(Str&, args[1]);
+        return VAR(self.rfind(suffix) == self.length() - suffix.length());
     });
 
     _vm->bind_method<1>("str", "join", [](VM* vm, Args& args) {
-        const Str& self = CAST(Str, args[0]);
+        const Str& self = CAST(Str&, args[0]);
         StrStream ss;
         PyVar obj = vm->asList(args[1]);
-        const List& list = CAST(List, obj);
+        const List& list = CAST(List&, obj);
         for (int i = 0; i < list.size(); ++i) {
             if (i > 0) ss << self;
-            ss << CAST(Str, list[i]);
+            ss << CAST(Str&, list[i]);
         }
         return VAR(ss.str());
     });
 
     /************ PyList ************/
     _vm->bind_method<1>("list", "append", [](VM* vm, Args& args) {
-        List& self = CAST(List, args[0]);
+        List& self = CAST(List&, args[0]);
         self.push_back(args[1]);
         return vm->None;
     });
 
     _vm->bind_method<0>("list", "reverse", [](VM* vm, Args& args) {
-        List& self = CAST(List, args[0]);
+        List& self = CAST(List&, args[0]);
         std::reverse(self.begin(), self.end());
         return vm->None;
     });
 
     _vm->bind_method<1>("list", "__mul__", [](VM* vm, Args& args) {
-        const List& self = CAST(List, args[0]);
-        int n = (int)CAST_V(i64, args[1]);
+        const List& self = CAST(List&, args[0]);
+        int n = CAST(int, args[1]);
         List result;
         result.reserve(self.size() * n);
         for(int i = 0; i < n; i++) result.insert(result.end(), self.begin(), self.end());
@@ -417,8 +416,8 @@ void init_builtins(VM* _vm) {
     });
 
     _vm->bind_method<2>("list", "insert", [](VM* vm, Args& args) {
-        List& self = CAST(List, args[0]);
-        int index = (int)CAST_V(i64, args[1]);
+        List& self = CAST(List&, args[0]);
+        int index = CAST(int, args[1]);
         if(index < 0) index += self.size();
         if(index < 0) index = 0;
         if(index > self.size()) index = self.size();
@@ -427,22 +426,22 @@ void init_builtins(VM* _vm) {
     });
 
     _vm->bind_method<0>("list", "clear", [](VM* vm, Args& args) {
-        CAST(List, args[0]).clear();
+        CAST(List&, args[0]).clear();
         return vm->None;
     });
 
     _vm->bind_method<0>("list", "copy", CPP_LAMBDA(VAR(CAST(List, args[0]))));
 
     _vm->bind_method<1>("list", "__add__", [](VM* vm, Args& args) {
-        const List& self = CAST(List, args[0]);
-        const List& obj = CAST(List, args[1]);
+        const List& self = CAST(List&, args[0]);
+        const List& obj = CAST(List&, args[1]);
         List new_list = self;
         new_list.insert(new_list.end(), obj.begin(), obj.end());
         return VAR(new_list);
     });
 
     _vm->bind_method<0>("list", "__len__", [](VM* vm, Args& args) {
-        const List& self = CAST(List, args[0]);
+        const List& self = CAST(List&, args[0]);
         return VAR(self.size());
     });
 
@@ -451,32 +450,32 @@ void init_builtins(VM* _vm) {
     });
 
     _vm->bind_method<1>("list", "__getitem__", [](VM* vm, Args& args) {
-        const List& self = CAST(List, args[0]);
+        const List& self = CAST(List&, args[0]);
 
         if(is_type(args[1], vm->tp_slice)){
-            Slice s = _CAST_V(Slice, args[1]);
+            Slice s = _CAST(Slice, args[1]);
             s.normalize(self.size());
             List new_list;
             for(size_t i = s.start; i < s.stop; i++) new_list.push_back(self[i]);
             return VAR(std::move(new_list));
         }
 
-        int index = (int)CAST_V(i64, args[1]);
+        int index = CAST(int, args[1]);
         index = vm->normalized_index(index, self.size());
         return self[index];
     });
 
     _vm->bind_method<2>("list", "__setitem__", [](VM* vm, Args& args) {
-        List& self = CAST(List, args[0]);
-        int index = (int)CAST_V(i64, args[1]);
+        List& self = CAST(List&, args[0]);
+        int index = CAST(int, args[1]);
         index = vm->normalized_index(index, self.size());
         self[index] = args[2];
         return vm->None;
     });
 
     _vm->bind_method<1>("list", "__delitem__", [](VM* vm, Args& args) {
-        List& self = CAST(List, args[0]);
-        int index = (int)CAST_V(i64, args[1]);
+        List& self = CAST(List&, args[0]);
+        int index = CAST(int, args[1]);
         index = vm->normalized_index(index, self.size());
         self.erase(self.begin() + index);
         return vm->None;
@@ -493,23 +492,23 @@ void init_builtins(VM* _vm) {
     });
 
     _vm->bind_method<1>("tuple", "__getitem__", [](VM* vm, Args& args) {
-        const Tuple& self = CAST(Tuple, args[0]);
+        const Tuple& self = CAST(Tuple&, args[0]);
 
         if(is_type(args[1], vm->tp_slice)){
-            Slice s = _CAST_V(Slice, args[1]);
+            Slice s = _CAST(Slice, args[1]);
             s.normalize(self.size());
             List new_list;
             for(size_t i = s.start; i < s.stop; i++) new_list.push_back(self[i]);
             return VAR(std::move(new_list));
         }
 
-        int index = (int)CAST_V(i64, args[1]);
+        int index = CAST(int, args[1]);
         index = vm->normalized_index(index, self.size());
         return self[index];
     });
 
     _vm->bind_method<0>("tuple", "__len__", [](VM* vm, Args& args) {
-        const Tuple& self = CAST(Tuple, args[0]);
+        const Tuple& self = CAST(Tuple&, args[0]);
         return VAR(self.size());
     });
 
@@ -517,18 +516,18 @@ void init_builtins(VM* _vm) {
     _vm->bind_static_method<1>("bool", "__new__", CPP_LAMBDA(vm->asBool(args[0])));
 
     _vm->bind_method<0>("bool", "__repr__", [](VM* vm, Args& args) {
-        bool val = CAST_V(bool, args[0]);
+        bool val = CAST(bool, args[0]);
         return VAR(val ? "True" : "False");
     });
 
     _vm->bind_method<0>("bool", "__json__", [](VM* vm, Args& args) {
-        bool val = CAST_V(bool, args[0]);
+        bool val = CAST(bool, args[0]);
         return VAR(val ? "true" : "false");
     });
 
     _vm->bind_method<1>("bool", "__xor__", [](VM* vm, Args& args) {
-        bool self = CAST_V(bool, args[0]);
-        bool other = CAST_V(bool, args[1]);
+        bool self = CAST(bool, args[0]);
+        bool other = CAST(bool, args[1]);
         return VAR(self ^ other);
     });
 
@@ -563,7 +562,7 @@ void add_module_sys(VM* vm){
     vm->bind_func<0>(mod, "getrecursionlimit", CPP_LAMBDA(VAR(vm->recursionlimit)));
 
     vm->bind_func<1>(mod, "setrecursionlimit", [](VM* vm, Args& args) {
-        vm->recursionlimit = (int)CAST_V(i64, args[0]);
+        vm->recursionlimit = CAST(int, args[0]);
         return vm->None;
     });
 }
@@ -571,7 +570,7 @@ void add_module_sys(VM* vm){
 void add_module_json(VM* vm){
     PyVar mod = vm->new_module("json");
     vm->bind_func<1>(mod, "loads", [](VM* vm, Args& args) {
-        const Str& expr = CAST(Str, args[0]);
+        const Str& expr = CAST(Str&, args[0]);
         CodeObject_ code = vm->compile(expr, "<json>", JSON_MODE);
         return vm->_exec(code, vm->top_frame()->_module, vm->top_frame()->_locals);
     });
@@ -635,26 +634,26 @@ struct FileIO {
         });
 
         vm->bind_method<0>(type, "read", [](VM* vm, Args& args){
-            FileIO& io = 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 = CAST(FileIO, args[0]);
-            io._fs << CAST(Str, args[1]);
+            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 = 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 = CAST(FileIO, args[0]);
+            FileIO& io = CAST(FileIO&, args[0]);
             io._fs.close();
             return vm->None;
         });
@@ -682,17 +681,17 @@ 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(CAST(ReMatch, args[0]).start)));
-        vm->bind_method<0>(type, "end", CPP_LAMBDA(VAR(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 = 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 = CAST(ReMatch, args[0]);
-            int index = (int)CAST_V(i64, args[1]);
+            auto& self = CAST(ReMatch&, args[0]);
+            int index = CAST(int, args[1]);
             index = vm->normalized_index(index, self.m.size());
             return VAR(self.m[index].str());
         });
@@ -716,28 +715,28 @@ void add_module_re(VM* vm){
     ReMatch::register_class(vm, mod);
 
     vm->bind_func<2>(mod, "match", [](VM* vm, Args& args) {
-        const Str& pattern = CAST(Str, args[0]);
-        const Str& string = CAST(Str, args[1]);
+        const Str& pattern = CAST(Str&, args[0]);
+        const Str& string = CAST(Str&, args[1]);
         return _regex_search(pattern, string, true, vm);
     });
 
     vm->bind_func<2>(mod, "search", [](VM* vm, Args& args) {
-        const Str& pattern = CAST(Str, args[0]);
-        const Str& string = CAST(Str, args[1]);
+        const Str& pattern = CAST(Str&, args[0]);
+        const Str& string = CAST(Str&, args[1]);
         return _regex_search(pattern, string, false, vm);
     });
 
     vm->bind_func<3>(mod, "sub", [](VM* vm, Args& args) {
-        const Str& pattern = CAST(Str, args[0]);
-        const Str& repl = CAST(Str, args[1]);
-        const Str& string = CAST(Str, args[2]);
+        const Str& pattern = CAST(Str&, args[0]);
+        const Str& repl = CAST(Str&, args[1]);
+        const Str& string = CAST(Str&, args[2]);
         std::regex re(pattern);
         return VAR(std::regex_replace(string, re, repl));
     });
 
     vm->bind_func<2>(mod, "split", [](VM* vm, Args& args) {
-        const Str& pattern = CAST(Str, args[0]);
-        const Str& string = CAST(Str, args[1]);
+        const Str& pattern = CAST(Str&, args[0]);
+        const Str& string = CAST(Str&, args[1]);
         std::regex re(pattern);
         std::sregex_token_iterator it(string.begin(), string.end(), re, -1);
         std::sregex_token_iterator end;
@@ -753,21 +752,21 @@ void add_module_random(VM* vm){
     PyVar mod = vm->new_module("random");
     std::srand(std::time(0));
     vm->bind_func<1>(mod, "seed", [](VM* vm, Args& args) {
-        std::srand((unsigned int)CAST_V(i64, args[0]));
+        std::srand((unsigned int)CAST(i64, args[0]));
         return vm->None;
     });
 
     vm->bind_func<0>(mod, "random", CPP_LAMBDA(VAR(std::rand() / (f64)RAND_MAX)));
     vm->bind_func<2>(mod, "randint", [](VM* vm, Args& args) {
-        i64 a = CAST_V(i64, args[0]);
-        i64 b = CAST_V(i64, args[1]);
+        i64 a = CAST(i64, args[0]);
+        i64 b = CAST(i64, args[1]);
         if(a > b) std::swap(a, b);
         return VAR(a + std::rand() % (b - a + 1));
     });
 
     vm->bind_func<2>(mod, "uniform", [](VM* vm, Args& args) {
-        f64 a = CAST_V(f64, args[0]);
-        f64 b = CAST_V(f64, args[1]);
+        f64 a = CAST(f64, args[0]);
+        f64 b = CAST(f64, args[1]);
         if(a > b) std::swap(a, b);
         return VAR(a + (b - a) * std::rand() / (f64)RAND_MAX);
     });
@@ -866,8 +865,8 @@ extern "C" {
         pkpy::PyVar* val = vm->_main->attr().try_get(name);
         if(val == nullptr) return nullptr;
         try{
-            pkpy::Str& _repr = pkpy::CAST(pkpy::Str, vm->asRepr(*val));
-            return strdup(_repr.c_str());
+            pkpy::Str repr = pkpy::CAST(pkpy::Str, vm->asRepr(*val));
+            return strdup(repr.c_str());
         }catch(...){
             return nullptr;
         }
@@ -882,8 +881,8 @@ extern "C" {
         pkpy::PyVarOrNull ret = vm->exec(source, "<eval>", pkpy::EVAL_MODE);
         if(ret == nullptr) return nullptr;
         try{
-            pkpy::Str& _repr = pkpy::CAST(pkpy::Str, vm->asRepr(ret));
-            return strdup(_repr.c_str());
+            pkpy::Str repr = pkpy::CAST(pkpy::Str, vm->asRepr(ret));
+            return strdup(repr.c_str());
         }catch(...){
             return nullptr;
         }
@@ -969,7 +968,7 @@ extern "C" {
             for(int i=0; i<args.size(); i++){
                 ss << ' ';
                 pkpy::PyVar x = vm->call(args[i], pkpy::__json__);
-                ss << pkpy::CAST(pkpy::Str, x);
+                ss << pkpy::CAST(pkpy::Str&, x);
             }
             char* packet = strdup(ss.str().c_str());
             switch(ret_code){

src/ref.h

@@ -127,7 +127,7 @@ struct TupleRef : BaseRef {
         for(int i=0; i<objs.size(); i++){
             PyVarOrNull x;
             if(is_type(objs[i], vm->tp_star_wrapper)){
-                auto& star = _CAST(StarWrapper, objs[i]);
+                auto& star = _CAST(StarWrapper&, objs[i]);
                 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");
                 auto ref = vm->PyRef_AS_C(star.obj);
@@ -153,7 +153,7 @@ struct TupleRef : BaseRef {
 
 template<typename P>
 PyVarRef VM::PyRef(P&& value) {
-    static_assert(std::is_base_of_v<BaseRef, RAW(P)>);
+    static_assert(std::is_base_of_v<BaseRef, std::decay_t<P>>);
     return new_object(tp_ref, std::forward<P>(value));
 }
 

src/test.cpp

@@ -0,0 +1,18 @@
+#include "cffi.h"
+#include "pocketpy.h"
+
+using namespace pkpy;
+
+double add(int a, double b){
+    return a + b;
+}
+
+int main(){
+    VM* vm = pkpy_new_vm(true);
+
+    vm->bind_builtin_func<2>("add", ProxyFunction(&add));
+    pkpy_vm_exec(vm, "print( add(1, 2.0) )");
+
+    pkpy_delete(vm);
+    return 0;
+}

src/vm.h

@@ -6,18 +6,18 @@
 namespace pkpy{
 
 #define DEF_NATIVE_2(ctype, ptype)                                      \
-    template<> ctype& py_cast<ctype>(VM* vm, const PyVar& obj) {        \
+    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) {       \
+    template<> ctype _py_cast<ctype>(VM* vm, const PyVar& obj) {        \
         return OBJ_GET(ctype, obj);                                     \
     }                                                                   \
-    template<> ctype py_cast_v<ctype>(VM* vm, const PyVar& obj) {       \
+    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_v<ctype>(VM* vm, const PyVar& obj) {      \
+    template<> ctype& _py_cast<ctype&>(VM* vm, const PyVar& obj) {      \
         return OBJ_GET(ctype, obj);                                     \
     }                                                                   \
     PyVar py_var(VM* vm, const ctype& value) { return vm->new_object(vm->ptype, value);}     \
@@ -114,13 +114,13 @@ public:
     }
 
     template<typename ArgT>
-    inline std::enable_if_t<std::is_same_v<RAW(ArgT), Args>, PyVar>
+    inline std::enable_if_t<std::is_same_v<std::decay_t<ArgT>, Args>, PyVar>
     call(const PyVar& _callable, ArgT&& args){
         return call(_callable, std::forward<ArgT>(args), no_arg(), false);
     }
 
     template<typename ArgT>
-    inline std::enable_if_t<std::is_same_v<RAW(ArgT), Args>, PyVar>
+    inline std::enable_if_t<std::is_same_v<std::decay_t<ArgT>, Args>, PyVar>
     call(const PyVar& obj, const StrName name, ArgT&& args){
         return call(getattr(obj, name), std::forward<ArgT>(args), no_arg(), false);
     }
@@ -173,23 +173,23 @@ public:
 #ifdef PK_EXTRA_CHECK
         if(!is_type(type, tp_type)) UNREACHABLE();
 #endif
-        return make_sp<PyObject, Py_<RAW(T)>>(OBJ_GET(Type, type), _value);
+        return make_sp<PyObject, Py_<std::decay_t<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));
+        return make_sp<PyObject, Py_<std::decay_t<T>>>(OBJ_GET(Type, type), std::move(_value));
     }
 
     template<typename T>
     inline PyVar new_object(Type type, const T& _value) {
-        return make_sp<PyObject, Py_<RAW(T)>>(type, _value);
+        return make_sp<PyObject, Py_<std::decay_t<T>>>(type, _value);
     }
     template<typename T>
     inline PyVar new_object(Type type, T&& _value) {
-        return make_sp<PyObject, Py_<RAW(T)>>(type, std::move(_value));
+        return make_sp<PyObject, Py_<std::decay_t<T>>>(type, std::move(_value));
     }
 
     template<int ARGC>
@@ -234,7 +234,7 @@ public:
 
     template<typename P>
     inline PyVar PyIter(P&& value) {
-        static_assert(std::is_base_of_v<BaseIter, RAW(P)>);
+        static_assert(std::is_base_of_v<BaseIter, std::decay_t<P>>);
         return new_object(tp_native_iterator, std::forward<P>(value));
     }
 
@@ -373,7 +373,7 @@ DEF_NATIVE_2(Exception, tp_exception)
 DEF_NATIVE_2(StarWrapper, tp_star_wrapper)
 
 template<typename T>
-std::enable_if_t<std::is_integral_v<T> && !std::is_same_v<RAW(T), bool>, PyVar> py_var(VM* vm, T _val){
+std::enable_if_t<std::is_integral_v<T> && !std::is_same_v<std::decay_t<T>, bool>, PyVar> py_var(VM* vm, T _val){
     i64 val = static_cast<i64>(_val);
     if(((val << 2) >> 2) != val){
         vm->_error("OverflowError", std::to_string(val) + " is out of range");
@@ -381,21 +381,28 @@ std::enable_if_t<std::is_integral_v<T> && !std::is_same_v<RAW(T), bool>, PyVar>
     val = (val << 2) | 0b01;
     return PyVar(reinterpret_cast<int*>(val));
 }
-template<> i64 py_cast_v<i64>(VM* vm, const PyVar& obj){
+template<> i64 py_cast<i64>(VM* vm, const PyVar& obj){
     vm->check_type(obj, vm->tp_int);
     return obj.bits >> 2;
 }
-template<> i64 _py_cast_v<i64>(VM* vm, const PyVar& obj){
+template<> i64 _py_cast<i64>(VM* vm, const PyVar& obj){
+    return obj.bits >> 2;
+}
+template<> int py_cast<int>(VM* vm, const PyVar& obj){
+    vm->check_type(obj, vm->tp_int);
+    return obj.bits >> 2;
+}
+template<> int _py_cast<int>(VM* vm, const PyVar& obj){
     return obj.bits >> 2;
 }
 
-template<> f64 py_cast_v<f64>(VM* vm, const PyVar& obj){
+template<> f64 py_cast<f64>(VM* vm, const PyVar& obj){
     vm->check_type(obj, vm->tp_float);
     i64 bits = obj.bits;
     bits = (bits >> 2) << 2;
     return __8B(bits)._float;
 }
-template<> f64 _py_cast_v<f64>(VM* vm, const PyVar& obj){
+template<> f64 _py_cast<f64>(VM* vm, const PyVar& obj){
     i64 bits = obj.bits;
     bits = (bits >> 2) << 2;
     return __8B(bits)._float;
@@ -414,11 +421,11 @@ const PyVar& py_var(VM* vm, bool val){
     return val ? vm->True : vm->False;
 }
 
-template<> bool py_cast_v<bool>(VM* vm, const PyVar& obj){
+template<> bool py_cast<bool>(VM* vm, const PyVar& obj){
     vm->check_type(obj, vm->tp_bool);
     return obj == vm->True;
 }
-template<> bool _py_cast_v<bool>(VM* vm, const PyVar& obj){
+template<> bool _py_cast<bool>(VM* vm, const PyVar& obj){
     return obj == vm->True;
 }
 
@@ -433,9 +440,9 @@ void _check_py_class(VM* vm, const PyVar& obj){
 
 PyVar VM::num_negated(const PyVar& obj){
     if (is_int(obj)){
-        return VAR(-CAST_V(i64, obj));
+        return VAR(-CAST(i64, obj));
     }else if(is_float(obj)){
-        return VAR(-CAST_V(f64, obj));
+        return VAR(-CAST(f64, obj));
     }
     TypeError("expected 'int' or 'float', got " + OBJ_NAME(_t(obj)).escape(true));
     return nullptr;
@@ -443,9 +450,9 @@ PyVar VM::num_negated(const PyVar& obj){
 
 f64 VM::num_to_float(const PyVar& obj){
     if(is_float(obj)){
-        return CAST_V(f64, obj);
+        return CAST(f64, obj);
     } else if (is_int(obj)){
-        return (f64)CAST_V(i64, obj);
+        return (f64)CAST(i64, obj);
     }
     TypeError("expected 'int' or 'float', got " + OBJ_NAME(_t(obj)).escape(true));
     return 0;
@@ -454,22 +461,22 @@ f64 VM::num_to_float(const PyVar& obj){
 const PyVar& VM::asBool(const PyVar& obj){
     if(is_type(obj, tp_bool)) return obj;
     if(obj == None) return False;
-    if(is_type(obj, tp_int)) return VAR(CAST_V(i64, obj) != 0);
-    if(is_type(obj, tp_float)) return VAR(CAST_V(f64, obj) != 0.0);
+    if(is_type(obj, tp_int)) return VAR(CAST(i64, obj) != 0);
+    if(is_type(obj, tp_float)) return VAR(CAST(f64, obj) != 0.0);
     PyVarOrNull len_fn = getattr(obj, __len__, false);
     if(len_fn != nullptr){
         PyVar ret = call(len_fn);
-        return VAR(CAST_V(i64, ret) > 0);
+        return VAR(CAST(i64, ret) > 0);
     }
     return True;
 }
 
 i64 VM::hash(const PyVar& obj){
-    if (is_type(obj, tp_str)) return CAST(Str, obj).hash();
-    if (is_int(obj)) return CAST_V(i64, obj);
+    if (is_type(obj, tp_str)) return CAST(Str&, obj).hash();
+    if (is_int(obj)) return CAST(i64, obj);
     if (is_type(obj, tp_tuple)) {
         i64 x = 1000003;
-        const Tuple& items = CAST(Tuple, obj);
+        const Tuple& items = CAST(Tuple&, obj);
         for (int i=0; i<items.size(); i++) {
             i64 y = hash(items[i]);
             x = x ^ (y + 0x9e3779b9 + (x << 6) + (x >> 2)); // recommended by Github Copilot
@@ -477,9 +484,9 @@ i64 VM::hash(const PyVar& obj){
         return x;
     }
     if (is_type(obj, tp_type)) return obj.bits;
-    if (is_type(obj, tp_bool)) return _CAST_V(bool, obj) ? 1 : 0;
+    if (is_type(obj, tp_bool)) return _CAST(bool, obj) ? 1 : 0;
     if (is_float(obj)){
-        f64 val = CAST_V(f64, obj);
+        f64 val = CAST(f64, obj);
         return (i64)std::hash<f64>()(val);
     }
     TypeError("unhashable type: " +  OBJ_NAME(_t(obj)).escape(true));
@@ -572,7 +579,7 @@ Str VM::disassemble(CodeObject_ co){
     for(int i=0; i<co->consts.size(); i++){
         PyVar obj = co->consts[i];
         if(is_type(obj, tp_function)){
-            const auto& f = CAST(Function, obj);
+            const auto& f = CAST(Function&, obj);
             ss << disassemble(f.code);
         }
     }
@@ -652,7 +659,7 @@ PyVar VM::call(const PyVar& _callable, Args args, const Args& kwargs, bool opCal
 
     const PyVar* callable = &_callable;
     if(is_type(*callable, tp_bound_method)){
-        auto& bm = CAST(BoundMethod, *callable);
+        auto& bm = CAST(BoundMethod&, *callable);
         callable = &bm.method;      // get unbound method
         args.extend_self(bm.obj);
     }
@@ -662,7 +669,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");
         return f(this, args);
     } else if(is_type(*callable, tp_function)){
-        const Function& fn = CAST(Function, *callable);
+        const Function& fn = CAST(Function&, *callable);
         NameDict_ locals = make_sp<NameDict>(
             fn.code->perfect_locals_capacity,
             kLocalsLoadFactor,
@@ -696,7 +703,7 @@ PyVar VM::call(const PyVar& _callable, Args args, const Args& kwargs, bool opCal
         }
         
         for(int i=0; i<kwargs.size(); i+=2){
-            const Str& key = CAST(Str, kwargs[i]);
+            const Str& key = CAST(Str&, kwargs[i]);
             if(!fn.kwargs.contains(key)){
                 TypeError(key.escape(true) + " is an invalid keyword argument for " + fn.name.str() + "()");
             }
@@ -717,10 +724,10 @@ void VM::unpack_args(Args& args){
     List unpacked;
     for(int i=0; i<args.size(); i++){
         if(is_type(args[i], tp_star_wrapper)){
-            auto& star = _CAST(StarWrapper, args[i]);
+            auto& star = _CAST(StarWrapper&, args[i]);
             if(!star.rvalue) UNREACHABLE();
             PyVar list = asList(star.obj);
-            List& list_c = CAST(List, list);
+            List& list_c = CAST(List&, list);
             unpacked.insert(unpacked.end(), list_c.begin(), list_c.end());
         }else{
             unpacked.push_back(args[i]);
@@ -830,7 +837,7 @@ PyVar VM::_exec(){
             continue;
         }catch(UnhandledException& e){
             PyVar obj = frame->pop();
-            Exception& _e = CAST(Exception, obj);
+            Exception& _e = CAST(Exception&, obj);
             _e.st_push(frame->snapshot());
             callstack.pop();
             if(callstack.empty()) throw _e;

tests/_c.py

@@ -1,12 +0,0 @@
-from c import *
-
-p = malloc(10 * sizeof(int_))
-p = p.cast(int_)
-
-for i in range(10):
-    p[i] = i
-
-for i in range(10):
-    assert p[i] == i
-
-free(p)