def test_IRScope(self):
filename = "<?>"
top = ir.Scope(parent=None, loc=ir.Loc(filename=filename, line=1))
local = ir.Scope(parent=top, loc=ir.Loc(filename=filename, line=2))
apple = local.define('apple', loc=ir.Loc(filename=filename, line=3))
self.assertTrue(local.get('apple') is apple)
self.assertEqual(len(local.localvars), 1)
orange = top.define('orange', loc=ir.Loc(filename=filename, line=4))
self.assertEqual(len(local.localvars), 1)
self.assertEqual(len(top.localvars), 1)
self.assertTrue(top.get('orange') is orange)
self.assertTrue(local.get('orange') is orange)
more_orange = local.define('orange', loc=ir.Loc(filename=filename,
line=5))
self.assertTrue(top.get('orange') is orange)
self.assertTrue(local.get('orange') is not orange)
self.assertTrue(local.get('orange') is more_orange)
try:
bad_orange = local.define('orange', loc=ir.Loc(filename=filename,
line=5))
except ir.RedefinedError:
pass
else:
self.fail("Expecting an %s" % ir.RedefinedError)
def __init__(self, bytecode):
self.bytecode = bytecode
self.scopes = []
self.loc = ir.Loc(filename=bytecode.filename, line=1)
self.argspec = bytecode.argspec
# Control flow analysis
self.cfa = controlflow.ControlFlowAnalysis(bytecode)
self.cfa.run()
# Data flow analysis
self.dfa = dataflow.DataFlowAnalysis(self.cfa)
self.dfa.run()
global_scope = ir.Scope(parent=None, loc=self.loc)
self._fill_global_scope(global_scope)
self.scopes.append(global_scope)
# { inst offset : ir.Block }
self.blocks = {}
# { name: value } of global variables used by the bytecode
self.used_globals = {}
self.definitions = collections.defaultdict(list)
# Temp states during interpretation
self.current_block = None
self.current_block_offset = None
self.syntax_blocks = []
self.dfainfo = None
def __init__(self, bytecode):
self.bytecode = bytecode
self.scopes = []
self.loc = ir.Loc(filename=bytecode.filename, line=1)
self.argspec = bytecode.argspec
# Control flow analysis
self.cfa = controlflow.ControlFlowAnalysis(bytecode)
self.cfa.run()
# Data flow analysis
self.dfa = dataflow.DataFlowAnalysis(self.cfa)
self.dfa.run()
global_scope = ir.Scope(parent=None, loc=self.loc)
self._fill_global_scope(global_scope)
self.scopes.append(global_scope)
# { inst offset : ir.Block }
self.blocks = {}
self.syntax_info = []
# Temp states during interpretation
self.current_block = None
self.current_block_offset = None
self.syntax_blocks = []
self.dfainfo = None
self._block_actions = {}
self.constants = {}
def __init__(self, bytecode):
self.bytecode = bytecode
self.scopes = []
self.loc = ir.Loc(filename=bytecode.filename, line=1)
self.argspec = bytecode.argspec
# Control flow analysis
self.cfa = controlflow.ControlFlowAnalysis(bytecode)
self.cfa.run()
# Data flow analysis
self.dfa = dataflow.DataFlowAnalysis(self.cfa)
self.dfa.run()
global_scope = ir.Scope(parent=None, loc=self.loc)
self._fill_global_scope(global_scope)
self.scopes.append(global_scope)
# { inst offset : ir.Block }
self.blocks = {}
# { name: value } of global variables used by the bytecode
self.used_globals = {}
# { name: [definitions] } of local variables
self.definitions = collections.defaultdict(list)
# { ir.Block: { variable names (potentially) alive at start of block } }
self.block_entry_vars = {}
if self.bytecode.is_generator:
self.generator_info = GeneratorInfo()
else:
self.generator_info = None
# Temp states during interpretation
self.current_block = None
self.current_block_offset = None
self.syntax_blocks = []
self.dfainfo = None
def test_var(self):
a = ir.Var(None, 'foo', self.loc1)
b = ir.Var(None, 'foo', self.loc1)
c = ir.Var(None, 'foo', self.loc2)
d = ir.Var(ir.Scope(None, ir.unknown_loc), 'foo', self.loc1)
e = ir.Var(None, 'bar', self.loc1)
self.check(a, same=[b, c, d], different=[e])
def gen_block():
parent = ir.Scope(None, self.loc1)
tmp = ir.Block(parent, self.loc2)
assign1 = ir.Assign(self.var_a, self.var_b, self.loc3)
assign2 = ir.Assign(self.var_a, self.var_c, self.loc3)
assign3 = ir.Assign(self.var_c, self.var_b, self.loc3)
tmp.append(assign1)
tmp.append(assign2)
tmp.append(assign3)
return tmp
def interpret(self):
firstblk = min(self.cfa.blocks.keys())
self.loc = ir.Loc(filename=self.bytecode.filename,
line=self.bytecode[firstblk].lineno)
self.scopes.append(ir.Scope(parent=self.current_scope, loc=self.loc))
self._fill_args_into_scope(self.current_scope)
# Interpret loop
for inst, kws in self._iter_inst():
self._dispatch(inst, kws)
# Clean up
self._insert_var_dels()
def interpret(self):
firstblk = min(self.cfa.blocks.keys())
self.loc = ir.Loc(filename=self.bytecode.filename,
line=self.bytecode[firstblk].lineno)
self.scopes.append(ir.Scope(parent=self.current_scope, loc=self.loc))
# Interpret loop
for inst, kws in self._iter_inst():
self._dispatch(inst, kws)
# Post-processing and analysis on generated IR
self._insert_var_dels()
self._compute_live_variables()
if self.generator_info:
self._compute_generator_info()
def test_scope(self):
parent1 = ir.Scope(None, self.loc1)
parent2 = ir.Scope(None, self.loc1)
parent3 = ir.Scope(None, self.loc2)
self.check(parent1, same=[parent2, parent3,])
a = ir.Scope(parent1, self.loc1)
b = ir.Scope(parent1, self.loc1)
c = ir.Scope(parent1, self.loc2)
d = ir.Scope(parent3, self.loc1)
self.check(a, same=[b, c, d])
# parent1 and parent2 are equal, so children referring to either parent
# should be equal
e = ir.Scope(parent2, self.loc1)
self.check(a, same=[e,])
