def visit_ConstNode(self, node):
constant = node.pyval
if node.type.is_complex:
real = nodes.ConstNode(constant.real, node.type.base_type)
imag = nodes.ConstNode(constant.imag, node.type.base_type)
node = nodes.ComplexNode(real, imag)
elif node.type.is_pointer:
addr_int = constnodes.get_pointer_address(constant, node.type)
node = nodes.ptrfromint(addr_int, node.type)
elif node.type.is_object and not nodes.is_null_constant(constant):
node = nodes.ObjectInjectNode(constant, node.type)
return node
def complex_(typesystem, node, a, b):
if len(node.args) == 2:
args = nodes.CoercionNode.coerce(node.args, double)
return nodes.ComplexNode(real=args[0], imag=args[1])
else:
return cast(node, complex128)
def visit_CoerceToNative(self, node):
"""
Try to perform fast coercion using e.g. PyLong_AsLong(), with a
fallback to PyArg_ParseTuple().
"""
new_node = None
from_type = node.node.type
node_type = node.type
if node_type.is_numeric:
cls = None
if node_type == size_t:
node_type = ulonglong
if node_type.is_int: # and not
new_node = self.object_to_int(node.node, node_type)
elif node_type.is_float:
cls = pyapi.PyFloat_AsDouble
elif node_type.is_complex:
# FIXME: This conversion has to be pretty slow. We
# need to move towards being ABI-savvy enough to just
# call PyComplex_AsCComplex().
cloneable = nodes.CloneableNode(node.node)
new_node = nodes.ComplexNode(
real=function_util.external_call(self.context,
self.llvm_module,
"PyComplex_RealAsDouble",
args=[cloneable]),
imag=function_util.external_call(self.context,
self.llvm_module,
"PyComplex_ImagAsDouble",
args=[cloneable.clone]))
else:
raise error.NumbaError(
node, "Don't know how to coerce a Python object to a %r" %
node_type)
if cls:
# TODO: error checking!
new_node = function_util.external_call(self.context,
self.llvm_module,
cls.__name__,
args=[node.node])
elif node_type.is_pointer:
if from_type.is_jit_function and node_type.base_type.is_function:
new_node = self.coerce_to_function_pointer(
node, from_type, node_type)
else:
raise error.NumbaError(
node, "Obtaining pointers from objects "
"is not yet supported")
elif node_type.is_void:
raise error.NumbaError(node,
"Cannot coerce %s to void" % (from_type, ))
if new_node is None:
# Create a tuple for PyArg_ParseTuple
new_node = node
new_node.node = ast.Tuple(elts=[node.node], ctx=ast.Load())
self.generic_visit(node)
return node
if new_node.type != node.type:
# Fast native coercion. E.g. coercing an object to an int_
# will use PyLong_AsLong, but that will return a long_. We
# need to coerce the long_ to an int_
new_node = nodes.CoercionNode(new_node, node.type)
# Specialize replacement node
new_node = self.visit(new_node)
return new_node