resurrect term spans. provide trace hook for grammar execution.

Author: Allen Short

bin/stage

@@ -5,7 +5,7 @@ import os
 import glob
 import shutil
 from ometa.runtime import ParseError
-from ometa.grammar import OMeta
+from ometa.grammar import OMeta, TreeTransformerGrammar
 from ometa.builder import writePython
 
 
@@ -38,9 +38,12 @@ def stage_pkg(parsley_dir, stage_dir, pkg):
         pyfn = os.path.join(stage_gen_dir, grammarname + '.py')
         print "{src:38} => {dst}".format(src=os.path.relpath(filename, parsley_dir),
                                          dst=os.path.relpath(pyfn, parsley_dir))
-        g = OMeta(grammar)
+        if grammar.startswith('#TreeTransformer'):
+            g = TreeTransformerGrammar(grammar)
+        else:
+            g = OMeta(grammar)
         tree = g.parseGrammar(grammarname)
-        source = writePython(tree)
+        source = writePython(tree, grammar)
         pythonFile = open(pyfn, 'w')
         pythonFile.write(source)
 

ometa/_generated/parsley.py

@@ -5,10 +5,13 @@ class parsley_termactions(GrammarBase):
         def rule_ruleValue(self):
             _locals = {'self': self}
             self.locals['ruleValue'] = _locals
+            self._trace(' ws', (11, 14), self.input.position)
             _G_apply_1, lastError = self._apply(self.rule_ws, "ws", [])
             self.considerError(lastError, 'ruleValue')
+            self._trace(" '->'", (14, 19), self.input.position)
             _G_exactly_2, lastError = self.exactly('->')
             self.considerError(lastError, 'ruleValue')
+            self._trace(' term', (19, 24), self.input.position)
             _G_apply_3, lastError = self._apply(self.rule_term, "term", [])
             self.considerError(lastError, 'ruleValue')
             _locals['tt'] = _G_apply_3
@@ -20,15 +23,20 @@ def rule_ruleValue(self):
         def rule_semanticPredicate(self):
             _locals = {'self': self}
             self.locals['semanticPredicate'] = _locals
+            self._trace(' ws', (64, 67), self.input.position)
             _G_apply_5, lastError = self._apply(self.rule_ws, "ws", [])
             self.considerError(lastError, 'semanticPredicate')
+            self._trace(" '?('", (67, 72), self.input.position)
             _G_exactly_6, lastError = self.exactly('?(')
             self.considerError(lastError, 'semanticPredicate')
+            self._trace(' term', (72, 77), self.input.position)
             _G_apply_7, lastError = self._apply(self.rule_term, "term", [])
             self.considerError(lastError, 'semanticPredicate')
             _locals['tt'] = _G_apply_7
+            self._trace(' ws', (80, 83), self.input.position)
             _G_apply_8, lastError = self._apply(self.rule_ws, "ws", [])
             self.considerError(lastError, 'semanticPredicate')
+            self._trace(" ')'", (83, 87), self.input.position)
             _G_exactly_9, lastError = self.exactly(')')
             self.considerError(lastError, 'semanticPredicate')
             _G_python_10, lastError = eval('t.Predicate(tt)', self.globals, _locals), None
@@ -39,15 +47,20 @@ def rule_semanticPredicate(self):
         def rule_semanticAction(self):
             _locals = {'self': self}
             self.locals['semanticAction'] = _locals
+            self._trace(' ws', (124, 127), self.input.position)
             _G_apply_11, lastError = self._apply(self.rule_ws, "ws", [])
             self.considerError(lastError, 'semanticAction')
+            self._trace(" '!('", (127, 132), self.input.position)
             _G_exactly_12, lastError = self.exactly('!(')
             self.considerError(lastError, 'semanticAction')
+            self._trace(' term', (132, 137), self.input.position)
             _G_apply_13, lastError = self._apply(self.rule_term, "term", [])
             self.considerError(lastError, 'semanticAction')
             _locals['tt'] = _G_apply_13
+            self._trace(' ws', (140, 143), self.input.position)
             _G_apply_14, lastError = self._apply(self.rule_ws, "ws", [])
             self.considerError(lastError, 'semanticAction')
+            self._trace(" ')'", (143, 147), self.input.position)
             _G_exactly_15, lastError = self.exactly(')')
             self.considerError(lastError, 'semanticAction')
             _G_python_16, lastError = eval('t.Action(tt)', self.globals, _locals), None
@@ -59,22 +72,27 @@ def rule_application(self):
             _locals = {'self': self}
             self.locals['application'] = _locals
             def _G_optional_17():
+                self._trace(' indentation', (178, 190), self.input.position)
                 _G_apply_18, lastError = self._apply(self.rule_indentation, "indentation", [])
                 self.considerError(lastError, None)
                 return (_G_apply_18, self.currentError)
             def _G_optional_19():
                 return (None, self.input.nullError())
             _G_or_20, lastError = self._or([_G_optional_17, _G_optional_19])
             self.considerError(lastError, 'application')
+            self._trace(' name', (191, 196), self.input.position)
             _G_apply_21, lastError = self._apply(self.rule_name, "name", [])
             self.considerError(lastError, 'application')
             _locals['name'] = _G_apply_21
             def _G_or_22():
+                self._trace("'('", (221, 224), self.input.position)
                 _G_exactly_23, lastError = self.exactly('(')
                 self.considerError(lastError, None)
+                self._trace(' term_arglist', (224, 237), self.input.position)
                 _G_apply_24, lastError = self._apply(self.rule_term_arglist, "term_arglist", [])
                 self.considerError(lastError, None)
                 _locals['args'] = _G_apply_24
+                self._trace(" ')'", (242, 246), self.input.position)
                 _G_exactly_25, lastError = self.exactly(')')
                 self.considerError(lastError, None)
                 _G_python_26, lastError = eval('t.Apply(name, self.rulename, args)', self.globals, _locals), None