def flatten (self, node):
"""Takes an AST as input, and then "flattens" the tree into a list of statements."""
if isinstance(node, While):
#statement
flatbody = self.flatten(node.body)
#expression
# the first element in the tuple is an expression, so it needs flattened.
var0, flattest0 = self.flatten(node.test[0])
# the second selement is a stmt node.
stmt = self.flatten(node.test[1])
# the statements associated with the newly flattened expression (node.test[0]),
# have to be run AFTER the statements in node.test[1]
stmt.nodes = stmt.nodes + flattest0
return [While((var0,stmt), flatbody, [], node.lineno)]
elif isinstance(node, If):
# flatten the "test" expression
vartes, test = self.flatten(node.tests[0][0])
# flatten the "then" and "else" statements
then = self.flatten(node.tests[0][1])
else_ = self.flatten(node.else_)
# NOTE: The If node has two attributes: "tests" and "else_". The tests attribute is
# a list of tuples, where the first element in the tuple is the test expression and the
# second element in the tuple is a Stmt object. Each tuple in the list corresponds to
# an "if" or "elif" clause. The else_ attribute is a Stmt object corresponding to the
# "else" clause.
self.log.debug('then=%s' % then)
self.log.debug('else_=%s' % then)
return test + [If([(vartes, then)], else_)]
else:
return P2Flattener.flatten(self, node)
def flatten(self, node):
"""Takes an AST as input, and then "flattens" the tree into a list of statements."""
if isinstance(node, While):
#statement
flatbody = self.flatten(node.body)
#expression
# the first element in the tuple is an expression, so it needs flattened.
var0, flattest0 = self.flatten(node.test[0])
# the second selement is a stmt node.
stmt = self.flatten(node.test[1])
# the statements associated with the newly flattened expression (node.test[0]),
# have to be run AFTER the statements in node.test[1]
stmt.nodes = stmt.nodes + flattest0
return [While((var0, stmt), flatbody, [], node.lineno)]
elif isinstance(node, If):
# flatten the "test" expression
vartes, test = self.flatten(node.tests[0][0])
# flatten the "then" and "else" statements
then = self.flatten(node.tests[0][1])
else_ = self.flatten(node.else_)
# NOTE: The If node has two attributes: "tests" and "else_". The tests attribute is
# a list of tuples, where the first element in the tuple is the test expression and the
# second element in the tuple is a Stmt object. Each tuple in the list corresponds to
# an "if" or "elif" clause. The else_ attribute is a Stmt object corresponding to the
# "else" clause.
self.log.debug('then=%s' % then)
self.log.debug('else_=%s' % then)
return test + [If([(vartes, then)], else_)]
else:
return P2Flattener.flatten(self, node)
from p2heapify import P2Heapify
from p2closureconvert import P2ClosureConversion
from p2flattener import P2Flattener
from p2insselector import P2InstructionSelector
from p2regallocator import P2RegAllocator
from p2ifinsselector import P2IfInstructionSelector
if len(sys.argv) < 2:
sys.exit(1)
testcases = sys.argv[1:]
for testcase in testcases:
varalloc = VariableAllocator()
p2unique = P2UniquifyVars()
p2explicator = P2Explicate(varalloc)
p2heap = P2Heapify(p2explicator)
p2closure = P2ClosureConversion(p2explicator, varalloc)
p2flatten = P2Flattener(varalloc)
p2insselector = P2InstructionSelector(varalloc)
ifinsselector = P2IfInstructionSelector(varalloc,
p2insselector.labelalloc)
ast = compiler.parseFile(testcase)
unique = p2unique.transform(ast)
explicated = p2explicator.explicate(unique)
heaped = p2heap.transform(explicated)
astlist = p2closure.transform(heaped)
for ast in astlist:
ast = p2flatten.flatten(ast)
program = p2insselector.transform(ast)
p2regallocator = P2RegAllocator(program, varalloc)
program = p2regallocator.substitute()
program = ifinsselector.visit(program)
def __init__ (self, varalloc, validate=False):
P2Flattener.__init__(self, varalloc)
self.validate = validate
def __init__(self, varalloc, validate=False):
P2Flattener.__init__(self, varalloc)
self.validate = validate
