def get_executor(space, name): # Matching of 'name' to an executor factory goes through up to four levels: # 1) full, qualified match # 2) drop '&': by-ref is pretty much the same as by-value, python-wise # 3) types/classes, either by ref/ptr or by value # 4) additional special cases # # If all fails, a default is used, which can be ignored at least until use. name = capi.c_resolve_name(space, name) # full, qualified match try: return _executors[name](space, None) except KeyError: pass compound = helper.compound(name) clean_name = capi.c_resolve_name(space, helper.clean_type(name)) # clean lookup try: return _executors[clean_name + compound](space, None) except KeyError: pass # drop '&': by-ref is pretty much the same as by-value, python-wise if compound and compound[len(compound) - 1] == '&': # TODO: this does not actually work with Reflex (?) try: return _executors[clean_name](space, None) except KeyError: pass # types/classes, either by ref/ptr or by value from pypy.module._cppyy import interp_cppyy cppclass = interp_cppyy.scope_byname(space, clean_name) if cppclass: # type check for the benefit of the annotator from pypy.module._cppyy.interp_cppyy import W_CPPClassDecl clsdecl = space.interp_w(W_CPPClassDecl, cppclass, can_be_None=False) # check smart pointer type check_smart = capi.c_smartptr_info(space, clean_name) if check_smart[0]: if compound == '': return SmartPointerExecutor(space, clsdecl, check_smart[1], check_smart[2]) elif compound == '*' or compound == '&': return SmartPointerPtrExecutor(space, clsdecl, check_smart[1], check_smart[2]) # fall through: can still return smart pointer in non-smart way if compound == '': return InstanceExecutor(space, clsdecl) elif compound == '*' or compound == '&': return InstancePtrExecutor(space, clsdecl) elif compound == '**' or compound == '*&': return InstancePtrPtrExecutor(space, clsdecl) elif "(anonymous)" in name: # special case: enum w/o a type name return _executors["internal_enum_type_t"](space, None) # 4) additional special cases if compound == '*': return _executors['void*']( space, None) # allow at least passing of the pointer # currently used until proper lazy instantiation available in interp_cppyy return Executor(space, None)
def get_converter(space, _name, default): # The matching of the name to a converter should follow: # 1) full, exact match # 1a) const-removed match # 2) match of decorated, unqualified type # 3) generalized cases (covers basically all user classes) # 3a) smart pointers # 4) void* or void converter (which fails on use) name = capi.c_resolve_name(space, _name) # full, exact match try: return _converters[name](space, default) except KeyError: pass # const-removed match try: return _converters[helper.remove_const(name)](space, default) except KeyError: pass # match of decorated, unqualified type cpd = helper.compound(name) clean_name = capi.c_resolve_name(space, helper.clean_type(name)) try: return _converters[clean_name+cpd](space, default) except KeyError: pass # arrays (array_size may be negative, meaning: no size or no size found) array_size = -1 if cpd == "[]": array_size = helper.array_size(_name) # uses original arg elif cpd == '*' and ':' in default: # this happens for multi-dimensional arrays: those are described as pointers cpd = "[]" splitpos = default.find(':') if 0 < splitpos: # always true, but needed for annotator array_size = int(default[:splitpos]) try: # TODO: using clean_name here drops const (e.g. const char[] will # never be seen this way) return _a_converters[clean_name+cpd](space, array_size) except KeyError: pass # generalized cases (covers basically all user classes) from pypy.module._cppyy import interp_cppyy scope_decl = interp_cppyy.scope_byname(space, clean_name) if scope_decl: from pypy.module._cppyy.interp_cppyy import W_CPPClassDecl clsdecl = space.interp_w(W_CPPClassDecl, scope_decl, can_be_None=False) # check smart pointer type check_smart = capi.c_smartptr_info(space, clean_name) if check_smart[0]: if cpd == '': return SmartPtrConverter(space, clsdecl, check_smart[1], check_smart[2]) elif cpd == '*': return SmartPtrPtrConverter(space, clsdecl, check_smart[1], check_smart[2]) elif cpd == '&': return SmartPtrRefConverter(space, clsdecl, check_smart[1], check_smart[2]) # fall through: can still return smart pointer in non-smart way # type check for the benefit of the annotator if cpd == "*": return InstancePtrConverter(space, clsdecl) elif cpd == "&": return InstanceRefConverter(space, clsdecl) elif cpd == "&&": return InstanceMoveConverter(space, clsdecl) elif cpd in ["**", "*[]", "&*"]: return InstancePtrPtrConverter(space, clsdecl) elif cpd == "[]" and array_size > 0: # default encodes the dimensions dims = default.split(':') return InstanceArrayConverter(space, clsdecl, array_size, dims) elif cpd == "": return InstanceConverter(space, clsdecl) elif "(anonymous)" in name: # special case: enum w/o a type name return _converters["internal_enum_type_t"](space, default) elif "(*)" in name or "::*)" in name: # function pointer pos = name.find("*)") if pos > 0: return FunctionPointerConverter(space, name[pos+2:]) # void* or void converter (which fails on use) if 0 <= cpd.find('*'): return VoidPtrConverter(space, default) # "user knows best" # return a void converter here, so that the class can be build even # when some types are unknown return VoidConverter(space, name) # fails on use