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 )