[pypy-svn] r31943 - in pypy/dist/pypy/translator/transformer: . test
fijal at codespeak.net
fijal at codespeak.net
Sat Sep 2 12:59:37 CEST 2006
Author: fijal
Date: Sat Sep 2 12:59:35 2006
New Revision: 31943
Added:
pypy/dist/pypy/translator/transformer/
pypy/dist/pypy/translator/transformer/__init__.py (contents, props changed)
pypy/dist/pypy/translator/transformer/basictransform.py (contents, props changed)
pypy/dist/pypy/translator/transformer/test/
pypy/dist/pypy/translator/transformer/test/__init__.py (contents, props changed)
pypy/dist/pypy/translator/transformer/test/test_basictransform.py (contents, props changed)
Log:
Added really simple graph (after annotation) transformation helpers. This is extend of transform.py in some sense.
Added: pypy/dist/pypy/translator/transformer/__init__.py
==============================================================================
Added: pypy/dist/pypy/translator/transformer/basictransform.py
==============================================================================
--- (empty file)
+++ pypy/dist/pypy/translator/transformer/basictransform.py Sat Sep 2 12:59:35 2006
@@ -0,0 +1,145 @@
+
+""" basic transform - some play around graph transformations
+"""
+
+# this is RPython code which handles proper base elements for
+# stack tracing
+
+from pypy.translator import unsimplify, simplify
+from pypy.translator.unsimplify import varoftype
+from pypy.annotation import model as annmodel
+from pypy.objspace.flow import model
+from pypy.translator.js.helper import main_exception_helper, ExceptionHelper
+from pypy.rpython.ootypesystem import ootype
+from pypy.rpython.ootypesystem import rclass
+from pypy.rpython.annlowlevel import MixLevelHelperAnnotator
+
+class BasicTransformer(object):
+ """ This is basic transformer which applies after annotation level.
+ Some more high-level stuff defined here, needed for ie. changing
+ block operations, reflowing, etc. etc.
+ """
+ def __init__(self, translator):
+ # some shortcuts
+ self.translator = translator
+ self.annotator = translator.annotator
+ self.bookkeeper = self.annotator.bookkeeper
+
+ def genop(self, name, args):
+ """ Pass here (example, is_constant) list as args, you'll
+ get retval
+ """
+ real_args = []
+ bk = self.bookkeeper
+ for arg in args:
+ if isinstance(arg, (model.Constant, model.Variable)):
+ real_args.append(arg)
+ else:
+ arg_example, is_constant = arg
+ if is_constant:
+ real_args.append(model.Constant(arg_example, concretetype=bk.immutablevalue(arg_example)))
+ else:
+ real_args.append(model.Variable(bk.annotation_from_example(arg_example)))
+ retval = model.Variable()
+ return model.SpaceOperation(name, real_args, retval), retval
+
+ def add_block(self, graph, block):
+ ann = self.annotator
+ args_s = [ann.bindings[v] for v in block.inputargs]
+ try:
+ del ann.annotated[block]
+ except KeyError:
+ pass
+ ann.addpendingblock(graph, block, args_s)
+
+ def flow_method(self, _class, func_name, args):
+ ann = self.annotator
+ bk = self.bookkeeper
+ example_ann = bk.annotation_from_example
+ s_args = [example_ann(arg) for arg in args]
+ graph = ann.annotate_helper_method(_class, func_name, s_args)
+ return graph
+
+ def transform_all(self):
+ bk = self.translator.annotator.bookkeeper
+ for graph in self.translator.graphs:
+ self.transform_graph(graph)
+ self.translator.annotator.complete()
+
+##class Transformer(object):
+## def __init__(self, translator):
+## self.translator = translator
+## self.register_helpers()
+##
+## def register_helpers(self):
+## """ Flow necessary additional functions
+## """
+## ann = self.translator.annotator
+## bk = ann.bookkeeper
+##
+## for func_name, func_args in [("enter", [3]), ("leave", []),
+## ("traceback", [])]:
+## self.flow_exc_handler_method(func_name, func_args)
+## self.excdef = bk.getuniqueclassdef(ExceptionHelper)
+##
+## def flow_exc_handler_method(self, func_name, args):
+## ann = self.translator.annotator
+## example_ann = ann.bookkeeper.annotation_from_example
+## s_args = [example_ann(arg) for arg in args]
+## graph = ann.annotate_helper_method(ExceptionHelper, func_name, s_args)
+## graph.exception_handler_explicit = True
+##
+## def transform_graph(self, graph):
+## # XXX: we do not want to flow low level helpers as well
+## # but for now I do not see how to see them
+## ann = self.translator.annotator
+## if graph.name.startswith("ll_"):
+## return
+## if getattr(graph, 'exception_handler_explicit', False):
+## return
+## # for each graph block enter operation which calls apropriate functions
+## old_start_block = graph.startblock
+## new_start_block = model.Block(old_start_block.inputargs[:])
+## newoutputargs = [unsimplify.copyvar(ann, v)
+## for v in old_start_block.inputargs]
+##
+## mapping = {}
+## for old, new in zip(old_start_block.inputargs, newoutputargs):
+## mapping[old] = new
+## old_start_block.renamevariables(mapping)
+## new_start_block.closeblock(model.Link( \
+## new_start_block.inputargs, old_start_block))
+##
+## old_start_block.isstartblock = False
+## new_start_block.isstartblock = True
+##
+## self.add_start_operations(graph, new_start_block)
+##
+## args_s = [ann.bindings[v] for v in new_start_block.inputargs]
+## ann.addpendingblock(graph, new_start_block, args_s)
+## graph.startblock = new_start_block
+##
+## #simplify.simplify_graph(graph, [simplify.eliminate_empty_blocks,
+## # simplify.join_blocks,
+## # simplify.transform_dead_op_vars])
+##
+## #def add_same_as_operations(self, new_block, old_block, old_args, new_args):
+## # mapping = {}
+## # for old, new in zip(old_args, new_args):
+## # new_block.operations.append(model.SpaceOperation("same_as", [old], new))
+## # mapping[old] = new
+## # old_block.renamevariables(mapping)
+##
+## def add_start_operations(self, graph, block):
+## assert len(block.operations) == 0
+## retval = model.Variable()
+## bk = self.translator.annotator.bookkeeper
+## arg = model.Constant(bk.immutablevalue("enter"))
+## block.operations.append(model.SpaceOperation("getattr", [self.main_instance, arg], retval))
+##
+## def transform_all(self):
+## bk = self.translator.annotator.bookkeeper
+## self.main_instance = model.Constant(bk.immutablevalue(main_exception_helper))
+## for graph in self.translator.graphs:
+## self.transform_graph(graph)
+## self.translator.annotator.complete()
Added: pypy/dist/pypy/translator/transformer/test/__init__.py
==============================================================================
Added: pypy/dist/pypy/translator/transformer/test/test_basictransform.py
==============================================================================
--- (empty file)
+++ pypy/dist/pypy/translator/transformer/test/test_basictransform.py Sat Sep 2 12:59:35 2006
@@ -0,0 +1,95 @@
+
+""" test basic javascript transformation
+"""
+
+from pypy.translator.translator import TranslationContext, graphof
+from pypy.translator.transformer.basictransform import BasicTransformer
+from pypy import conftest
+from pypy.rpython import llinterp
+from pypy.objspace.flow import model
+from pypy.translator.unsimplify import copyvar
+
+def transform_function(transformerclass, fun, annotation=[], specialize=True,
+ type_system="ootype"):
+ t = TranslationContext()
+ annotator = t.buildannotator()
+ annotator.build_types(fun, annotation)
+ tran = transformerclass(t)
+ tran.transform_all()
+
+ if conftest.option.view:
+ t.view()
+
+ t.buildrtyper(type_system=type_system).specialize()
+
+ if conftest.option.view:
+ t.view()
+
+ return t
+
+def interp_fun(t, fun, args=[]):
+ graph = graphof(t, fun)
+ interp = llinterp.LLInterpreter(t.rtyper)
+ res = interp.eval_graph(graph, args)
+ return res
+
+class OpTransformer(BasicTransformer):
+ def transform_graph(self, graph):
+ block = graph.startblock
+ op, v = self.genop("add", [(1, True), (2, True)])
+ block.operations.append(op)
+ self.add_block(graph, block)
+ block.exits[0].args = [v]
+
+def test_genop():
+ def genop_fun(i1, i2):
+ return 1
+
+ t = transform_function(OpTransformer, genop_fun, [int, int])
+ res = interp_fun(t, genop_fun, [3, 2])
+ assert res == 3
+
+class BlockTransformer(BasicTransformer):
+ def transform_graph(self, graph):
+ block = model.Block(graph.startblock.inputargs[:])
+
+ old_start_block = graph.startblock
+ graph.startblock = block
+
+ block.isstartblock = True
+ old_start_block.isstartblock = False
+ op, v = self.genop("add", (block.inputargs[0], (1, True)))
+ block.operations.append(op)
+ block.closeblock(model.Link([v], old_start_block))
+
+ self.add_block(graph, block)
+
+ old_start_block.renamevariables({block.inputargs[0]:
+ copyvar(self.annotator, block.inputargs[0])})
+
+def test_change_startblock():
+ def some_fun(i):
+ return i
+
+ t = transform_function(BlockTransformer, some_fun, [int])
+ res = interp_fun(t, some_fun, [1])
+ assert res == 2
+
+##def test_transform():
+## def fun(i):
+## a = 3 + i
+## b = a - 1
+## return b
+##
+## def wrapper(i):
+## retval = fun(i)
+## return retval, main_exception_helper.traceback()
+##
+## t = transform_function(wrapper, [int])
+## res = interp_fun(t, wrapper, [3])
+## retval = res._items['item0']
+## traceback = res._items['item1']
+## real_traceback = [i._str for i in traceback._list]
+## assert retval == fun(3)
+## assert len(real_traceback) == 3
+## # XXX: to be fixed as basic_transform continues to grow
More information about the Pypy-commit
mailing list