diff options
Diffstat (limited to 'runtime/Python/tests/t051treeRewriteAST.py')
| -rw-r--r-- | runtime/Python/tests/t051treeRewriteAST.py | 1593 |
1 files changed, 1593 insertions, 0 deletions
diff --git a/runtime/Python/tests/t051treeRewriteAST.py b/runtime/Python/tests/t051treeRewriteAST.py new file mode 100644 index 0000000..39253b4 --- /dev/null +++ b/runtime/Python/tests/t051treeRewriteAST.py @@ -0,0 +1,1593 @@ +import unittest +import textwrap +import antlr3 +import antlr3.tree +import testbase + +class T(testbase.ANTLRTest): + def walkerClass(self, base): + class TWalker(base): + def __init__(self, *args, **kwargs): + base.__init__(self, *args, **kwargs) + self.buf = "" + + def traceIn(self, ruleName, ruleIndex): + self.traces.append('>'+ruleName) + + + def traceOut(self, ruleName, ruleIndex): + self.traces.append('<'+ruleName) + + + def recover(self, input, re): + # no error recovery yet, just crash! + raise + + return TWalker + + + def execTreeParser(self, grammar, grammarEntry, treeGrammar, treeEntry, input): + lexerCls, parserCls = self.compileInlineGrammar(grammar) + walkerCls = self.compileInlineGrammar(treeGrammar) + + cStream = antlr3.StringStream(input) + lexer = lexerCls(cStream) + tStream = antlr3.CommonTokenStream(lexer) + parser = parserCls(tStream) + r = getattr(parser, grammarEntry)() + nodes = antlr3.tree.CommonTreeNodeStream(r.tree) + nodes.setTokenStream(tStream) + walker = walkerCls(nodes) + r = getattr(walker, treeEntry)() + + if r.tree is not None: + return r.tree.toStringTree() + + return "" + + + def testFlatList(self): + grammar = textwrap.dedent( + r''' + grammar T1; + options { + language=Python; + output=AST; + } + a : ID INT; + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP1; + options { + language=Python; + output=AST; + ASTLabelType=CommonTree; + tokenVocab=T1; + } + + a : ID INT -> INT ID; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 'a', + "abc 34" + ) + + self.failUnlessEqual("34 abc", found) + + + def testSimpleTree(self): + grammar = textwrap.dedent( + r''' + grammar T2; + options { + language=Python; + output=AST; + } + a : ID INT -> ^(ID INT); + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP2; + options { + language=Python; + output=AST; + ASTLabelType=CommonTree; + tokenVocab=T2; + } + a : ^(ID INT) -> ^(INT ID); + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 'a', + "abc 34" + ) + + self.failUnlessEqual("(34 abc)", found) + + + def testCombinedRewriteAndAuto(self): + grammar = textwrap.dedent( + r''' + grammar T3; + options { + language=Python; + output=AST; + } + a : ID INT -> ^(ID INT) | INT ; + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP3; + options { + language=Python; + output=AST; + ASTLabelType=CommonTree; + tokenVocab=T3; + } + a : ^(ID INT) -> ^(INT ID) | INT; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 'a', + "abc 34" + ) + + self.failUnlessEqual("(34 abc)", found) + + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 'a', + "34" + ) + + self.failUnlessEqual("34", found) + + + def testAvoidDup(self): + grammar = textwrap.dedent( + r''' + grammar T4; + options { + language=Python; + output=AST; + } + a : ID ; + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP4; + options { + language=Python; + output=AST; + ASTLabelType=CommonTree; + tokenVocab=T4; + } + a : ID -> ^(ID ID); + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 'a', + "abc" + ) + + self.failUnlessEqual("(abc abc)", found) + + + def testLoop(self): + grammar = textwrap.dedent( + r''' + grammar T5; + options { + language=Python; + output=AST; + } + a : ID+ INT+ -> (^(ID INT))+ ; + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP5; + options { + language=Python; + output=AST; + ASTLabelType=CommonTree; + tokenVocab=T5; + } + a : (^(ID INT))+ -> INT+ ID+; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 'a', + "a b c 3 4 5" + ) + + self.failUnlessEqual("3 4 5 a b c", found) + + + def testAutoDup(self): + grammar = textwrap.dedent( + r''' + grammar T6; + options { + language=Python; + output=AST; + } + a : ID ; + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP6; + options { + language=Python; + output=AST; + ASTLabelType=CommonTree; + tokenVocab=T6; + } + a : ID; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 'a', + "abc" + ) + + self.failUnlessEqual("abc", found) + + + def testAutoDupRule(self): + grammar = textwrap.dedent( + r''' + grammar T7; + options { + language=Python; + output=AST; + } + a : ID INT ; + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP7; + options { + language=Python; + output=AST; + ASTLabelType=CommonTree; + tokenVocab=T7; + } + a : b c ; + b : ID ; + c : INT ; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 'a', + "a 1" + ) + + self.failUnlessEqual("a 1", found) + + + def testAutoWildcard(self): + grammar = textwrap.dedent( + r''' + grammar T; + options {language=Python;output=AST;} + a : ID INT ; + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP; + options {language=Python;output=AST; ASTLabelType=CommonTree; tokenVocab=T;} + a : ID . + ; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 'a', + "abc 34") + self.assertEquals("abc 34", found) + + +# def testNoWildcardAsRootError(self): +# ErrorQueue equeue = new ErrorQueue(); +# ErrorManager.setErrorListener(equeue); +# > +# String treeGrammar = +# "tree grammar TP;\n"+ +# "options {language=Python;output=AST;} +# "a : ^(. INT) +# " ;\n"; +# > +# Grammar g = new Grammar(treeGrammar); +# Tool antlr = newTool(); +# antlr.setOutputDirectory(null); // write to /dev/null +# CodeGenerator generator = new CodeGenerator(antlr, g, "Java"); +# g.setCodeGenerator(generator); +# generator.genRecognizer(); +# > +# assertEquals("unexpected errors: "+equeue, 1, equeue.errors.size()); +# > +# int expectedMsgID = ErrorManager.MSG_WILDCARD_AS_ROOT; +# Object expectedArg = null; +# antlr.RecognitionException expectedExc = null; +# GrammarSyntaxMessage expectedMessage = +# new GrammarSyntaxMessage(expectedMsgID, g, null, expectedArg, expectedExc); +# > +# checkError(equeue, expectedMessage); +# } + + def testAutoWildcard2(self): + grammar = textwrap.dedent( + r''' + grammar T; + options {language=Python;output=AST;} + a : ID INT -> ^(ID INT); + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP; + options {language=Python;output=AST; ASTLabelType=CommonTree; tokenVocab=T;} + a : ^(ID .) + ; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 'a', + "abc 34") + self.assertEquals("(abc 34)", found) + + + def testAutoWildcardWithLabel(self): + grammar = textwrap.dedent( + r''' + grammar T; + options {language=Python;output=AST;} + a : ID INT ; + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP; + options {language=Python;output=AST; ASTLabelType=CommonTree; tokenVocab=T;} + a : ID c=. + ; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 'a', + "abc 34") + self.assertEquals("abc 34", found) + + + def testAutoWildcardWithListLabel(self): + grammar = textwrap.dedent( + r''' + grammar T; + options {language=Python;output=AST;} + a : ID INT ; + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP; + options {language=Python;output=AST; ASTLabelType=CommonTree; tokenVocab=T;} + a : ID c+=. + ; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 'a', + "abc 34") + self.assertEquals("abc 34", found) + + + def testAutoDupMultiple(self): + grammar = textwrap.dedent( + r''' + grammar T8; + options { + language=Python; + output=AST; + } + a : ID ID INT; + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP8; + options { + language=Python; + output=AST; + ASTLabelType=CommonTree; + tokenVocab=T8; + } + a : ID ID INT + ; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 'a', + "a b 3" + ) + + self.failUnlessEqual("a b 3", found) + + + def testAutoDupTree(self): + grammar = textwrap.dedent( + r''' + grammar T9; + options { + language=Python; + output=AST; + } + a : ID INT -> ^(ID INT); + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP9; + options { + language=Python; + output=AST; + ASTLabelType=CommonTree; + tokenVocab=T9; + } + a : ^(ID INT) + ; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 'a', + "a 3" + ) + + self.failUnlessEqual("(a 3)", found) + + + def testAutoDupTreeWithLabels(self): + grammar = textwrap.dedent( + r''' + grammar T10; + options { + language=Python; + output=AST; + } + a : ID INT -> ^(ID INT); + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP10; + options { + language=Python; + output=AST; + ASTLabelType=CommonTree; + tokenVocab=T10; + } + a : ^(x=ID y=INT) + ; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 'a', + "a 3" + ) + + self.failUnlessEqual("(a 3)", found) + + + def testAutoDupTreeWithListLabels(self): + grammar = textwrap.dedent( + r''' + grammar T11; + options { + language=Python; + output=AST; + } + a : ID INT -> ^(ID INT); + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP11; + options { + language=Python; + output=AST; + ASTLabelType=CommonTree; + tokenVocab=T11; + } + a : ^(x+=ID y+=INT) + ; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 'a', + "a 3" + ) + + self.failUnlessEqual("(a 3)", found) + + + def testAutoDupTreeWithRuleRoot(self): + grammar = textwrap.dedent( + r''' + grammar T12; + options { + language=Python; + output=AST; + } + a : ID INT -> ^(ID INT); + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP12; + options { + language=Python; + output=AST; + ASTLabelType=CommonTree; + tokenVocab=T12; + } + a : ^(b INT) ; + b : ID ; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 'a', + "a 3" + ) + + self.failUnlessEqual("(a 3)", found) + + + def testAutoDupTreeWithRuleRootAndLabels(self): + grammar = textwrap.dedent( + r''' + grammar T13; + options { + language=Python; + output=AST; + } + a : ID INT -> ^(ID INT); + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP13; + options { + language=Python; + output=AST; + ASTLabelType=CommonTree; + tokenVocab=T13; + } + a : ^(x=b INT) ; + b : ID ; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 'a', + "a 3" + ) + + self.failUnlessEqual("(a 3)", found) + + + def testAutoDupTreeWithRuleRootAndListLabels(self): + grammar = textwrap.dedent( + r''' + grammar T14; + options { + language=Python; + output=AST; + } + a : ID INT -> ^(ID INT); + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP14; + options { + language=Python; + output=AST; + ASTLabelType=CommonTree; + tokenVocab=T14; + } + a : ^(x+=b y+=c) ; + b : ID ; + c : INT ; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 'a', + "a 3" + ) + + self.failUnlessEqual("(a 3)", found) + + + def testAutoDupNestedTree(self): + grammar = textwrap.dedent( + r''' + grammar T15; + options { + language=Python; + output=AST; + } + a : x=ID y=ID INT -> ^($x ^($y INT)); + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP15; + options { + language=Python; + output=AST; + ASTLabelType=CommonTree; + tokenVocab=T15; + } + a : ^(ID ^(ID INT)) + ; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 'a', + "a b 3" + ) + + self.failUnlessEqual("(a (b 3))", found) + + + def testDelete(self): + grammar = textwrap.dedent( + r''' + grammar T16; + options { + language=Python; + output=AST; + } + a : ID ; + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP16; + options { + language=Python; + output=AST; + ASTLabelType=CommonTree; + tokenVocab=T16; + } + a : ID -> + ; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 'a', + "abc" + ) + + self.failUnlessEqual("", found) + + def testSetMatchNoRewrite(self): + grammar = textwrap.dedent( + r''' + grammar T; + options { + language=Python; + output=AST; + } + a : ID INT ; + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP; + options { + language=Python; + output=AST; + ASTLabelType=CommonTree; + tokenVocab=T; + } + a : b INT; + b : ID | INT; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 'a', + "abc 34" + ) + + self.failUnlessEqual("abc 34", found) + + + def testSetOptionalMatchNoRewrite(self): + grammar = textwrap.dedent( + r''' + grammar T; + options { + language=Python; + output=AST; + } + a : ID INT ; + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP; + options { + language=Python; + output=AST; + ASTLabelType=CommonTree; + tokenVocab=T; + } + a : (ID|INT)? INT ; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 'a', + "abc 34") + + self.failUnlessEqual("abc 34", found) + + + def testSetMatchNoRewriteLevel2(self): + grammar = textwrap.dedent( + r''' + grammar T; + options { + language=Python; + output=AST; + } + a : x=ID INT -> ^($x INT); + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP; + options { + language=Python; + output=AST; + ASTLabelType=CommonTree; + tokenVocab=T; + } + a : ^(ID (ID | INT) ) ; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 'a', + "abc 34" + ) + + self.failUnlessEqual("(abc 34)", found) + + + def testSetMatchNoRewriteLevel2Root(self): + grammar = textwrap.dedent( + r''' + grammar T; + options { + language=Python; + output=AST; + } + a : x=ID INT -> ^($x INT); + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP; + options { + language=Python; + output=AST; + ASTLabelType=CommonTree; + tokenVocab=T; + } + a : ^((ID | INT) INT) ; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 'a', + "abc 34" + ) + + self.failUnlessEqual("(abc 34)", found) + + + ## REWRITE MODE + + def testRewriteModeCombinedRewriteAndAuto(self): + grammar = textwrap.dedent( + r''' + grammar T17; + options { + language=Python; + output=AST; + } + a : ID INT -> ^(ID INT) | INT ; + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP17; + options { + language=Python; + output=AST; + ASTLabelType=CommonTree; + tokenVocab=T17; + rewrite=true; + } + a : ^(ID INT) -> ^(ID["ick"] INT) + | INT // leaves it alone, returning $a.start + ; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 'a', + "abc 34" + ) + + self.failUnlessEqual("(ick 34)", found) + + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 'a', + "34" + ) + + self.failUnlessEqual("34", found) + + + def testRewriteModeFlatTree(self): + grammar = textwrap.dedent( + r''' + grammar T18; + options { + language=Python; + output=AST; + } + a : ID INT -> ID INT | INT ; + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP18; + options { + language=Python; + output=AST; + ASTLabelType=CommonTree; + tokenVocab=T18; + rewrite=true; + } + s : ID a ; + a : INT -> INT["1"] + ; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 's', + "abc 34" + ) + self.assertEquals("abc 1", found) + + + def testRewriteModeChainRuleFlatTree(self): + grammar = textwrap.dedent( + r''' + grammar T; + options {language=Python; output=AST;} + a : ID INT -> ID INT | INT ; + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP; + options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;} + s : a ; + a : b ; + b : ID INT -> INT ID + ; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 's', + "abc 34") + self.assertEquals("34 abc", found) + + + def testRewriteModeChainRuleTree(self): + grammar = textwrap.dedent( + r''' + grammar T; + options {language=Python; output=AST;} + a : ID INT -> ^(ID INT) ; + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP; + options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;} + s : a ; + a : b ; // a.tree must become b.tree + b : ^(ID INT) -> INT + ; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 's', + "abc 34") + self.assertEquals("34", found) + + + def testRewriteModeChainRuleTree2(self): + grammar = textwrap.dedent( + r''' + grammar T; + options {language=Python; output=AST;} + a : ID INT -> ^(ID INT) ; + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r""" + tree grammar TP; + options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;} + tokens { X; } + s : a* b ; // only b contributes to tree, but it's after a*; s.tree = b.tree + a : X ; + b : ^(ID INT) -> INT + ; + """) + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 's', + "abc 34") + self.assertEquals("34", found) + + + def testRewriteModeChainRuleTree3(self): + grammar = textwrap.dedent( + r''' + grammar T; + options {language=Python; output=AST;} + a : 'boo' ID INT -> 'boo' ^(ID INT) ; + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r""" + tree grammar TP; + options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;} + tokens { X; } + s : 'boo' a* b ; // don't reset s.tree to b.tree due to 'boo' + a : X ; + b : ^(ID INT) -> INT + ; + """) + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 's', + "boo abc 34") + self.assertEquals("boo 34", found) + + + def testRewriteModeChainRuleTree4(self): + grammar = textwrap.dedent( + r""" + grammar T; + options {language=Python; output=AST;} + a : 'boo' ID INT -> ^('boo' ^(ID INT)) ; + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\n') {$channel=HIDDEN;} ; + """) + + treeGrammar = textwrap.dedent( + r""" + tree grammar TP; + options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;} + tokens { X; } + s : ^('boo' a* b) ; // don't reset s.tree to b.tree due to 'boo' + a : X ; + b : ^(ID INT) -> INT + ; + """) + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 's', + "boo abc 34") + self.assertEquals("(boo 34)", found) + + + def testRewriteModeChainRuleTree5(self): + grammar = textwrap.dedent( + r""" + grammar T; + options {language=Python; output=AST;} + a : 'boo' ID INT -> ^('boo' ^(ID INT)) ; + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\n') {$channel=HIDDEN;} ; + """) + + treeGrammar = textwrap.dedent( + r""" + tree grammar TP; + options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;} + tokens { X; } + s : ^(a b) ; // s.tree is a.tree + a : 'boo' ; + b : ^(ID INT) -> INT + ; + """) + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 's', + "boo abc 34") + self.assertEquals("(boo 34)", found) + + + def testRewriteOfRuleRef(self): + grammar = textwrap.dedent( + r""" + grammar T; + options {language=Python; output=AST;} + a : ID INT -> ID INT | INT ; + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\n') {$channel=HIDDEN;} ; + """) + + treeGrammar = textwrap.dedent( + r""" + tree grammar TP; + options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;} + s : a -> a ; + a : ID INT -> ID INT ; + """) + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 's', + "abc 34") + self.failUnlessEqual("abc 34", found) + + + def testRewriteOfRuleRefRoot(self): + grammar = textwrap.dedent( + r""" + grammar T; + options {language=Python; output=AST;} + a : ID INT INT -> ^(INT ^(ID INT)); + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\n') {$channel=HIDDEN;} ; + """) + + treeGrammar = textwrap.dedent( + r""" + tree grammar TP; + options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;} + s : ^(a ^(ID INT)) -> a ; + a : INT ; + """) + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 's', + "abc 12 34") + # emits whole tree when you ref the root since I can't know whether + # you want the children or not. You might be returning a whole new + # tree. Hmm...still seems weird. oh well. + self.failUnlessEqual("(12 (abc 34))", found) + + + def testRewriteOfRuleRefRootLabeled(self): + grammar = textwrap.dedent( + r""" + grammar T; + options {language=Python; output=AST;} + a : ID INT INT -> ^(INT ^(ID INT)); + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\n') {$channel=HIDDEN;} ; + """) + + treeGrammar = textwrap.dedent( + r""" + tree grammar TP; + options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;} + s : ^(label=a ^(ID INT)) -> a ; + a : INT ; + """) + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 's', + "abc 12 34") + # emits whole tree when you ref the root since I can't know whether + # you want the children or not. You might be returning a whole new + # tree. Hmm...still seems weird. oh well. + self.failUnlessEqual("(12 (abc 34))", found) + + + def testRewriteOfRuleRefRootListLabeled(self): + grammar = textwrap.dedent( + r""" + grammar T; + options {language=Python; output=AST;} + a : ID INT INT -> ^(INT ^(ID INT)); + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\n') {$channel=HIDDEN;} ; + """) + + treeGrammar = textwrap.dedent( + r""" + tree grammar TP; + options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;} + s : ^(label+=a ^(ID INT)) -> a ; + a : INT ; + """) + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 's', + "abc 12 34") + # emits whole tree when you ref the root since I can't know whether + # you want the children or not. You might be returning a whole new + # tree. Hmm...still seems weird. oh well. + self.failUnlessEqual("(12 (abc 34))", found) + + + def testRewriteOfRuleRefChild(self): + grammar = textwrap.dedent( + r""" + grammar T; + options {language=Python; output=AST;} + a : ID INT -> ^(ID ^(INT INT)); + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\n') {$channel=HIDDEN;} ; + """) + + treeGrammar = textwrap.dedent( + r""" + tree grammar TP; + options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;} + s : ^(ID a) -> a ; + a : ^(INT INT) ; + """) + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 's', + "abc 34") + self.failUnlessEqual("(34 34)", found) + + + def testRewriteOfRuleRefLabel(self): + grammar = textwrap.dedent( + r""" + grammar T; + options {language=Python; output=AST;} + a : ID INT -> ^(ID ^(INT INT)); + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\n') {$channel=HIDDEN;} ; + """) + + treeGrammar = textwrap.dedent( + r""" + tree grammar TP; + options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;} + s : ^(ID label=a) -> a ; + a : ^(INT INT) ; + """) + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 's', + "abc 34") + self.failUnlessEqual("(34 34)", found) + + + def testRewriteOfRuleRefListLabel(self): + grammar = textwrap.dedent( + r""" + grammar T; + options {language=Python; output=AST;} + a : ID INT -> ^(ID ^(INT INT)); + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\n') {$channel=HIDDEN;} ; + """) + + treeGrammar = textwrap.dedent( + r""" + tree grammar TP; + options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;} + s : ^(ID label+=a) -> a ; + a : ^(INT INT) ; + """) + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 's', + "abc 34") + self.failUnlessEqual("(34 34)", found) + + + + def testRewriteModeWithPredicatedRewrites(self): + grammar = textwrap.dedent( + r''' + grammar T19; + options { + language=Python; + output=AST; + } + a : ID INT -> ^(ID["root"] ^(ID INT)) | INT -> ^(ID["root"] INT) ; + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP19; + options { + language=Python; + output=AST; + ASTLabelType=CommonTree; + tokenVocab=T19; + rewrite=true; + } + s : ^(ID a) { self.buf += $s.start.toStringTree() }; + a : ^(ID INT) -> {True}? ^(ID["ick"] INT) + -> INT + ; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 's', + "abc 34" + ) + + self.failUnlessEqual("(root (ick 34))", found) + + + def testWildcardSingleNode(self): + grammar = textwrap.dedent( + r''' + grammar T; + options { + language=Python; + output=AST; + } + a : ID INT -> ^(ID["root"] INT); + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP; + options { + language=Python; + output=AST; + ASTLabelType=CommonTree; + tokenVocab=T; + } + s : ^(ID c=.) -> $c + ; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 's', + "abc 34" + ) + + self.failUnlessEqual("34", found) + + def testWildcardUnlabeledSingleNode(self): + grammar = textwrap.dedent( + r''' + grammar T; + options {language=Python; output=AST;} + a : ID INT -> ^(ID INT); + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP; + options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T;} + s : ^(ID .) -> ID + ; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 's', + "abc 34") + self.assertEquals("abc", found) + + + def testWildcardGrabsSubtree(self): + grammar = textwrap.dedent( + r''' + grammar T; + options {language=Python; output=AST;} + a : ID x=INT y=INT z=INT -> ^(ID[\"root\"] ^($x $y $z)); + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP; + options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T;} + s : ^(ID c=.) -> $c + ; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 's', + "abc 1 2 3") + self.assertEquals("(1 2 3)", found) + + + def testWildcardGrabsSubtree2(self): + grammar = textwrap.dedent( + r''' + grammar T; + options {language=Python; output=AST;} + a : ID x=INT y=INT z=INT -> ID ^($x $y $z); + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP; + options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T;} + s : ID c=. -> $c + ; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 's', + "abc 1 2 3") + self.assertEquals("(1 2 3)", found) + + + def testWildcardListLabel(self): + grammar = textwrap.dedent( + r''' + grammar T; + options {language=Python; output=AST;} + a : INT INT INT ; + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP; + options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T;} + s : (c+=.)+ -> $c+ + ; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 's', + "1 2 3") + self.assertEquals("1 2 3", found) + + + def testWildcardListLabel2(self): + grammar = textwrap.dedent( + r''' + grammar T; + options {language=Python; output=AST; ASTLabelType=CommonTree;} + a : x=INT y=INT z=INT -> ^($x ^($y $z) ^($y $z)); + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + WS : (' '|'\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP; + options {language=Python; output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;} + s : ^(INT (c+=.)+) -> $c+ + ; + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 's', + "1 2 3") + self.assertEquals("(2 3) (2 3)", found) + + + def testRuleResultAsRoot(self): + grammar = textwrap.dedent( + r''' + grammar T; + options { + language=Python; + output=AST; + } + a : ID '=' INT -> ^('=' ID INT); + ID : 'a'..'z'+ ; + INT : '0'..'9'+; + COLON : ':' ; + WS : (' '|'\n') {$channel=HIDDEN;} ; + ''') + + treeGrammar = textwrap.dedent( + r''' + tree grammar TP; + options { + language=Python; + output=AST; + rewrite=true; + ASTLabelType=CommonTree; + tokenVocab=T; + } + a : ^(eq e1=ID e2=.) -> ^(eq $e2 $e1) ; + eq : '=' | ':' {pass} ; // bug in set match, doesn't add to tree!! booh. force nonset. + ''') + + found = self.execTreeParser( + grammar, 'a', + treeGrammar, 'a', + "abc = 34") + self.assertEquals("(= 34 abc)", found) + + +if __name__ == '__main__': + unittest.main() |