Files
pybindgen/pybindgen/typehandlers/base.py
T

1271 lines
47 KiB
Python

## -*- python -*-
## pylint: disable-msg=W0142,R0921
"""
Base classes for all parameter/return type handlers,
and base interfaces for wrapper generators.
"""
import codesink
import warnings
from ctypeparser import normalize_type_string
try:
all
except NameError: # for compatibility with Python < 2.5
def all(iterable):
"Returns True if all elements are true"
for element in iterable:
if not element:
return False
return True
class CodegenErrorBase(Exception):
pass
class NotSupportedError(CodegenErrorBase):
"""Exception that is raised when declaring an interface configuration
that is not supported or not implemented."""
class CodeGenerationError(CodegenErrorBase):
"""Exception that is raised when wrapper generation fails for some reason."""
class TypeLookupError(CodegenErrorBase):
"""Exception that is raised when lookup of a type handler fails"""
class TypeConfigurationError(CodegenErrorBase):
"""Exception that is raised when a type handler does not find some
information it needs, such as owernship transfer semantics."""
def join_ctype_and_name(ctype, name):
"""
Utility method that joins a C type and a variable name into
a single string
>>> join_ctype_and_name('void*', 'foo')
'void *foo'
>>> join_ctype_and_name('void *', 'foo')
'void *foo'
>>> join_ctype_and_name("void**", "foo")
'void **foo'
>>> join_ctype_and_name("void **", "foo")
'void **foo'
>>> join_ctype_and_name('C*', 'foo')
'C *foo'
"""
if ctype[-1] == '*':
for i in range(-1, -len(ctype) - 1, -1):
if ctype[i] != '*':
if ctype[i] == ' ':
return "".join([ctype[:i+1], ctype[i+1:], name])
else:
return "".join([ctype[:i+1], ' ', ctype[i+1:], name])
raise ValueError((ctype, name))
else:
return " ".join([ctype, name])
class CodeBlock(object):
'''An intelligent code block that keeps track of cleanup actions.
This object is to be used by TypeHandlers when generating code.'''
class CleanupHandle(object):
"""Handle for some cleanup code"""
__slots__ = ['code_block', 'position']
def __init__(self, code_block, position):
"""Create a handle given code_block and position"""
self.code_block = code_block
self.position = position
def __cmp__(self, other):
comp = cmp(self.code_block, other.code_block)
if comp:
return comp
return cmp(self.position, other.position)
def cancel(self):
"""Cancel the cleanup code"""
self.code_block.remove_cleanup_code(self)
def get_position(self):
"returns the cleanup code relative position"
return self.position
def __init__(self, error_return, declarations, predecessor=None):
'''
CodeBlock constructor
>>> block = CodeBlock("return NULL;", DeclarationsScope())
>>> block.write_code("foo();")
>>> cleanup1 = block.add_cleanup_code("clean1();")
>>> cleanup2 = block.add_cleanup_code("clean2();")
>>> cleanup3 = block.add_cleanup_code("clean3();")
>>> cleanup2.cancel()
>>> block.write_error_check("error()", "error_clean()")
>>> block.write_code("bar();")
>>> block.write_cleanup()
>>> print block.sink.flush().rstrip()
foo();
if (error()) {
error_clean()
clean3();
clean1();
return NULL;
}
bar();
clean3();
clean1();
@param error_return: code that is generated on error conditions
(detected by write_error_check()); normally
it returns from the wrapper function,
e.g. return NULL;
@param predecessor: optional predecessor code block; a
predecessor is used to search for additional
cleanup actions.
'''
assert isinstance(declarations, DeclarationsScope)
assert predecessor is None or isinstance(predecessor, CodeBlock)
self.sink = codesink.MemoryCodeSink()
self.predecessor = predecessor
self._cleanup_actions = {}
self._last_cleanup_position = 0
self.error_return = error_return
self.declarations = declarations
def clear(self):
self._cleanup_actions = {}
self._last_cleanup_position = 0
self.sink = codesink.MemoryCodeSink()
def declare_variable(self, type_, name, initializer=None, array=None):
"""
Calls declare_variable() on the associated DeclarationsScope object.
"""
if ':' in name:
raise ValueError("invalid variable name: %s " % name)
return self.declarations.declare_variable(type_, name, initializer, array)
def write_code(self, code):
'''Write out some simple code'''
self.sink.writeln(code)
def indent(self, level=4):
'''Add a certain ammount of indentation to all lines written
from now on and until unindent() is called'''
self.sink.indent(level)
def unindent(self):
'''Revert indentation level to the value before last indent() call'''
self.sink.unindent()
def add_cleanup_code(self, cleanup_code):
'''Add a chunk of code used to cleanup previously allocated resources
Returns a handle used to cancel the cleanup code
'''
self._last_cleanup_position += 1
handle = self.CleanupHandle(self, self._last_cleanup_position)
self._cleanup_actions[handle.get_position()] = cleanup_code
return handle
def remove_cleanup_code(self, handle):
'''Remove cleanup code previously added with add_cleanup_code()
'''
assert isinstance(handle, self.CleanupHandle)
del self._cleanup_actions[handle.get_position()]
def get_cleanup_code(self):
'''return a new list with all cleanup actions, including the
ones from predecessor code blocks; Note: cleanup actions are
executed in reverse order than when they were added.'''
if self.predecessor is None:
cleanup = []
else:
cleanup = self.predecessor.get_cleanup_code()
items = self._cleanup_actions.items()
items.sort()
for dummy, code in items:
cleanup.append(code)
cleanup.reverse()
return cleanup
def write_error_check(self, failure_expression, failure_cleanup=None):
'''Add a chunk of code that checks for a possible error
@param failure_expression: C boolean expression that is true when
an error occurred
@param failure_cleanup: optional extra cleanup code to write only
for the the case when failure_expression is
true; this extra cleanup code comes before
all other cleanup code previously registered.
'''
self.sink.writeln("if (%s) {" % (failure_expression,))
self.sink.indent()
if failure_cleanup is not None:
self.sink.writeln(failure_cleanup)
self.write_error_return()
self.sink.unindent()
self.sink.writeln("}")
def write_cleanup(self):
"""Write the current cleanup code."""
for cleanup_action in self.get_cleanup_code():
self.sink.writeln(cleanup_action)
def write_error_return(self):
'''Add a chunk of code that cleans up and returns an error.
'''
self.write_cleanup()
self.sink.writeln(self.error_return)
class ParseTupleParameters(object):
"Object to keep track of PyArg_ParseTuple (or similar) parameters"
def __init__(self):
"""
>>> tuple_params = ParseTupleParameters()
>>> tuple_params.add_parameter('i', ['&foo'], 'foo')
>>> tuple_params.add_parameter('s', ['&bar'], 'bar', optional=True)
>>> tuple_params.get_parameters()
['"i|s"', '&foo', '&bar']
>>> tuple_params.get_keywords()
['foo', 'bar']
>>> tuple_params = ParseTupleParameters()
>>> tuple_params.add_parameter('i', ['&foo'], 'foo')
>>> tuple_params.add_parameter('s', ['&bar'], 'bar', prepend=True)
>>> tuple_params.get_parameters()
['"si"', '&bar', '&foo']
>>> tuple_params.get_keywords()
['bar', 'foo']
>>> tuple_params = ParseTupleParameters()
>>> tuple_params.add_parameter('i', ['&foo'])
>>> print tuple_params.get_keywords()
None
"""
self._parse_tuple_items = [] # (template, param_values, param_name, optional)
def clear(self):
self._parse_tuple_items = []
def add_parameter(self, param_template, param_values, param_name=None,
prepend=False, optional=False):
"""
Adds a new parameter specification
@param param_template: template item, see documentation for
PyArg_ParseTuple for more information
@param param_values: list of parameters, see documentation
for PyArg_ParseTuple for more information
@param prepend: whether this parameter should be parsed first
@param optional: whether the parameter is optional; note that after
the first optional parameter, all remaining
parameters must also be optional
"""
assert isinstance(param_values, list)
assert isinstance(param_template, str)
item = (param_template, param_values, param_name, optional)
if prepend:
self._parse_tuple_items.insert(0, item)
else:
self._parse_tuple_items.append(item)
def is_empty(self):
return self.get_parameters() == ['""']
def get_parameters(self):
"""
returns a list of parameters to pass into a
PyArg_ParseTuple-style function call, the first paramter in
the list being the template string.
"""
template = ['"']
last_was_optional = False
for (param_template, dummy,
dummy, optional) in self._parse_tuple_items:
if not (last_was_optional and optional or not last_was_optional):
raise ValueError("Error: optional parameter followed by a non-optional one"
" (debug: self._parse_tuple_parameters=%r)" % self._parse_tuple_items)
if not last_was_optional and optional:
template.append('|')
last_was_optional = optional
template.append(param_template)
template.append('"')
params = [''.join(template)]
for (dummy, param_values,
dummy, dummy) in self._parse_tuple_items:
params.extend(param_values)
return params
def get_keywords(self):
"""
returns list of keywords (parameter names), or None if none of
the parameters had a name; should only be called if names were
given for all parameters or none of them.
"""
keywords = []
for (dummy, dummy, name, dummy) in self._parse_tuple_items:
if name is None:
if keywords:
raise ValueError("mixing parameters with and without keywords")
else:
keywords.append(name)
if keywords:
return keywords
else:
return None
class BuildValueParameters(object):
"Object to keep track of Py_BuildValue (or similar) parameters"
def __init__(self):
"""
>>> bld = BuildValueParameters()
>>> bld.add_parameter('i', [123, 456])
>>> bld.add_parameter('s', ["hello"])
>>> bld.get_parameters()
['"is"', 123, 456, 'hello']
>>> bld = BuildValueParameters()
>>> bld.add_parameter('i', [123])
>>> bld.add_parameter('s', ["hello"], prepend=True)
>>> bld.get_parameters()
['"si"', 'hello', 123]
"""
self._build_value_items = [] # (template, param_value, cleanup_handle)
def clear(self):
self._build_value_items = []
def add_parameter(self, param_template, param_values,
prepend=False, cancels_cleanup=None):
"""
Adds a new parameter to the Py_BuildValue (or similar) statement.
@param param_template: template item, see documentation for
Py_BuildValue for more information
@param param_values: list of C expressions to use as value, see documentation
for Py_BuildValue for more information
@param prepend: whether this parameter should come first in the tuple being built
@param cancels_cleanup: optional handle to a cleanup action,
that is removed after the call. Typically
this is used for 'N' parameters, which
already consume an object reference
"""
item = (param_template, param_values, cancels_cleanup)
if prepend:
self._build_value_items.insert(0, item)
else:
self._build_value_items.append(item)
def get_parameters(self):
"""returns a list of parameters to pass into a
Py_BuildValue-style function call, the first paramter in
the list being the template string."""
template = ['"']
params = [None]
for (param_template, param_values, dummy) in self._build_value_items:
template.append(param_template)
params.extend(param_values)
template.append('"')
params[0] = ''.join(template)
return params
def get_cleanups(self):
"""Get a list of handles to cleanup actions"""
return [cleanup for (dummy, dummy, cleanup) in self._build_value_items]
class DeclarationsScope(object):
"""Manages variable declarations in a given scope."""
def __init__(self, parent_scope=None):
"""
Constructor
>>> scope = DeclarationsScope()
>>> scope.declare_variable('int', 'foo')
'foo'
>>> scope.declare_variable('char*', 'bar')
'bar'
>>> scope.declare_variable('int', 'foo')
'foo2'
>>> scope.declare_variable('int', 'foo', '1')
'foo3'
>>> scope.declare_variable('const char *', 'kwargs', '{"hello", NULL}', '[]')
'kwargs'
>>> print scope.get_code_sink().flush().rstrip()
int foo;
char *bar;
int foo2;
int foo3 = 1;
const char *kwargs[] = {"hello", NULL};
@param parent_scope: optional 'parent scope'; if given,
declarations in this scope will avoid clashing
with names in the parent scope, and vice
versa.
"""
self._declarations = codesink.MemoryCodeSink()
## name -> number of variables with that name prefix
if parent_scope is None:
self.declared_variables = {}
else:
assert isinstance(parent_scope, DeclarationsScope)
self.declared_variables = parent_scope.declared_variables
def clear(self):
self._declarations = codesink.MemoryCodeSink()
self.declared_variables.clear()
def declare_variable(self, type_, name, initializer=None, array=None):
"""Add code to declare a variable. Returns the actual variable
name used (uses 'name' as base, with a number in case of conflict.)
@param type_: C type name of the variable
@param name: base name of the variable; actual name used can be
slightly different in case of name conflict.
@param initializer: optional, value to initialize the variable with
@param array: optional, array size specifiction, e.g. '[]', or '[100]'
"""
try:
num = self.declared_variables[name]
except KeyError:
num = 0
num += 1
self.declared_variables[name] = num
if num == 1:
varname = name
else:
varname = "%s%i" % (name, num)
decl = join_ctype_and_name(type_, varname)
if array is not None:
decl += array
if initializer is not None:
decl += ' = ' + initializer
self._declarations.writeln(decl + ';')
return varname
def reserve_variable(self, name):
"""Reserve a variable name, to be used later.
@param name: base name of the variable; actual name used can be
slightly different in case of name conflict.
"""
try:
num = self.declared_variables[name]
except KeyError:
num = 0
num += 1
self.declared_variables[name] = num
if num == 1:
varname = name
else:
varname = "%s%i" % (name, num)
return varname
def get_code_sink(self):
"""Returns the internal MemoryCodeSink that holds all declararions."""
return self._declarations
class ReverseWrapperBase(object):
"""Generic base for all reverse wrapper generators.
Reverse wrappers all have the following general structure in common:
1. 'declarations' -- variable declarations; for compatibility with
older C compilers it is very important that all declarations
come before any simple statement. Declarations can be added
with the add_declaration() method on the 'declarations'
attribute. Two standard declarations are always predeclared:
'<return-type> retval', unless return-type is void, and 'PyObject
*py_retval';
2. 'code before call' -- this is a code block dedicated to contain
all code that is needed before calling into Python; code can be
freely added to it by accessing the 'before_call' (a CodeBlock
instance) attribute;
3. 'call into python' -- this is realized by a
PyObject_CallMethod(...) or similar Python API call; the list
of parameters used in this call can be customized by accessing
the 'build_params' (a BuildValueParameters instance) attribute;
4. 'code after call' -- this is a code block dedicated to contain
all code that must come after calling into Python; code can be
freely added to it by accessing the 'after_call' (a CodeBlock
instance) attribute;
5. A 'return retval' statement (or just 'return' if return_value is void)
"""
def __init__(self, return_value, parameters, error_return=None):
'''
Base constructor
@param return_value: type handler for the return value
@param parameters: a list of type handlers for the parameters
'''
assert isinstance(return_value, ReturnValue)
assert isinstance(parameters, list)
assert all([isinstance(param, Parameter) for param in parameters])
self.return_value = return_value
self.parameters = parameters
if error_return is None:
error_return = "PyErr_Print();\n" + return_value.get_c_error_return()
self.error_return = error_return
self.declarations = DeclarationsScope()
self.before_call = CodeBlock(error_return, self.declarations)
self.after_call = CodeBlock(error_return, self.declarations,
predecessor=self.before_call)
self.build_params = BuildValueParameters()
self.parse_params = ParseTupleParameters()
def set_error_return(self, error_return):
self.error_return = error_return
self.before_call.error_return = error_return
self.after_call.error_return = error_return
def reset_code_generation_state(self):
self.declarations.clear()
self.before_call.clear()
self.after_call.clear()
self.build_params.clear()
self.parse_params.clear()
def generate_python_call(self):
"""Generates the code (into self.before_call) to call into
Python, storing the result in the variable 'py_retval'; should
also check for call error.
"""
raise NotImplementedError
def generate(self, code_sink, wrapper_name, decl_modifiers=('static',),
decl_post_modifiers=()):
"""Generate the wrapper
@param code_sink: a CodeSink object that will receive the code
@param wrapper_name: C/C++ identifier of the function/method to generate
@param decl_modifiers: list of C/C++ declaration modifiers, e.g. 'static'
"""
assert isinstance(decl_modifiers, (list, tuple))
assert all([isinstance(mod, str) for mod in decl_modifiers])
self.declarations.declare_variable('PyObject*', 'py_retval')
if self.return_value.ctype != 'void' \
and not self.return_value.REQUIRES_ASSIGNMENT_CONSTRUCTOR:
self.declarations.declare_variable(self.return_value.ctype, 'retval')
## convert the input parameters
for param in self.parameters:
param.convert_c_to_python(self)
## generate_python_call should include something like
## self.after_call.write_error_check('py_retval == NULL')
self.generate_python_call()
## convert the return value(s)
self.return_value.convert_python_to_c(self)
if self.parse_params.is_empty():
self.before_call.write_error_check('py_retval != Py_None',
'PyErr_SetString(PyExc_TypeError, "function/method should return None");')
else:
## parse the return value
## this ensures that py_retval is always a tuple
self.before_call.write_code('py_retval = Py_BuildValue("(N)", py_retval);')
parse_tuple_params = ['py_retval']
parse_tuple_params.extend(self.parse_params.get_parameters())
self.before_call.write_error_check('!PyArg_ParseTuple(%s)' %
(', '.join(parse_tuple_params),))
## cleanup and return
self.after_call.write_cleanup()
if self.return_value.ctype == 'void':
self.after_call.write_code('return;')
else:
self.after_call.write_code('return retval;')
## now write out the wrapper function itself
## open function
retline = list(decl_modifiers)
retline.append(self.return_value.ctype)
code_sink.writeln(' '.join(retline))
params_list = ', '.join([join_ctype_and_name(param.ctype, param.name)
for param in self.parameters])
code_sink.writeln("%s(%s)%s" % (wrapper_name, params_list,
' '.join([''] + list(decl_post_modifiers))))
## body
code_sink.writeln('{')
code_sink.indent()
self.declarations.get_code_sink().flush_to(code_sink)
code_sink.writeln()
self.before_call.sink.flush_to(code_sink)
self.after_call.sink.flush_to(code_sink)
## close function
code_sink.unindent()
code_sink.writeln('}')
class ForwardWrapperBase(object):
"""Generic base for all forward wrapper generators.
Forward wrappers all have the following general structure in common:
1. 'declarations' -- variable declarations; for compatibility with
older C compilers it is very important that all declarations
come before any simple statement. Declarations can be added
with the add_declaration() method on the 'declarations'
attribute. Two standard declarations are always predeclared:
'<return-type> retval', unless return-type is void, and 'PyObject
*py_retval';
2. 'code before parse' -- code before the
PyArg_ParseTupleAndKeywords call; code can be freely added to
it by accessing the 'before_parse' (a CodeBlock instance)
attribute;
3. A PyArg_ParseTupleAndKeywords call; uses items from the
parse_params object;
4. 'code before call' -- this is a code block dedicated to contain
all code that is needed before calling the C function; code can be
freely added to it by accessing the 'before_call' (a CodeBlock
instance) attribute;
5. 'call into C' -- this is realized by a C/C++ call; the list of
parameters that should be used is in the 'call_params' wrapper
attribute;
6. 'code after call' -- this is a code block dedicated to contain
all code that must come after calling into Python; code can be
freely added to it by accessing the 'after_call' (a CodeBlock
instance) attribute;
7. A py_retval = Py_BuildValue(...) call; this call can be
customized, so that out/inout parameters can add additional
return values, by accessing the 'build_params' (a
BuildValueParameters instance) attribute;
8. Cleanup and return.
Object constructors cannot return values, and so the step 7 is to
be omitted for them.
"""
PARSE_TUPLE = 1
PARSE_TUPLE_AND_KEYWORDS = 2
def __init__(self, return_value, parameters,
parse_error_return, error_return,
force_parse=None, no_c_retval=False,
unblock_threads=False):
'''
Base constructor
@param return_value: type handler for the return value
@param parameters: a list of type handlers for the parameters
@param parse_error_return: statement to return an error during parameter parsing
@param error_return: statement to return an error after parameter parsing
@param force_parse: force generation of code to parse parameters even if there are none
@param no_c_retval: force the wrapper to not have a C return value
@param unblock_threads: generate code to unblock python threads during the C function call
'''
assert isinstance(return_value, ReturnValue) or return_value is None
assert isinstance(parameters, list)
assert all([isinstance(param, Parameter) for param in parameters])
self.return_value = return_value
self.parameters = parameters
self.declarations = DeclarationsScope()
self.before_parse = CodeBlock(parse_error_return, self.declarations)
self.before_call = CodeBlock(parse_error_return, self.declarations,
predecessor=self.before_parse)
self.after_call = CodeBlock(error_return, self.declarations,
predecessor=self.before_call)
self.build_params = BuildValueParameters()
self.parse_params = ParseTupleParameters()
self.call_params = []
self.force_parse = force_parse
self.meth_flags = []
self.unblock_threads = unblock_threads
self.no_c_retval = no_c_retval
self.overload_index = None
# The following 3 variables describe the C wrapper function
# prototype; do not confuse with the python function/method!
self.wrapper_actual_name = None # name of the wrapper function/method
self.wrapper_return = None # C type expression for the wrapper return
self.wrapper_args = None # list of arguments to the wrapper function
if return_value is not None:
self.declarations.declare_variable('PyObject*', 'py_retval')
if (not no_c_retval and return_value is not None
and return_value.ctype != 'void'
and not return_value.REQUIRES_ASSIGNMENT_CONSTRUCTOR):
self.declarations.declare_variable(return_value.ctype, 'retval')
for param in self.parameters:
self.declarations.reserve_variable(param.name)
def reset_code_generation_state(self):
self.declarations.clear()
for param in self.parameters:
self.declarations.reserve_variable(param.name)
self.before_parse.clear()
self.before_call.clear()
self.after_call.clear()
self.build_params.clear()
self.parse_params.clear()
self.call_params = []
self.meth_flags = []
if self.return_value is not None:
self.declarations.declare_variable('PyObject*', 'py_retval')
if (not self.no_c_retval and self.return_value is not None
and self.return_value.ctype != 'void'
and not self.return_value.REQUIRES_ASSIGNMENT_CONSTRUCTOR):
self.declarations.declare_variable(self.return_value.ctype, 'retval')
def set_parse_error_return(self, parse_error_return):
self.before_parse.error_return = parse_error_return
self.before_call.error_return = parse_error_return
def generate_call(self):
"""Generates the code (into self.before_call) to call into
Python, storing the result in the variable 'py_retval'; should
also check for call error.
"""
raise NotImplementedError
def _before_return_hook(self):
"""
Optional hook that lets subclasses add code after all
parameters are parsed and after the function C return value is
processed, but after the python wrapper return value (py_ret)
is built and returned. Subclasses may add code to
self.after_call, which will be placed before py_ret is
created.
"""
pass
def write_open_wrapper(self, code_sink, add_static=False):
assert self.wrapper_actual_name is not None
assert self.wrapper_return is not None
assert isinstance(self.wrapper_args, list)
if add_static:
code_sink.writeln("static " + self.wrapper_return)
else:
code_sink.writeln(self.wrapper_return)
code_sink.writeln("%s(%s)" % (self.wrapper_actual_name, ', '.join(self.wrapper_args)))
code_sink.writeln('{')
code_sink.indent()
def write_close_wrapper(self, code_sink):
code_sink.unindent()
code_sink.writeln('}')
def generate_body(self, code_sink, gen_call_params=()):
"""Generate the wrapper function body
code_sink -- a CodeSink object that will receive the code
"""
if self.unblock_threads:
py_thread_state = self.declarations.declare_variable("PyThreadState*", "py_thread_state", "NULL")
self.after_call.write_code(
"\nif (%s)\n"
" PyEval_RestoreThread(%s);\n" % (py_thread_state, py_thread_state))
## convert the input parameters
for param in self.parameters:
try:
param.convert_python_to_c(self)
except NotImplementedError:
raise CodeGenerationError(
'convert_python_to_c method of parameter %s not implemented'
% (param.ctype,))
if self.unblock_threads:
self.before_call.write_code(
"\nif (PyEval_ThreadsInitialized ())\n"
" %s = PyEval_SaveThread();\n"
% (py_thread_state, ))
self.generate_call(*gen_call_params)
params = self.parse_params.get_parameters()
keywords = self.parse_params.get_keywords()
if params != ['""'] or self.force_parse != None:
self.meth_flags.append("METH_VARARGS")
if (keywords is None
and self.force_parse != self.PARSE_TUPLE_AND_KEYWORDS):
param_list = ['args'] + params
self.before_parse.write_error_check('!PyArg_ParseTuple(%s)' %
(', '.join(param_list),))
else:
if keywords is None:
keywords = []
keywords_var = self.declarations.declare_variable(
'const char *', 'keywords',
'{' + ', '.join(['"%s"' % kw for kw in keywords] + ['NULL']) + '}',
'[]')
param_list = ['args', 'kwargs', params[0], '(char **) ' + keywords_var] + params[1:]
self.before_parse.write_error_check('!PyArg_ParseTupleAndKeywords(%s)' %
(', '.join(param_list),))
self.meth_flags.append("METH_KEYWORDS")
else:
self.meth_flags.append("METH_NOARGS")
## convert the return value(s)
if self.return_value is None:
assert self.build_params.get_parameters() == ['""'], \
"this wrapper is not supposed to return values"
self._before_return_hook()
self.after_call.write_cleanup()
else:
try:
self.return_value.convert_c_to_python(self)
except NotImplementedError:
raise CodeGenerationError(
'convert_c_to_python method of return value %s not implemented'
% (self.return_value.ctype,))
self._before_return_hook()
params = self.build_params.get_parameters()
if params:
self.after_call.write_code('py_retval = Py_BuildValue(%s);' %
(', '.join(params),))
## cleanup and return
self.after_call.write_cleanup()
self.after_call.write_code('return py_retval;')
## now write out the wrapper function body itself
self.declarations.get_code_sink().flush_to(code_sink)
code_sink.writeln()
self.before_parse.sink.flush_to(code_sink)
self.before_call.sink.flush_to(code_sink)
self.after_call.sink.flush_to(code_sink)
def get_py_method_def_flags(self):
"""
Get a list of PyMethodDef flags that should be used for this wrapper.
"""
flags = set(self.meth_flags)
if flags:
return list(flags)
tmp_sink = codesink.NullCodeSink()
try:
# try:
# self.generate_body(tmp_sink)
# except CodegenErrorBase:
# return []
# else:
# return list(set(self.meth_flags))
self.generate_body(tmp_sink)
return list(set(self.meth_flags))
finally:
self.reset_code_generation_state()
class TypeTransformation(object):
"""
Type transformations are used to register handling of special
types that are simple transformation over another type that is
already registered. This way, only the original type is
registered, and the type transformation only does the necessary
adjustments over the original type handler to make it handle the
transformed type as well.
This is typically used to get smart pointer templated types
working.
"""
def get_untransformed_name(self, name):
"""
Given a transformed named, get the original C type name.
E.g., given a smart pointer transformation, MySmartPointer::
get_untransformed_name('MySmartPointer<Foo>') -> 'Foo*'
"""
raise NotImplementedError
def create_type_handler(self, type_handler_class, *args, **kwargs):
"""
Given a type_handler class, create an instance with proper customization.
@param type_handler_class: type handler class
@param args: arguments
@param kwargs: keywords arguments
"""
raise NotImplementedError
def transform(self, type_handler, declarations, code_block, value):
"""
Transforms a value expression of the original type to an
equivalent value expression in the transformed type.
Example, with the transformation::
'T*' -> 'boost::shared_ptr<T>'
Then::
transform(wrapper, 'foo') -> 'boost::shared_ptr<%s>(foo)' % type_handler.untransformed_ctype
"""
raise NotImplementedError
def untransform(self, type_handler, declarations, code_block, value):
"""
Transforms a value expression of the transformed type to an
equivalent value expression in the original type.
Example, with the transformation::
'T*' -> 'boost::shared_ptr<T>'
Then::
untransform(wrapper, 'foo') -> 'foo->get_pointer()'
"""
raise NotImplementedError
class NullTypeTransformation(object):
"""
Null type transformation, returns everything unchanged.
"""
def get_untransformed_name(self, name):
"identity transformation"
return name
def create_type_handler(self, type_handler_class, *args, **kwargs):
"identity transformation"
return type_handler_class(*args, **kwargs)
def transform(self, type_handler, declarations, code_block, value):
"identity transformation"
return value
def untransform(self, type_handler, declarations, code_block, value):
"identity transformation"
return value
class ReturnValue(object):
'''Abstract base class for all classes dedicated to handle
specific return value types'''
## list of C type names it can handle
CTYPES = []
## whether it supports type transformations
SUPPORTS_TRANSFORMATIONS = False
REQUIRES_ASSIGNMENT_CONSTRUCTOR = False
class __metaclass__(type):
"Metaclass for automatically registering parameter type handlers"
def __init__(mcs, name, bases, dict_):
"metaclass __init__"
type.__init__(mcs, name, bases, dict_)
if __debug__:
try:
iter(mcs.CTYPES)
except TypeError:
print "ERROR: missing CTYPES on class ", mcs
for ctype in mcs.CTYPES:
return_type_matcher.register(ctype, mcs)
@classmethod
def new(cls, *args, **kwargs):
"""
>>> import inttype
>>> isinstance(ReturnValue.new('int'), inttype.IntReturn)
True
"""
if cls is ReturnValue:
ctype = args[0]
type_handler_class, transformation = \
return_type_matcher.lookup(ctype)
assert type_handler_class is not None
if transformation is None:
try:
return type_handler_class(*args, **kwargs)
except TypeError, ex:
warnings.warn("Exception %r in type handler %s constructor" % (str(ex), type_handler_class))
raise
else:
return transformation.create_type_handler(type_handler_class, *args, **kwargs)
else:
return cls(*args, **kwargs)
def __init__(self, ctype, is_const=False):
'''
Creates a return value object
Keywork Arguments:
@param ctype: actual C/C++ type being used
'''
if type(self) is ReturnValue:
raise TypeError('ReturnValue is an abstract class; use ReturnValue.new(...)')
#assert 'const' not in ctype, "FIXME: remove this assert"
if is_const:
ctype = 'const ' + ctype
self.ctype = ctype
self.untransformed_ctype = ctype
self.transformation = NullTypeTransformation()
self.value = 'retval'
self.is_const = is_const
def set_tranformation(self, transformation, untransformed_ctype):
"Set the type transformation to use in this type handler"
assert isinstance(transformation, TypeTransformation)
assert untransformed_ctype != self.ctype
assert isinstance(self.transformation, NullTypeTransformation)
assert self.SUPPORTS_TRANSFORMATIONS
self.transformation = transformation
self.untransformed_ctype = untransformed_ctype
def get_c_error_return(self):
'''Return a "return <value>" code string, for use in case of error'''
raise NotImplementedError
def convert_python_to_c(self, wrapper):
'''
Writes code to convert the Python return value into the C "retval" variable.
'''
raise NotImplementedError
#assert isinstance(wrapper, ReverseWrapperBase)
def convert_c_to_python(self, wrapper):
'''
Writes code to convert the C return value the Python return.
'''
raise NotImplementedError
#assert isinstance(wrapper, ReverseWrapperBase)
ReturnValue.CTYPES = NotImplemented
class PointerReturnValue(ReturnValue):
"""Base class for all pointer-to-something handlers"""
CTYPES = []
def __init__(self, ctype, is_const=False, caller_owns_return=None):
super(PointerReturnValue, self).__init__(ctype, is_const)
self.call_owns_return = caller_owns_return
PointerReturnValue.CTYPES = NotImplemented
class Parameter(object):
'''Abstract base class for all classes dedicated to handle specific parameter types'''
## bit mask values
DIRECTION_IN = 1
DIRECTION_OUT = 2
DIRECTION_INOUT = DIRECTION_IN|DIRECTION_OUT
## list of possible directions for this type
DIRECTIONS = NotImplemented
## whether it supports type transformations
SUPPORTS_TRANSFORMATIONS = False
## list of C type names it can handle
CTYPES = []
def _direction_value_to_name(cls, value):
if value == cls.DIRECTION_IN:
return "DIRECTION_IN"
elif value == cls.DIRECTION_OUT:
return "DIRECTION_OUT"
elif value == cls.DIRECTION_INOUT:
return "DIRECTION_INOUT"
else:
return "(invalid %r)" % value
_direction_value_to_name = classmethod(_direction_value_to_name)
class __metaclass__(type):
"Metaclass for automatically registering parameter type handlers"
def __init__(mcs, name, bases, dict_):
"metaclass __init__"
type.__init__(mcs, name, bases, dict_)
if __debug__:
try:
iter(mcs.CTYPES)
except TypeError:
print "ERROR: missing CTYPES on class ", mcs
for ctype in mcs.CTYPES:
param_type_matcher.register(ctype, mcs)
@classmethod
def new(cls, *args, **kwargs):
"""
>>> import inttype
>>> isinstance(Parameter.new('int', 'name'), inttype.IntParam)
True
"""
if cls is Parameter:
# support calling Parameter("typename", ...)
ctype = args[0]
type_handler_class, transformation = \
param_type_matcher.lookup(ctype)
assert type_handler_class is not None
if transformation is None:
try:
return type_handler_class(*args, **kwargs)
except TypeError, ex:
warnings.warn("Exception %r in type handler %s constructor" % (str(ex), type_handler_class))
raise
else:
return transformation.create_type_handler(type_handler_class, *args, **kwargs)
else:
return cls(*args, **kwargs)
def __init__(self, ctype, name, direction=DIRECTION_IN, is_const=False, default_value=None):
'''
Creates a parameter object
Keywork Arguments:
@param ctype: actual C/C++ type being used
@param name: parameter name
@param direction: direction of the parameter transfer, valid values
are DIRECTION_IN, DIRECTION_OUT, and
DIRECTION_IN|DIRECTION_OUT
'''
if type(self) is Parameter:
raise TypeError('Parameter is an abstract class; use Parameter.new(...)')
#assert 'const' not in ctype, "FIXME: remove this assert"
self.ctype_no_const = ctype
if is_const:
ctype = 'const ' + ctype
self.ctype = ctype
self.untransformed_ctype = ctype
self.name = name
assert direction in self.DIRECTIONS, \
"Error: requested direction %s for type handler %r (ctype=%r), but it only supports directions %r"\
% (self._direction_value_to_name(direction), type(self), self.ctype,
[self._direction_value_to_name(d) for d in self.DIRECTIONS])
self.direction = direction
self.is_const = is_const
self.transformation = NullTypeTransformation()
self.value = name
self.default_value = default_value
def set_tranformation(self, transformation, untransformed_ctype):
"Set the type transformation to use in this type handler"
assert isinstance(transformation, TypeTransformation)
assert untransformed_ctype != self.ctype
assert isinstance(self.transformation, NullTypeTransformation)
assert self.SUPPORTS_TRANSFORMATIONS
self.transformation = transformation
self.untransformed_ctype = untransformed_ctype
def convert_c_to_python(self, wrapper):
'''Write some code before calling the Python method.'''
#assert isinstance(wrapper, ReverseWrapperBase)
raise NotImplementedError
def convert_python_to_c(self, wrapper):
'''Write some code before calling the C method.'''
#assert isinstance(wrapper, ReverseWrapperBase)
raise NotImplementedError
Parameter.CTYPES = NotImplemented
class PointerParameter(Parameter):
"""Base class for all pointer-to-something handlers"""
CTYPES = []
def __init__(self, ctype, name, direction=Parameter.DIRECTION_IN, is_const=False, default_value=None,
transfer_ownership=False):
super(PointerParameter, self).__init__(ctype, name, direction, is_const, default_value)
self.transfer_ownership = transfer_ownership
PointerParameter.CTYPES = NotImplemented
class TypeMatcher(object):
"""
Type matcher object: maps C type names to classes that handle
those types.
"""
def __init__(self):
"""Constructor"""
self._types = {}
self._transformations = []
def register_transformation(self, transformation):
"Register a type transformation object"
assert isinstance(transformation, TypeTransformation)
self._transformations.append(transformation)
def register(self, name, type_handler):
"""Register a new handler class for a given C type
@param name: C type name
@param type_handler: class to handle this C type
"""
name = normalize_type_string(name)
if name in self._types:
raise ValueError("return type %s already registered" % (name,))
self._types[name] = type_handler
def lookup(self, name):
"""
lookup(name) -> type_handler, type_transformation
Returns a handler with the given ctype name, or raises KeyError.
Supports type transformations.
@param name: C type name, possibly transformed (e.g. MySmartPointer<Foo> looks up Foo*)
"""
name = normalize_type_string(name)
try:
return self._types[name], None
except KeyError:
## Now try all the type transformations
for transf in self._transformations:
untransformed_name = transf.get_untransformed_name(name)
if untransformed_name is None:
continue
try:
return self._types[untransformed_name], transf
except KeyError:
continue
else:
raise TypeLookupError(name)
def items(self):
"Returns an iterator over all registered items"
return self._types.iteritems()
return_type_matcher = TypeMatcher()
param_type_matcher = TypeMatcher()