import cython
-cython.declare(PyrexTypes=object, Naming=object, ExprNodes=object, Nodes=object,
- Options=object, UtilNodes=object, ModuleNode=object,
- LetNode=object, LetRefNode=object, TreeFragment=object,
- TemplateTransform=object, EncodedString=object,
- error=object, warning=object, copy=object)
+cython.declare(PyrexTypes=object, ExprNodes=object, Nodes=object,
+ Builtin=object, InternalError=object,
+ error=object, warning=object,
+ py_object_type=object, unspecified_type=object,
+ object_expr=object, object_expr_not_none=object,
+ fake_rhs_expr=object, TypedExprNode=object)
import Builtin
import ExprNodes
class TypedExprNode(ExprNodes.ExprNode):
# Used for declaring assignments of a specified type without a known entry.
def __init__(self, type, may_be_none=None, pos=None):
- self.pos = pos
+ super(TypedExprNode, self).__init__(pos)
self.type = type
self._may_be_none = may_be_none
self.assignments = []
def visit_Node(self):
- self.visitchildren(self)
+ self._visitchildren(self, None)
def visit_SingleAssignmentNode(self, node):
self.assignments.append((node.lhs, node.rhs))
class ControlFlowAnalysis(CythonTransform):
- in_inplace_assignment = False
def visit_ModuleNode(self, node):
self.gv_ctx = GVContext()
# Set of NameNode reductions
self.reductions = set()
+ self.in_inplace_assignment = False
self.env_stack = []
self.env = node.scope
self.stack = []
for arg in node.args:
if arg.default:
self.visitchildren(arg)
- self.visitchildren(node, attrs=('decorators',))
+ self.visitchildren(node, ('decorators',))
self.env_stack.append(self.env)
self.env = node.local_scope
self.stack.append(self.flow)
self.flow.nextblock()
for arg in node.args:
- self.visit(arg)
+ self._visit(arg)
if node.star_arg:
self.flow.mark_argument(node.star_arg,
TypedExprNode(Builtin.tuple_type,
TypedExprNode(Builtin.dict_type,
may_be_none=False),
node.starstar_arg.entry)
- self.visit(node.body)
+ self._visit(node.body)
# Workaround for generators
if node.is_generator:
- self.visit(node.gbody.body)
+ self._visit(node.gbody.body)
# Exit point
if self.flow.block:
for arg in lhs.args:
self.mark_assignment(arg)
else:
- self.visit(lhs)
+ self._visit(lhs)
if self.flow.exceptions:
exc_descr = self.flow.exceptions[-1]
raise InternalError, "Unhandled assignment node"
def visit_SingleAssignmentNode(self, node):
- self.visit(node.rhs)
+ self._visit(node.rhs)
self.mark_assignment(node.lhs, node.rhs)
return node
def visit_CascadedAssignmentNode(self, node):
- self.visit(node.rhs)
+ self._visit(node.rhs)
for lhs in node.lhs_list:
self.mark_assignment(lhs, node.rhs)
return node
collector = AssignmentCollector()
collector.visitchildren(node)
for lhs, rhs in collector.assignments:
- self.visit(rhs)
+ self._visit(rhs)
for lhs, rhs in collector.assignments:
self.mark_assignment(lhs, rhs)
return node
"can not delete variable '%s' "
"referenced in nested scope" % entry.name)
# Mark reference
- self.visit(arg)
+ self._visit(arg)
self.flow.mark_deletion(arg, entry)
return node
def visit_StatListNode(self, node):
if self.flow.block:
for stat in node.stats:
- self.visit(stat)
+ self._visit(stat)
if not self.flow.block:
stat.is_terminator = True
break
# If clauses
for clause in node.if_clauses:
parent = self.flow.nextblock(parent)
- self.visit(clause.condition)
+ self._visit(clause.condition)
self.flow.nextblock()
- self.visit(clause.body)
+ self._visit(clause.body)
if self.flow.block:
self.flow.block.add_child(next_block)
# Else clause
if node.else_clause:
self.flow.nextblock(parent=parent)
- self.visit(node.else_clause)
+ self._visit(node.else_clause)
if self.flow.block:
self.flow.block.add_child(next_block)
else:
next_block = self.flow.newblock()
# Condition block
self.flow.loops.append(LoopDescr(next_block, condition_block))
- self.visit(node.condition)
+ self._visit(node.condition)
# Body block
self.flow.nextblock()
- self.visit(node.body)
+ self._visit(node.body)
self.flow.loops.pop()
# Loop it
if self.flow.block:
# Else clause
if node.else_clause:
self.flow.nextblock(parent=condition_block)
- self.visit(node.else_clause)
+ self._visit(node.else_clause)
if self.flow.block:
self.flow.block.add_child(next_block)
else:
next_block = self.flow.newblock()
# Condition with iterator
self.flow.loops.append(LoopDescr(next_block, condition_block))
- self.visit(node.iterator)
+ self._visit(node.iterator)
# Target assignment
self.flow.nextblock()
self._delete_privates(node, exclude=node.target.entry)
self.flow.nextblock()
- self.visit(node.body)
+ self._visit(node.body)
self.flow.loops.pop()
# Loop it
# Else clause
if node.else_clause:
self.flow.nextblock(parent=condition_block)
- self.visit(node.else_clause)
+ self._visit(node.else_clause)
if self.flow.block:
self.flow.block.add_child(next_block)
else:
next_block = self.flow.newblock()
# Condition with iterator
self.flow.loops.append(LoopDescr(next_block, condition_block))
- self.visit(node.bound1)
- self.visit(node.bound2)
+ self._visit(node.bound1)
+ self._visit(node.bound2)
if node.step is not None:
- self.visit(node.step)
+ self._visit(node.step)
# Target assignment
self.flow.nextblock()
self.mark_assignment(node.target, node.bound1)
node.bound1, node.step))
# Body block
self.flow.nextblock()
- self.visit(node.body)
+ self._visit(node.body)
self.flow.loops.pop()
# Loop it
if self.flow.block:
# Else clause
if node.else_clause:
self.flow.nextblock(parent=condition_block)
- self.visit(node.else_clause)
+ self._visit(node.else_clause)
if self.flow.block:
self.flow.block.add_child(next_block)
else:
return node
def visit_WithStatNode(self, node):
- self.visit(node.manager)
- self.visit(node.enter_call)
- self.visit(node.body)
+ self._visit(node.manager)
+ self._visit(node.enter_call)
+ self._visit(node.body)
return node
def visit_TryExceptStatNode(self, node):
## XXX: links to exception handling point should be added by
## XXX: children nodes
self.flow.block.add_child(entry_point)
- self.visit(node.body)
+ self._visit(node.body)
self.flow.exceptions.pop()
# After exception
if self.flow.block:
if node.else_clause:
self.flow.nextblock()
- self.visit(node.else_clause)
+ self._visit(node.else_clause)
if self.flow.block:
self.flow.block.add_child(next_block)
self.flow.block = entry_point
if clause.pattern:
for pattern in clause.pattern:
- self.visit(pattern)
+ self._visit(pattern)
else:
# TODO: handle * pattern
pass
self.flow.nextblock()
if clause.target:
self.mark_assignment(clause.target)
- self.visit(clause.body)
+ self._visit(clause.body)
if self.flow.block:
self.flow.block.add_child(next_block)
# Exception entry point
entry_point = self.flow.newblock()
self.flow.block = entry_point
- self.visit(node.finally_clause)
+ self._visit(node.finally_clause)
if self.flow.block and self.flow.exceptions:
self.flow.block.add_child(self.flow.exceptions[-1].entry_point)
# Normal execution
finally_enter = self.flow.newblock()
self.flow.block = finally_enter
- self.visit(node.finally_clause)
+ self._visit(node.finally_clause)
finally_exit = self.flow.block
descr = ExceptionDescr(entry_point, finally_enter, finally_exit)
self.flow.block = body_block
## XXX: Is it still required
body_block.add_child(entry_point)
- self.visit(node.body)
+ self._visit(node.body)
self.flow.exceptions.pop()
if self.flow.loops:
self.flow.loops[-1].exceptions.pop()
self.env_stack.append(self.env)
self.env = node.expr_scope
# Skip append node here
- self.visit(node.target)
- self.visit(node.loop)
+ self._visit(node.target)
+ self._visit(node.loop)
if node.expr_scope:
self.env = self.env_stack.pop()
return node
return node
def visit_PyClassDefNode(self, node):
- self.visitchildren(node, attrs=('dict', 'metaclass',
- 'mkw', 'bases', 'class_result'))
+ self.visitchildren(node, ('dict', 'metaclass',
+ 'mkw', 'bases', 'class_result'))
self.flow.mark_assignment(node.target, object_expr_not_none,
self.env.lookup(node.name))
self.env_stack.append(self.env)
self.env = node.scope
self.flow.nextblock()
- self.visitchildren(node, attrs=('body',))
+ self.visitchildren(node, ('body',))
self.flow.nextblock()
self.env = self.env_stack.pop()
return node