def test_bfs_large(self):
tree = Node.Node(
1, Node.Node(2, None, Node.Node(4, Node.Node(7, None, None),
None)),
Node.Node(
3, Node.Node(5, None, None),
Node.Node(6, None, Node.Node(8, Node.Node(9, None, None),
None))))
self.assertEqual(TreeOperations.breadth_first_search(tree),
[1, 2, 3, 4, 5, 6, 7, 8, 9])
def __call__( self, node ):
if node.isFunctionCall():
called = node.getCalledExpression()
if called.isVariableReference():
variable = called.getVariable()
if variable.isModuleVariable():
var_name = variable.getName()
if var_name in self.replacements:
replacement_extractor = self.replacements[ var_name ]
new_node = replacement_extractor( node )
if new_node is not None:
node.replaceWith( new_node = new_node )
if new_node.isStatement() and node.parent.isStatementExpression():
node.parent.replaceWith( new_node )
TreeOperations.assignParent( node.parent )
def test_max_depth_2_right(self):
tree = Node.Node(5, None, Node.Node(3, None, None))
self.assertEqual(2, TreeOperations.maximum_depth(tree))
def test_max_depth_1(self):
tree = Node.Node(5, None, None)
self.assertEqual(1, TreeOperations.maximum_depth(tree))
def test_max_depth_empty(self):
self.assertEqual(0, TreeOperations.maximum_depth(None))
def test_preorder_both(self):
tree = Node.Node(5, Node.Node(4, None, None), Node.Node(3, None, None))
self.assertEqual(TreeOperations.pre_order(tree), [5, 4, 3])
def test_preorder_left(self):
tree = Node.Node(5, Node.Node(4, None, None), None)
self.assertEqual(TreeOperations.pre_order(tree), [5, 4])
def test_preorder_empty(self):
self.assertEqual(TreeOperations.pre_order(None), [])
def test_preorder_automatically(self):
for _ in range(0, 1000):
t, l = gen_tree(7)
self.assertEqual(TreeOperations.pre_order(t), l)
def test_bfs_both(self):
tree = Node.Node(5, Node.Node(4, None, None), Node.Node(3, None, None))
self.assertEqual(TreeOperations.breadth_first_search(tree), [5, 4, 3])
def test_bfs_root(self):
tree = Node.Node(5, None, None)
self.assertEqual(TreeOperations.breadth_first_search(tree), [5])
def test_bfs_empty(self):
self.assertEqual(TreeOperations.breadth_first_search(None), [])
def _prepareCodeGeneration( tree ):
visitor = _PrepareCodeGenerationVisitor()
TreeOperations.visitTree( tree, visitor )
def checkOverflowNeed( node ):
visitor = _OverflowCheckVisitor()
TreeOperations.visitScope( node, visitor )
return visitor.getResult()
def replaceBuiltinsCallsThatRequireInterpreter( tree, future_flags ):
def _pickLocalsForNode( node ):
provider = node.getParentVariableProvider()
if provider.isModule():
return Nodes.CPythonExpressionBuiltinCallGlobals(
source_ref = node.getSourceReference()
)
else:
return Nodes.CPythonExpressionBuiltinCallLocals(
source_ref = node.getSourceReference()
)
def _pickGlobalsForNode( node ):
return Nodes.CPythonExpressionBuiltinCallGlobals(
source_ref = node.getSourceReference()
)
def globals_extractor( node ):
assert node.isEmptyCall()
return _pickGlobalsForNode( node )
def locals_extractor( node ):
assert node.isEmptyCall()
return _pickLocalsForNode( node )
def dir_extractor( node ):
# Only treat the empty dir() call, leave the others alone for now.
if not node.isEmptyCall():
return None
return Nodes.CPythonExpressionBuiltinCallDir(
source_ref = node.getSourceReference()
)
def vars_extractor( node ):
assert node.hasOnlyPositionalArguments()
positional_args = node.getPositionalArguments()
if len( positional_args ) == 0:
return Nodes.CPythonExpressionBuiltinCallLocals(
source_ref = node.getSourceReference()
)
elif len( positional_args ) == 1:
return Nodes.CPythonExpressionBuiltinCallVars(
source = positional_args[ 0 ],
source_ref = node.getSourceReference()
)
else:
assert False
def eval_extractor( node ):
assert node.hasOnlyPositionalArguments()
positional_args = node.getPositionalArguments()
return Nodes.CPythonExpressionBuiltinCallEval (
source = positional_args[0],
globals_arg = positional_args[1] if len( positional_args ) > 1 else None,
locals_arg = positional_args[2] if len( positional_args ) > 2 else None,
mode = "eval",
future_flags = future_flags,
source_ref = node.getSourceReference()
)
def execfile_extractor( node ):
assert node.parent.isStatementExpression()
assert node.hasOnlyPositionalArguments()
positional_args = node.getPositionalArguments()
source_ref = node.getSourceReference()
source_node = Nodes.CPythonExpressionFunctionCall(
called_expression = Nodes.CPythonExpressionAttributeLookup(
expression = Nodes.CPythonExpressionBuiltinCallOpen(
filename = positional_args[0],
mode = Nodes.CPythonExpressionConstant(
constant = "rU",
source_ref = source_ref
),
buffering = None,
source_ref = source_ref
),
attribute = "read",
source_ref = source_ref
),
positional_args = (),
named_args = (),
list_star_arg = None,
dict_star_arg = None,
source_ref = source_ref
)
return Nodes.CPythonStatementExec(
source = source_node,
globals_arg = positional_args[1] if len( positional_args ) > 1 else None,
locals_arg = positional_args[2] if len( positional_args ) > 2 else None,
future_flags = future_flags,
source_ref = source_ref
)
visitor = TreeVisitorReplaceBuiltinCalls(
replacements = {
"globals" : globals_extractor,
"locals" : locals_extractor,
"dir" : dir_extractor,
"vars" : vars_extractor,
"eval" : eval_extractor,
"execfile" : execfile_extractor
}
)
TreeOperations.visitTree( tree, visitor )
visitor = TreeVisitorFixupNewStaticmethod()
TreeOperations.visitTree( tree, visitor )
def replaceConstantExecs( tree, build_node ):
visitor = TreeVisitorOptimizeStaticExec( build_node )
TreeOperations.visitTree( tree, visitor )
