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) accept ref as pointer (for the stubs, const& can be
# by value, but that does not work for the ffi path)
# 4) generalized cases (covers basically all user classes)
# 5) void converter, which fails on use
name = capi.c_resolve_name(space, name)
# 1) full, exact match
try:
return _converters[name](space, default)
except KeyError:
pass
# 1a) const-removed match
try:
return _converters[helper.remove_const(name)](space, default)
except KeyError:
pass
# 2) match of decorated, unqualified type
compound = helper.compound(name)
clean_name = capi.c_resolve_name(space, helper.clean_type(name))
try:
# array_index may be negative to indicate no size or no size found
array_size = helper.array_size(name)
return _a_converters[clean_name + compound](space, array_size)
except KeyError:
pass
# 3) TODO: accept ref as pointer
# 4) generalized cases (covers basically all user classes)
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_CPPClass
cppclass = space.interp_w(W_CPPClass, cppclass, can_be_None=False)
if compound == "*":
return InstancePtrConverter(space, cppclass)
elif compound == "&":
return InstanceRefConverter(space, cppclass)
elif compound == "**":
return InstancePtrPtrConverter(space, cppclass)
elif compound == "":
return InstanceConverter(space, cppclass)
elif capi.c_is_enum(space, clean_name):
return _converters['unsigned'](space, default)
# 5) void converter, which fails on use
#
# return a void converter here, so that the class can be build even
# when some types are unknown; this overload will simply fail on use
return VoidConverter(space, name)
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) accept ref as pointer (for the stubs, const& can be
# by value, but that does not work for the ffi path)
# 4) generalized cases (covers basically all user classes)
# 5) void converter, which fails on use
name = capi.c_resolve_name(space, name)
# 1) full, exact match
try:
return _converters[name](space, default)
except KeyError:
pass
# 1a) const-removed match
try:
return _converters[helper.remove_const(name)](space, default)
except KeyError:
pass
# 2) match of decorated, unqualified type
compound = helper.compound(name)
clean_name = capi.c_resolve_name(space, helper.clean_type(name))
try:
# array_index may be negative to indicate no size or no size found
array_size = helper.array_size(name)
return _a_converters[clean_name+compound](space, array_size)
except KeyError:
pass
# 3) TODO: accept ref as pointer
# 4) generalized cases (covers basically all user classes)
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_CPPClass
cppclass = space.interp_w(W_CPPClass, cppclass, can_be_None=False)
if compound == "*":
return InstancePtrConverter(space, cppclass)
elif compound == "&":
return InstanceRefConverter(space, cppclass)
elif compound == "**":
return InstancePtrPtrConverter(space, cppclass)
elif compound == "":
return InstanceConverter(space, cppclass)
elif capi.c_is_enum(space, clean_name):
return _converters['unsigned'](space, default)
# 5) void converter, which fails on use
#
# return a void converter here, so that the class can be build even
# when some types are unknown; this overload will simply fail on use
return VoidConverter(space, name)
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)
# 1) 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))
# 1a) clean lookup
try:
return _executors[clean_name + compound](space, None)
except KeyError:
pass
# 2) 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
# 3) 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_CPPClass
cppclass = space.interp_w(W_CPPClass, cppclass, can_be_None=False)
if compound == '':
return InstanceExecutor(space, cppclass)
elif compound == '*' or compound == '&':
return InstancePtrExecutor(space, cppclass)
elif compound == '**' or compound == '*&':
return InstancePtrPtrExecutor(space, cppclass)
elif capi.c_is_enum(space, clean_name):
return _executors['unsigned int'](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 FunctionExecutor(space, None)
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)
# 1) 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))
# 1a) clean lookup
try:
return _executors[clean_name+compound](space, None)
except KeyError:
pass
# 2) 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
# 3) 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_CPPClass
cppclass = space.interp_w(W_CPPClass, cppclass, can_be_None=False)
if compound == '':
return InstanceExecutor(space, cppclass)
elif compound == '*' or compound == '&':
return InstancePtrExecutor(space, cppclass)
elif compound == '**' or compound == '*&':
return InstancePtrPtrExecutor(space, cppclass)
elif capi.c_is_enum(space, clean_name):
return _executors['unsigned int'](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 FunctionExecutor(space, None)
def test_clean_type():
assert helper.clean_type(" int***") == "int"
assert helper.clean_type("int* const *&") == "int"
assert helper.clean_type("std::vector<int>&") == "std::vector<int>"
assert helper.clean_type("const std::vector<int>&") == "std::vector<int>"
assert helper.clean_type("std::vector<std::vector<int> >" ) == "std::vector<std::vector<int> >"
assert helper.clean_type("unsigned short int[3]") == "unsigned short int"
def test_clean_type():
assert helper.clean_type(" int***") == "int"
assert helper.clean_type("int* const *&") == "int"
assert helper.clean_type("std::vector<int>&") == "std::vector<int>"
assert helper.clean_type("const std::vector<int>&") == "std::vector<int>"
assert helper.clean_type("std::vector<std::vector<int> >" ) == "std::vector<std::vector<int> >"
assert helper.clean_type("unsigned short int[3]") == "unsigned short int"