def visit_Attribute(self, node):
""" Compute typing for an attribute node. """
obj, path = attr_to_path(node)
assert not obj.isliteral() or obj.return_type, "Constants are known."
# If no type is given, use a decltype
if obj.return_type:
self.result[node] = obj.return_type
else:
self.result[node] = DeclType('::'.join(path) + '{}')
def visit_Attribute(self, node):
""" Compute typing for an attribute node. """
obj, path = attr_to_path(node)
# If no type is given, use a decltype
if obj.isliteral():
typename = pytype_to_ctype(obj.signature)
self.result[node] = NamedType(typename)
else:
self.result[node] = DeclType('::'.join(path) + '{}')
def visit_List(self, node):
if not node.elts: # empty list
return "pythonic::__builtin__::functor::list{}()"
else:
elts = [self.visit(n) for n in node.elts]
elts_type = [DeclType(elt) for elt in elts]
elts_type = CombinedTypes(*elts_type)
# constructor disambiguation, clang++ workaround
if len(elts) == 1:
elts.append('pythonic::types::single_value()')
node_type = ListType(elts_type)
return "{0}({{{1}}})".format(Assignable(node_type),
", ".join(elts))
def visit_Attribute(self, node):
""" Compute typing for an attribute node. """
def get_intrinsic_path(modules, attr):
""" Get function path and intrinsic from an ast.Attributs. """
if isinstance(attr, ast.Name):
return modules[attr.id], (attr.id, )
elif isinstance(attr, ast.Attribute):
module, path = get_intrinsic_path(modules, attr.value)
return module[attr.attr], path + (attr.attr, )
# Get the intrinsic object and its path as path is use in Pythonic
# hierarchy and obj may give additional information
obj, path = get_intrinsic_path(MODULES, node)
path = ('pythonic', ) + path
assert not obj.isliteral() or obj.return_type, "Constants are known."
# If no type is given, use a decltype
if obj.return_type:
self.result[node] = obj.return_type
else:
self.result[node] = DeclType('::'.join(path[:-1]) + '::proxy::' +
path[-1] + '()')
def visit_For(self, node):
"""
Create For representation for Cxx generation.
Examples
--------
>> for i in xrange(10):
>> ... work ...
Becomes
>> typename returnable<decltype(__builtin__.xrange(10))>::type __iterX
= __builtin__.xrange(10);
>> ... possible container size reservation ...
>> for (auto&& i: __iterX)
>> ... the work ...
This function also handle assignment for local variables.
We can notice that three kind of loop are possible:
- Normal for loop on iterator
- Autofor loop.
- Normal for loop using integer variable iteration
Kind of loop used depend on OpenMP, yield use and variable scope.
"""
if not isinstance(node.target, ast.Name):
raise PythranSyntaxError(
"Using something other than an identifier as loop target",
node.target)
target = self.visit(node.target)
# Handle the body of the for loop
loop_body = Block([self.visit(stmt) for stmt in node.body])
# Declare local variables at the top of the loop body
loop_body = self.process_locals(node, loop_body, node.target.id)
iterable = self.visit(node.iter)
if self.can_use_c_for(node):
header, loop = self.gen_c_for(node, target, loop_body)
else:
if self.can_use_autofor(node):
header = []
self.ldecls = {
d
for d in self.ldecls if d.id != node.target.id
}
autofor = AutoFor(target, iterable, loop_body)
loop = [self.process_omp_attachements(node, autofor)]
else:
# Iterator declaration
local_iter = "__iter{0}".format(len(self.break_handlers))
local_iter_decl = Assignable(DeclType(iterable))
self.handle_omp_for(node, local_iter)
# For yield function, iterable is globals.
if self.yields:
self.extra_declarations.append((
local_iter,
local_iter_decl,
))
local_iter_decl = ""
# Assign iterable
# For C loop, it avoids issues
# if the upper bound is assigned in the loop
header = [
Statement("{0} {1} = {2}".format(local_iter_decl,
local_iter, iterable))
]
loop = self.gen_for(node, target, local_iter, loop_body)
# For xxxComprehension, it is replaced by a for loop. In this case,
# pre-allocate size of container.
for comp in metadata.get(node, metadata.Comprehension):
header.append(
Statement("pythonic::utils::reserve({0},{1})".format(
comp.target, iterable)))
return Block(header + loop)
