def __init__(self, method_name, wrapper_name, wrapper_body=None,
flags=('METH_VARARGS', 'METH_KEYWORDS')):
super(CustomCppMethodWrapper, self).__init__(method_name, ReturnValue.new('void'), [])
self.wrapper_base_name = wrapper_name
self.wrapper_actual_name = wrapper_name
self.meth_flags = list(flags)
self.wrapper_body = wrapper_body
def __init__(self, method_name, wrapper_name, wrapper_body=None,
flags=('METH_VARARGS', 'METH_KEYWORDS'), docstring=None):
super(CustomCppMethodWrapper, self).__init__(method_name, ReturnValue.new('void'), [], docstring=docstring)
self.wrapper_base_name = wrapper_name
self.wrapper_actual_name = wrapper_name
self.meth_flags = list(flags)
self.wrapper_body = wrapper_body
def try_wrapper(param, wrapper_number):
if 'const' in param.ctype and direction&Parameter.DIRECTION_OUT:
return
wrapper = MyReverseWrapper(ReturnValue.new('void'), [param])
try:
wrapper.generate(code_out,
'_test_wrapper_number_%i' % (wrapper_number,),
['static'])
except NotImplementedError:
print >> sys.stderr, ("ReverseWrapper void(%s) could not be generated: not implemented"
% (param.ctype))
print
def try_wrapper(param, wrapper_number):
if 'const' in param.ctype and direction&Parameter.DIRECTION_OUT:
return
wrapper = MyReverseWrapper(ReturnValue.new('void'), [param])
try:
wrapper.generate(code_out,
'_test_wrapper_number_%i' % (wrapper_number,),
['static'])
except NotImplementedError:
print >> sys.stderr, ("ReverseWrapper void(%s) could not be generated: not implemented"
% (param.ctype))
print
def try_wrapper(param, wrapper_number):
if 'const' in param.ctype and direction&Parameter.DIRECTION_OUT:
return
code_out.writeln("/* Test %s (%s) param type */" % (param_type, param_handler))
wrapper = MyReverseWrapper(ReturnValue.new('void'), [param])
try:
wrapper.generate(code_out,
'_test_wrapper_number_%i' % (wrapper_number,),
['static'])
except NotImplementedError:
sys.stderr.write("ReverseWrapper void(%s) could not be generated: not implemented"
% (param.ctype))
sys.stdout.write("\n")
def try_wrapper(param, wrapper_number):
if 'const' in param.ctype and direction&Parameter.DIRECTION_OUT:
return
code_out.writeln("/* Test %s (%s) param type */" % (param_type, param_handler))
wrapper = MyReverseWrapper(ReturnValue.new('void'), [param])
try:
wrapper.generate(code_out,
'_test_wrapper_number_%i' % (wrapper_number,),
['static'])
except NotImplementedError:
sys.stderr.write("ReverseWrapper void(%s) could not be generated: not implemented"
% (param.ctype))
sys.stdout.write("\n")
def __init__(self, function_name, wrapper_name, wrapper_body=None,
flags=('METH_VARARGS', 'METH_KEYWORDS'), docstring=None):
"""
:param function_name: name for function, Python side
:param wrapper_name: name of the C wrapper function
:param wrapper_body: if not None, the function wrapper is generated containing this parameter value as function body
"""
super(CustomFunctionWrapper, self).__init__(function_name, ReturnValue.new('void'), [], docstring=docstring)
self.wrapper_base_name = wrapper_name
self.wrapper_actual_name = wrapper_name
self.meth_flags = list(flags)
self.wrapper_body = wrapper_body
self.wrapper_args = ["PyObject *args", "PyObject *kwargs", "PyObject **return_exception"]
self.wrapper_return = "PyObject *"
def __init__(self, function_name, wrapper_name, wrapper_body=None,
flags=('METH_VARARGS', 'METH_KEYWORDS'), docstring=None):
"""
:param function_name: name for function, Python side
:param wrapper_name: name of the C wrapper function
:param wrapper_body: if not None, the function wrapper is generated containing this parameter value as function body
"""
super(CustomFunctionWrapper, self).__init__(function_name, ReturnValue.new('void'), [], docstring=docstring)
self.wrapper_base_name = wrapper_name
self.wrapper_actual_name = wrapper_name
self.meth_flags = list(flags)
self.wrapper_body = wrapper_body
self.wrapper_args = ["PyObject *args", "PyObject *kwargs", "PyObject **return_exception"]
self.wrapper_return = "PyObject *"
def __init__(self, method_name, return_value, parameters, is_static=False,
template_parameters=(), is_virtual=None, is_const=False,
unblock_threads=None, is_pure_virtual=False,
custom_template_method_name=None, visibility='public',
custom_name=None, deprecated=False, docstring=None, throw=()):
"""
Create an object the generates code to wrap a C++ class method.
:param return_value: the method return value
:type return_value: L{ReturnValue}
:param method_name: name of the method
:param parameters: the method parameters
:type parameters: list of :class:`pybindgen.typehandlers.base.Parameter`
:param is_static: whether it is a static method
:param template_parameters: optional list of template parameters needed to invoke the method
:type template_parameters: list of strings, each element a template parameter expression
:param is_virtual: whether the method is virtual (pure or not)
:param is_const: whether the method has a const modifier on it
:param unblock_threads: whether to release the Python GIL
around the method call or not. If None or omitted, use
global settings. Releasing the GIL has a small
performance penalty, but is recommended if the method is
expected to take considerable time to complete, because
otherwise no other Python thread is allowed to run until
the method completes.
:param is_pure_virtual: whether the method is defined as "pure
virtual", i.e. virtual method with no default implementation
in the class being wrapped.
:param custom_name: alternate name to give to the method, in python side.
:param custom_template_method_name: (deprecated) same as parameter 'custom_name'.
:param visibility: visibility of the method within the C++ class
:type visibility: a string (allowed values are 'public', 'protected', 'private')
:param deprecated: deprecation state for this API:
- False: Not deprecated
- True: Deprecated
- "message": Deprecated, and deprecation warning contains the given message
:param throw: list of C++ exceptions that the function may throw
:type throw: list of L{CppException}
"""
self.stack_where_defined = traceback.extract_stack()
## backward compatibility check
if isinstance(return_value, str) and isinstance(method_name, ReturnValue):
warnings.warn("CppMethod has changed API; see the API documentation (but trying to correct...)",
DeprecationWarning, stacklevel=2)
method_name, return_value = return_value, method_name
# bug 399870
if is_virtual is None:
is_virtual = is_pure_virtual
if return_value is None:
return_value = ReturnValue.new('void')
if unblock_threads is None:
unblock_threads = settings.unblock_threads
assert visibility in ['public', 'protected', 'private']
self.visibility = visibility
self.method_name = method_name
self.is_static = is_static
self.is_virtual = is_virtual
self.is_pure_virtual = is_pure_virtual
self.is_const = is_const
self.template_parameters = template_parameters
self.custom_name = (custom_name or custom_template_method_name)
#self.static_decl = True
self._class = None
self._helper_class = None
self.docstring = docstring
self.wrapper_base_name = None
self.wrapper_actual_name = None
self.return_value = None
self.parameters = None
return_value = utils.eval_retval(return_value, self)
parameters = [utils.eval_param(param, self) for param in parameters]
super(CppMethod, self).__init__(
return_value, parameters,
"return NULL;", "return NULL;",
unblock_threads=unblock_threads)
self.deprecated = deprecated
for t in throw:
assert isinstance(t, CppException)
self.throw = list(throw)
self.custodians_and_wards = [] # list of (custodian, ward, postcall)
from . import cppclass
cppclass.scan_custodians_and_wards(self)
def __init__(self, method_name, return_value, parameters, is_static=False,
template_parameters=(), is_virtual=None, is_const=False,
unblock_threads=None, is_pure_virtual=False,
custom_template_method_name=None, visibility='public',
custom_name=None, deprecated=False, docstring=None, throw=()):
"""
Create an object the generates code to wrap a C++ class method.
:param return_value: the method return value
:type return_value: L{ReturnValue}
:param method_name: name of the method
:param parameters: the method parameters
:type parameters: list of :class:`pybindgen.typehandlers.base.Parameter`
:param is_static: whether it is a static method
:param template_parameters: optional list of template parameters needed to invoke the method
:type template_parameters: list of strings, each element a template parameter expression
:param is_virtual: whether the method is virtual (pure or not)
:param is_const: whether the method has a const modifier on it
:param unblock_threads: whether to release the Python GIL
around the method call or not. If None or omitted, use
global settings. Releasing the GIL has a small
performance penalty, but is recommended if the method is
expected to take considerable time to complete, because
otherwise no other Python thread is allowed to run until
the method completes.
:param is_pure_virtual: whether the method is defined as "pure
virtual", i.e. virtual method with no default implementation
in the class being wrapped.
:param custom_name: alternate name to give to the method, in python side.
:param custom_template_method_name: (deprecated) same as parameter 'custom_name'.
:param visibility: visibility of the method within the C++ class
:type visibility: a string (allowed values are 'public', 'protected', 'private')
:param deprecated: deprecation state for this API:
- False: Not deprecated
- True: Deprecated
- "message": Deprecated, and deprecation warning contains the given message
:param throw: list of C++ exceptions that the function may throw
:type throw: list of L{CppException}
"""
self.stack_where_defined = traceback.extract_stack()
## backward compatibility check
if isinstance(return_value, str) and isinstance(method_name, ReturnValue):
warnings.warn("CppMethod has changed API; see the API documentation (but trying to correct...)",
DeprecationWarning, stacklevel=2)
method_name, return_value = return_value, method_name
# bug 399870
if is_virtual is None:
is_virtual = is_pure_virtual
if return_value is None:
return_value = ReturnValue.new('void')
if unblock_threads is None:
unblock_threads = settings.unblock_threads
assert visibility in ['public', 'protected', 'private']
self.visibility = visibility
self.method_name = method_name
self.is_static = is_static
self.is_virtual = is_virtual
self.is_pure_virtual = is_pure_virtual
self.is_const = is_const
self.template_parameters = template_parameters
self.custom_name = (custom_name or custom_template_method_name)
#self.static_decl = True
self._class = None
self._helper_class = None
self.docstring = docstring
self.wrapper_base_name = None
self.wrapper_actual_name = None
self.return_value = None
self.parameters = None
return_value = utils.eval_retval(return_value, self)
parameters = [utils.eval_param(param, self) for param in parameters]
super(CppMethod, self).__init__(
return_value, parameters,
"return NULL;", "return NULL;",
unblock_threads=unblock_threads)
self.deprecated = deprecated
for t in throw:
assert isinstance(t, CppException)
self.throw = list(throw)
self.custodians_and_wards = [] # list of (custodian, ward, postcall)
from . import cppclass
cppclass.scan_custodians_and_wards(self)
def __init__(self,
function_name,
return_value,
parameters,
docstring=None,
unblock_threads=None,
template_parameters=(),
custom_name=None,
deprecated=False,
foreign_cpp_namespace=None,
throw=()):
"""
:param function_name: name of the C function
:param return_value: the function return value
:type return_value: L{ReturnValue}
:param parameters: the function parameters
:type parameters: list of L{Parameter}
:param custom_name: an alternative name to give to this
function at python-side; if omitted, the name of the
function in the python module will be the same name as the
function in C++ (minus namespace).
:param deprecated: deprecation state for this API:
- False: Not deprecated
- True: Deprecated
- "message": Deprecated, and deprecation warning contains the given message
:param foreign_cpp_namespace: if set, the function is assumed
to belong to the given C++ namespace, regardless of the C++
namespace of the python module it will be added to.
:param throw: list of C++ exceptions that the function may throw
:type throw: list of L{CppException}
"""
self.stack_where_defined = traceback.extract_stack()
if unblock_threads is None:
unblock_threads = settings.unblock_threads
## backward compatibility check
if isinstance(return_value, string_types) and isinstance(
function_name, ReturnValue):
warnings.warn(
"Function has changed API; see the API documentation (but trying to correct...)",
DeprecationWarning,
stacklevel=2)
function_name, return_value = return_value, function_name
if return_value is None:
return_value = ReturnValue.new('void')
return_value = utils.eval_retval(return_value, self)
parameters = [utils.eval_param(param, self) for param in parameters]
super(Function, self).__init__(return_value,
parameters,
parse_error_return="return NULL;",
error_return="return NULL;",
unblock_threads=unblock_threads)
self.deprecated = deprecated
self.foreign_cpp_namespace = foreign_cpp_namespace
self._module = None
function_name = utils.ascii(function_name)
self.function_name = function_name
self.wrapper_base_name = None
self.wrapper_actual_name = None
self.docstring = docstring
self.self_parameter_pystruct = None
self.template_parameters = template_parameters
self.custom_name = custom_name
for t in throw:
assert isinstance(t, CppException)
self.throw = list(throw)
self.custodians_and_wards = [] # list of (custodian, ward, postcall)
from pybindgen import cppclass
cppclass.scan_custodians_and_wards(self)
def test():
code_out = codesink.FileCodeSink(sys.stdout)
pybindgen.write_preamble(code_out)
print
print "#include <string>"
print "#include <stdint.h>"
print
## Declare a dummy class
sys.stdout.write('''
class Foo
{
std::string m_datum;
public:
Foo () : m_datum ("")
{}
Foo (std::string datum) : m_datum (datum)
{}
std::string get_datum () const { return m_datum; }
Foo (Foo const & other) : m_datum (other.get_datum ())
{}
};
''')
module = Module("foo")
## Register type handlers for the class
Foo = cppclass.CppClass('Foo')
Foo.module = module
#Foo.full_name = Foo.name # normally adding the class to a module would take care of this
Foo.generate_forward_declarations(code_out, module)
wrapper_number = 0
## test return type handlers of reverse wrappers
for return_type, return_handler in typehandlers.base.return_type_matcher.items(
):
if os.name == 'nt':
if stdint_rx.search(return_type):
continue # win32 does not support the u?int\d+_t types (defined in <stdint.h>)
if issubclass(return_handler,
(cppclass.CppClassPtrReturnValue,
typehandlers.pyobjecttype.PyObjectReturnValue)):
for caller_owns_return in True, False:
retval = return_handler(return_type,
caller_owns_return=caller_owns_return)
wrapper = MyReverseWrapper(retval, [])
wrapper_number += 1
try:
wrapper.generate(
code_out,
'_test_wrapper_number_%i' % (wrapper_number, ),
['static'])
except NotImplementedError:
print >> sys.stderr, \
("ReverseWrapper %s(void) (caller_owns_return=%r)"
" could not be generated: not implemented"
% (retval.ctype, caller_owns_return))
print
else:
retval = return_handler(return_type)
try:
wrapper = MyReverseWrapper(retval, [])
except NotSupportedError:
continue
wrapper_number += 1
try:
wrapper.generate(
code_out, '_test_wrapper_number_%i' % (wrapper_number, ),
['static'])
except NotImplementedError:
print >> sys.stderr, (
"ReverseWrapper %s(void) could not be generated: not implemented"
% (retval.ctype, ))
print
## test parameter type handlers of reverse wrappers
for param_type, param_handler in typehandlers.base.param_type_matcher.items(
):
if os.name == 'nt':
if stdint_rx.search(param_type):
continue # win32 does not support the u?int\d+_t types (defined in <stdint.h>)
for direction in param_handler.DIRECTIONS:
if direction == (Parameter.DIRECTION_IN):
param_name = 'param'
elif direction == (Parameter.DIRECTION_IN
| Parameter.DIRECTION_OUT):
param_name = 'param_inout'
elif direction == (Parameter.DIRECTION_OUT):
param_name = 'param_out'
def try_wrapper(param, wrapper_number):
if 'const' in param.ctype and direction & Parameter.DIRECTION_OUT:
return
wrapper = MyReverseWrapper(ReturnValue.new('void'),
[param])
try:
wrapper.generate(
code_out,
'_test_wrapper_number_%i' % (wrapper_number, ),
['static'])
except NotImplementedError:
print >> sys.stderr, (
"ReverseWrapper void(%s) could not be generated: not implemented"
% (param.ctype))
print
if issubclass(param_handler,
(cppclass.CppClassPtrParameter,
typehandlers.pyobjecttype.PyObjectParam)):
for transfer_ownership in True, False:
try:
param = param_handler(
param_type,
param_name,
transfer_ownership=transfer_ownership)
except TypeError:
print >> sys.stderr, "ERROR -----> param_handler(param_type=%r, "\
"transfer_ownership=%r, is_const=%r)"\
% (param_type, transfer_ownership, is_const)
wrapper_number += 1
try_wrapper(param, wrapper_number)
else:
param = param_handler(param_type, param_name, direction)
wrapper_number += 1
try_wrapper(param, wrapper_number)
## test generic forward wrappers, and module
for return_type, return_handler in typehandlers.base.return_type_matcher.items(
):
if os.name == 'nt':
if stdint_rx.search(return_type):
continue # win32 does not support the u?int\d+_t types (defined in <stdint.h>)
wrapper_number += 1
function_name = 'foo_function_%i' % (wrapper_number, )
## declare a fake prototype
print "%s %s(void);" % (return_type, function_name)
print
if issubclass(return_handler,
(cppclass.CppClassPtrReturnValue,
typehandlers.pyobjecttype.PyObjectReturnValue)):
retval = return_handler(return_type, caller_owns_return=True)
else:
retval = return_handler(return_type)
module.add_function(function_name, retval, [])
for param_type, param_handler in typehandlers.base.param_type_matcher.items(
):
if os.name == 'nt':
if stdint_rx.search(param_type):
continue # win32 does not support the u?int\d+_t types (defined in <stdint.h>)
for is_const in [True, False]:
for direction in param_handler.DIRECTIONS:
if direction == (Parameter.DIRECTION_IN):
param_name = 'param'
elif direction == (Parameter.DIRECTION_IN
| Parameter.DIRECTION_OUT):
param_name = 'param_inout'
elif direction == (Parameter.DIRECTION_OUT):
param_name = 'param_out'
if is_const and direction & Parameter.DIRECTION_OUT:
continue # const and output parameter makes no sense
if is_const:
if '&' in param_type: # const references not allowed
continue
param_type_with_const = "const %s" % (param_type, )
else:
param_type_with_const = param_type
if issubclass(param_handler,
(cppclass.CppClassPtrParameter,
typehandlers.pyobjecttype.PyObjectParam)):
for transfer_ownership in True, False:
name = param_name + (transfer_ownership and '_transfer'
or '_notransfer')
try:
param = param_handler(
param_type,
name,
transfer_ownership=transfer_ownership)
except TypeError:
print >> sys.stderr, "ERROR -----> param_handler(param_type=%r, "\
"name=%r, transfer_ownership=%r, is_const=%r)"\
% (param_type, name, transfer_ownership, is_const)
wrapper_number += 1
function_name = 'foo_function_%i' % (wrapper_number, )
## declare a fake prototype
print "void %s(%s %s);" % (function_name,
param_type_with_const, name)
print
module.add_function(function_name,
ReturnValue.new('void'), [param])
else:
param = param_handler(param_type, param_name, direction)
wrapper_number += 1
function_name = 'foo_function_%i' % (wrapper_number, )
## declare a fake prototype
print "void %s(%s);" % (function_name,
param_type_with_const)
print
module.add_function(function_name, ReturnValue.new('void'),
[param])
module.generate(code_out)
def __init__(self, function_name, return_value, parameters, docstring=None, unblock_threads=None,
template_parameters=(), custom_name=None, deprecated=False, foreign_cpp_namespace=None,
throw=()):
"""
:param function_name: name of the C function
:param return_value: the function return value
:type return_value: L{ReturnValue}
:param parameters: the function parameters
:type parameters: list of L{Parameter}
:param custom_name: an alternative name to give to this
function at python-side; if omitted, the name of the
function in the python module will be the same name as the
function in C++ (minus namespace).
:param deprecated: deprecation state for this API:
- False: Not deprecated
- True: Deprecated
- "message": Deprecated, and deprecation warning contains the given message
:param foreign_cpp_namespace: if set, the function is assumed
to belong to the given C++ namespace, regardless of the C++
namespace of the python module it will be added to.
:param throw: list of C++ exceptions that the function may throw
:type throw: list of L{CppException}
"""
self.stack_where_defined = traceback.extract_stack()
if unblock_threads is None:
unblock_threads = settings.unblock_threads
## backward compatibility check
if isinstance(return_value, string_types) and isinstance(function_name, ReturnValue):
warnings.warn("Function has changed API; see the API documentation (but trying to correct...)",
DeprecationWarning, stacklevel=2)
function_name, return_value = return_value, function_name
if return_value is None:
return_value = ReturnValue.new('void')
return_value = utils.eval_retval(return_value, self)
parameters = [utils.eval_param(param, self) for param in parameters]
super(Function, self).__init__(
return_value, parameters,
parse_error_return="return NULL;",
error_return="return NULL;",
unblock_threads=unblock_threads)
self.deprecated = deprecated
self.foreign_cpp_namespace = foreign_cpp_namespace
self._module = None
function_name = utils.ascii(function_name)
self.function_name = function_name
self.wrapper_base_name = None
self.wrapper_actual_name = None
self.docstring = docstring
self.self_parameter_pystruct = None
self.template_parameters = template_parameters
self.custom_name = custom_name
for t in throw:
assert isinstance(t, CppException)
self.throw = list(throw)
self.custodians_and_wards = [] # list of (custodian, ward, postcall)
from pybindgen import cppclass
cppclass.scan_custodians_and_wards(self)
def test():
code_out = codesink.FileCodeSink(sys.stdout)
pybindgen.write_preamble(code_out)
sys.stdout.write("""
#include <string>
#include <stdint.h>
""")
## Declare a dummy class
sys.stdout.write('''
class Foo
{
std::string m_datum;
public:
Foo () : m_datum ("")
{}
Foo (std::string datum) : m_datum (datum)
{}
std::string get_datum () const { return m_datum; }
Foo (Foo const & other) : m_datum (other.get_datum ())
{}
};
''')
module = Module("foo")
## Register type handlers for the class
Foo = cppclass.CppClass('Foo')
Foo.module = module
#Foo.full_name = Foo.name # normally adding the class to a module would take care of this
Foo.generate_forward_declarations(code_out, module)
wrapper_number = 0
## test return type handlers of reverse wrappers
for return_type, return_handler in list(typehandlers.base.return_type_matcher.items()):
if type_blacklisted(return_type):
continue
if os.name == 'nt':
if stdint_rx.search(return_type):
continue # win32 does not support the u?int\d+_t types (defined in <stdint.h>)
code_out.writeln("/* Test %s (%s) return type */" % (return_type, return_handler))
if issubclass(return_handler, (cppclass.CppClassPtrReturnValue,
typehandlers.pyobjecttype.PyObjectReturnValue)):
for caller_owns_return in True, False:
retval = return_handler(return_type, caller_owns_return=caller_owns_return)
wrapper = MyReverseWrapper(retval, [])
wrapper_number += 1
try:
wrapper.generate(code_out,
'_test_wrapper_number_%i' % (wrapper_number,),
['static'])
except NotImplementedError:
sys.stderr.write("ReverseWrapper %s(void) (caller_owns_return=%r)"
" could not be generated: not implemented\n"
% (retval.ctype, caller_owns_return))
sys.stdout.write("\n")
else:
retval = return_handler(return_type)
try:
wrapper = MyReverseWrapper(retval, [])
except NotSupportedError:
continue
except NotImplementedError:
sys.stderr.write("ReverseWrapper %s(void) could not be generated: not implemented\n"
% (retval.ctype))
continue
wrapper_number += 1
memsink = codesink.MemoryCodeSink()
try:
wrapper.generate(memsink,
'_test_wrapper_number_%i' % (wrapper_number,),
['static'])
except NotImplementedError:
sys.stderr.write("ReverseWrapper %s xxx (void) could not be generated: not implemented\n"
% (retval.ctype,))
continue
except NotSupportedError:
continue
else:
memsink.flush_to(code_out)
sys.stdout.write("\n")
## test parameter type handlers of reverse wrappers
for param_type, param_handler in list(typehandlers.base.param_type_matcher.items()):
if type_blacklisted(param_type):
continue
if os.name == 'nt':
if stdint_rx.search(param_type):
continue # win32 does not support the u?int\d+_t types (defined in <stdint.h>)
for direction in param_handler.DIRECTIONS:
if direction == (Parameter.DIRECTION_IN):
param_name = 'param'
elif direction == (Parameter.DIRECTION_IN|Parameter.DIRECTION_OUT):
param_name = 'param_inout'
elif direction == (Parameter.DIRECTION_OUT):
param_name = 'param_out'
def try_wrapper(param, wrapper_number):
if 'const' in param.ctype and direction&Parameter.DIRECTION_OUT:
return
code_out.writeln("/* Test %s (%s) param type */" % (param_type, param_handler))
wrapper = MyReverseWrapper(ReturnValue.new('void'), [param])
try:
wrapper.generate(code_out,
'_test_wrapper_number_%i' % (wrapper_number,),
['static'])
except NotImplementedError:
sys.stderr.write("ReverseWrapper void(%s) could not be generated: not implemented"
% (param.ctype))
sys.stdout.write("\n")
if issubclass(param_handler, (cppclass.CppClassPtrParameter,
typehandlers.pyobjecttype.PyObjectParam)):
for transfer_ownership in True, False:
try:
param = param_handler(param_type, param_name, transfer_ownership=transfer_ownership)
except TypeError:
sys.stderr.write("ERROR -----> param_handler(param_type=%r, "
"transfer_ownership=%r, is_const=%r)\n"
% (param_type, transfer_ownership, is_const))
wrapper_number += 1
try_wrapper(param, wrapper_number)
else:
param = param_handler(param_type, param_name, direction)
wrapper_number += 1
try_wrapper(param, wrapper_number)
## test generic forward wrappers, and module
for return_type, return_handler in list(typehandlers.base.return_type_matcher.items()):
if type_blacklisted(return_type):
continue
if os.name == 'nt':
if stdint_rx.search(return_type):
continue # win32 does not support the u?int\d+_t types (defined in <stdint.h>)
wrapper_number += 1
function_name = 'foo_function_%i' % (wrapper_number,)
## declare a fake prototype
sys.stdout.write("%s %s(void);\n\n" % (return_type, function_name))
if issubclass(return_handler, (cppclass.CppClassPtrReturnValue,
typehandlers.pyobjecttype.PyObjectReturnValue)):
retval = return_handler(return_type, caller_owns_return=True)
else:
retval = return_handler(return_type)
module.add_function(function_name, retval, [])
for param_type, param_handler in list(typehandlers.base.param_type_matcher.items()):
if type_blacklisted(param_type):
continue
if os.name == 'nt':
if stdint_rx.search(param_type):
continue # win32 does not support the u?int\d+_t types (defined in <stdint.h>)
for is_const in [True, False]:
for direction in param_handler.DIRECTIONS:
if direction == (Parameter.DIRECTION_IN):
param_name = 'param'
elif direction == (Parameter.DIRECTION_IN|Parameter.DIRECTION_OUT):
param_name = 'param_inout'
elif direction == (Parameter.DIRECTION_OUT):
param_name = 'param_out'
if is_const and direction & Parameter.DIRECTION_OUT:
continue # const and output parameter makes no sense
if is_const:
if '&' in param_type: # const references not allowed
continue
param_type_with_const = "const %s" % (param_type,)
else:
param_type_with_const = param_type
if issubclass(param_handler, (cppclass.CppClassPtrParameter,
typehandlers.pyobjecttype.PyObjectParam)):
for transfer_ownership in True, False:
name = param_name + (transfer_ownership and '_transfer' or '_notransfer')
try:
param = param_handler(param_type, name, transfer_ownership=transfer_ownership)
except TypeError:
sys.stderr.write("ERROR -----> param_handler(param_type=%r, "
"name=%r, transfer_ownership=%r, is_const=%r)\n"
% (param_type, name, transfer_ownership, is_const))
wrapper_number += 1
function_name = 'foo_function_%i' % (wrapper_number,)
## declare a fake prototype
sys.stdout.write("void %s(%s %s);\n\n" % (function_name, param_type_with_const, name))
module.add_function(function_name, ReturnValue.new('void'), [param])
else:
param = param_handler(param_type, param_name, direction)
wrapper_number += 1
function_name = 'foo_function_%i' % (wrapper_number,)
## declare a fake prototype
sys.stdout.write("void %s(%s);\n\n" % (function_name, param_type_with_const))
module.add_function(function_name, ReturnValue.new('void'), [param])
module.generate(code_out)
def test():
code_out = codesink.FileCodeSink(sys.stdout)
pybindgen.write_preamble(code_out)
print
print "#include <string>"
print "#include <stdint.h>"
print
## Declare a dummy class
sys.stdout.write(
"""
class Foo
{
std::string m_datum;
public:
Foo () : m_datum ("")
{}
Foo (std::string datum) : m_datum (datum)
{}
std::string get_datum () const { return m_datum; }
Foo (Foo const & other) : m_datum (other.get_datum ())
{}
};
"""
)
module = Module("foo")
## Register type handlers for the class
Foo = cppclass.CppClass("Foo")
Foo.module = module
# Foo.full_name = Foo.name # normally adding the class to a module would take care of this
Foo.generate_forward_declarations(code_out, module)
wrapper_number = 0
## test return type handlers of reverse wrappers
for return_type, return_handler in typehandlers.base.return_type_matcher.items():
if os.name == "nt":
if stdint_rx.search(return_type):
continue # win32 does not support the u?int\d+_t types (defined in <stdint.h>)
if issubclass(return_handler, (cppclass.CppClassPtrReturnValue, typehandlers.pyobjecttype.PyObjectReturnValue)):
for caller_owns_return in True, False:
retval = return_handler(return_type, caller_owns_return=caller_owns_return)
wrapper = MyReverseWrapper(retval, [])
wrapper_number += 1
try:
wrapper.generate(code_out, "_test_wrapper_number_%i" % (wrapper_number,), ["static"])
except NotImplementedError:
print >> sys.stderr, (
"ReverseWrapper %s(void) (caller_owns_return=%r)"
" could not be generated: not implemented" % (retval.ctype, caller_owns_return)
)
print
else:
retval = return_handler(return_type)
try:
wrapper = MyReverseWrapper(retval, [])
except NotSupportedError:
continue
wrapper_number += 1
try:
wrapper.generate(code_out, "_test_wrapper_number_%i" % (wrapper_number,), ["static"])
except NotImplementedError:
print >> sys.stderr, (
"ReverseWrapper %s(void) could not be generated: not implemented" % (retval.ctype,)
)
print
## test parameter type handlers of reverse wrappers
for param_type, param_handler in typehandlers.base.param_type_matcher.items():
if os.name == "nt":
if stdint_rx.search(param_type):
continue # win32 does not support the u?int\d+_t types (defined in <stdint.h>)
for direction in param_handler.DIRECTIONS:
if direction == (Parameter.DIRECTION_IN):
param_name = "param"
elif direction == (Parameter.DIRECTION_IN | Parameter.DIRECTION_OUT):
param_name = "param_inout"
elif direction == (Parameter.DIRECTION_OUT):
param_name = "param_out"
param = param_handler(param_type, param_name, direction)
if "const" in param.ctype and direction & Parameter.DIRECTION_OUT:
continue
wrapper = MyReverseWrapper(ReturnValue.new("void"), [param])
wrapper_number += 1
try:
wrapper.generate(code_out, "_test_wrapper_number_%i" % (wrapper_number,), ["static"])
except NotImplementedError:
print >> sys.stderr, ("ReverseWrapper void(%s) could not be generated: not implemented" % (param.ctype))
print
## test generic forward wrappers, and module
for return_type, return_handler in typehandlers.base.return_type_matcher.items():
if os.name == "nt":
if stdint_rx.search(return_type):
continue # win32 does not support the u?int\d+_t types (defined in <stdint.h>)
wrapper_number += 1
function_name = "foo_function_%i" % (wrapper_number,)
## declare a fake prototype
print "%s %s(void);" % (return_type, function_name)
print
if issubclass(return_handler, (cppclass.CppClassPtrReturnValue, typehandlers.pyobjecttype.PyObjectReturnValue)):
retval = return_handler(return_type, caller_owns_return=True)
else:
retval = return_handler(return_type)
module.add_function(function_name, retval, [])
for param_type, param_handler in typehandlers.base.param_type_matcher.items():
if os.name == "nt":
if stdint_rx.search(param_type):
continue # win32 does not support the u?int\d+_t types (defined in <stdint.h>)
for is_const in [True, False]:
for direction in param_handler.DIRECTIONS:
if direction == (Parameter.DIRECTION_IN):
param_name = "param"
elif direction == (Parameter.DIRECTION_IN | Parameter.DIRECTION_OUT):
param_name = "param_inout"
elif direction == (Parameter.DIRECTION_OUT):
param_name = "param_out"
if is_const and direction & Parameter.DIRECTION_OUT:
continue # const and output parameter makes no sense
if is_const:
if "&" in param_type: # const references not allowed
continue
param_type_with_const = "const %s" % (param_type,)
else:
param_type_with_const = param_type
if issubclass(param_handler, (cppclass.CppClassPtrParameter, typehandlers.pyobjecttype.PyObjectParam)):
for transfer_ownership in True, False:
name = param_name + (transfer_ownership and "_transfer" or "_notransfer")
try:
param = param_handler(param_type, name, transfer_ownership=transfer_ownership)
except TypeError:
print >> sys.stderr, "ERROR -----> param_handler(param_type=%r, " "name=%r, transfer_ownership=%r, is_const=%r)" % (
param_type,
name,
transfer_ownership,
is_const,
)
wrapper_number += 1
function_name = "foo_function_%i" % (wrapper_number,)
## declare a fake prototype
print "void %s(%s %s);" % (function_name, param_type_with_const, name)
print
module.add_function(function_name, ReturnValue.new("void"), [param])
else:
param = param_handler(param_type, param_name, direction)
wrapper_number += 1
function_name = "foo_function_%i" % (wrapper_number,)
## declare a fake prototype
print "void %s(%s);" % (function_name, param_type_with_const)
print
module.add_function(function_name, ReturnValue.new("void"), [param])
module.generate(code_out)
