diff options
Diffstat (limited to 'tool/src/test/java/org/antlr/test/TestTreeGrammarRewriteAST.java')
| -rw-r--r-- | tool/src/test/java/org/antlr/test/TestTreeGrammarRewriteAST.java | 1121 |
1 files changed, 1121 insertions, 0 deletions
diff --git a/tool/src/test/java/org/antlr/test/TestTreeGrammarRewriteAST.java b/tool/src/test/java/org/antlr/test/TestTreeGrammarRewriteAST.java new file mode 100644 index 0000000..518e48a --- /dev/null +++ b/tool/src/test/java/org/antlr/test/TestTreeGrammarRewriteAST.java @@ -0,0 +1,1121 @@ +/* + * [The "BSD license"] + * Copyright (c) 2010 Terence Parr + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package org.antlr.test; + +import org.antlr.Tool; +import org.antlr.codegen.CodeGenerator; +import org.antlr.runtime.RecognitionException; +import org.antlr.tool.ErrorManager; +import org.antlr.tool.Grammar; +import org.antlr.tool.GrammarSyntaxMessage; +import org.junit.Ignore; +import org.junit.Test; + +/** Tree rewrites in tree parsers are basically identical to rewrites + * in a normal grammar except that the atomic element is a node not + * a Token. Tests here ensure duplication of nodes occurs properly + * and basic functionality. + */ +public class TestTreeGrammarRewriteAST extends BaseTest { + protected boolean debug = false; + + @Test public void testFlatList() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT;\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "a : ID INT -> INT ID\n" + + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "abc 34"); + assertEquals("34 abc\n", found); + } + + @Test public void testSimpleTree() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT -> ^(ID INT);\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "a : ^(ID INT) -> ^(INT ID)\n" + + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "abc 34"); + assertEquals("(34 abc)\n", found); + } + + @Test public void testNonImaginaryWithCtor() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : INT ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "a : INT -> INT[\"99\"]\n" + // make new INT node + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "34"); + assertEquals("99\n", found); + } + + @Test public void testCombinedRewriteAndAuto() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT -> ^(ID INT) | INT ;\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "a : ^(ID INT) -> ^(INT ID) | INT\n" + + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "abc 34"); + assertEquals("(34 abc)\n", found); + + found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "34"); + assertEquals("34\n", found); + } + + @Test public void testAvoidDup() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID ;\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "a : ID -> ^(ID ID)\n" + + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "abc"); + assertEquals("(abc abc)\n", found); + } + + @Test public void testLoop() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID+ INT+ -> (^(ID INT))+ ;\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "a : (^(ID INT))+ -> INT+ ID+\n" + + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "a b c 3 4 5"); + assertEquals("3 4 5 a b c\n", found); + } + + @Test public void testAutoDup() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID ;\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "a : ID \n" + + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "abc"); + assertEquals("abc\n", found); + } + + @Test public void testAutoDupRule() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT ;\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "a : b c ;\n" + + "b : ID ;\n" + + "c : INT ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "a 1"); + assertEquals("a 1\n", found); + } + + @Test public void testAutoWildcard() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT ;\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "a : ID . \n" + + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "abc 34"); + assertEquals("abc 34\n", found); + } + + @Test public void testNoWildcardAsRootError() throws Exception { + ErrorQueue equeue = new ErrorQueue(); + ErrorManager.setErrorListener(equeue); + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST;}\n" + + "a : ^(. INT) \n" + + " ;\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; + RecognitionException expectedExc = null; + GrammarSyntaxMessage expectedMessage = + new GrammarSyntaxMessage(expectedMsgID, g, null, expectedArg, expectedExc); + + checkError(equeue, expectedMessage); + } + + @Test public void testAutoWildcard2() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT -> ^(ID INT);\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "a : ^(ID .) \n" + + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "abc 34"); + assertEquals("(abc 34)\n", found); + } + + @Test public void testAutoWildcardWithLabel() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT ;\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "a : ID c=. \n" + + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "abc 34"); + assertEquals("abc 34\n", found); + } + + @Test public void testAutoWildcardWithListLabel() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT ;\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "a : ID c+=. \n" + + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "abc 34"); + assertEquals("abc 34\n", found); + } + + @Test public void testAutoDupMultiple() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID ID INT;\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "a : ID ID INT\n" + + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "a b 3"); + assertEquals("a b 3\n", found); + } + + @Test public void testAutoDupTree() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT -> ^(ID INT);\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "a : ^(ID INT)\n" + + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "a 3"); + assertEquals("(a 3)\n", found); + } + + @Test public void testAutoDupTree2() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT INT -> ^(ID INT INT);\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "a : ^(ID b b)\n" + + " ;\n" + + "b : INT ;"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "a 3 4"); + assertEquals("(a 3 4)\n", found); + } + + @Test public void testAutoDupTreeWithLabels() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT -> ^(ID INT);\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "a : ^(x=ID y=INT)\n" + + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "a 3"); + assertEquals("(a 3)\n", found); + } + + @Test public void testAutoDupTreeWithListLabels() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT -> ^(ID INT);\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "a : ^(x+=ID y+=INT)\n" + + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "a 3"); + assertEquals("(a 3)\n", found); + } + + @Test public void testAutoDupTreeWithRuleRoot() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT -> ^(ID INT);\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "a : ^(b INT) ;\n" + + "b : ID ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "a 3"); + assertEquals("(a 3)\n", found); + } + + @Test public void testAutoDupTreeWithRuleRootAndLabels() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT -> ^(ID INT);\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "a : ^(x=b INT) ;\n" + + "b : ID ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "a 3"); + assertEquals("(a 3)\n", found); + } + + @Test public void testAutoDupTreeWithRuleRootAndListLabels() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT -> ^(ID INT);\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "a : ^(x+=b y+=c) ;\n" + + "b : ID ;\n" + + "c : INT ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "a 3"); + assertEquals("(a 3)\n", found); + } + + @Test public void testAutoDupNestedTree() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : x=ID y=ID INT -> ^($x ^($y INT));\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "a : ^(ID ^(ID INT))\n" + + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "a b 3"); + assertEquals("(a (b 3))\n", found); + } + + @Test public void testAutoDupTreeWithSubruleInside() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "tokens {OP;}\n" + + "a : (x=ID|x=INT) -> ^(OP $x) ;\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "a : ^(OP (b|c)) ;\n" + + "b : ID ;\n" + + "c : INT ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "a"); + assertEquals("(OP a)\n", found); + } + + @Test public void testDelete() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID ;\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "a : ID -> \n" + + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "abc"); + assertEquals("", found); + } + + @Test public void testSetMatchNoRewrite() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT ;\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "a : b INT\n" + + " ;\n" + + "b : ID | INT ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "abc 34"); + assertEquals("abc 34\n", found); + } + + @Test public void testSetOptionalMatchNoRewrite() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT ;\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "a : (ID|INT)? INT ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "abc 34"); + assertEquals("abc 34\n", found); + } + + + @Test public void testSetMatchNoRewriteLevel2() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : x=ID INT -> ^($x INT);\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "a : ^(ID (ID | INT) ) ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "abc 34"); + assertEquals("(abc 34)\n", found); + } + + @Test public void testSetMatchNoRewriteLevel2Root() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : x=ID INT -> ^($x INT);\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "a : ^((ID | INT) INT) ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "abc 34"); + assertEquals("(abc 34)\n", found); + } + + + // REWRITE MODE + + @Test public void testRewriteModeCombinedRewriteAndAuto() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT -> ^(ID INT) | INT ;\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;}\n" + + "a : ^(ID INT) -> ^(ID[\"ick\"] INT)\n" + + " | INT\n" + // leaves it alone, returning $a.start + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "abc 34"); + assertEquals("(ick 34)\n", found); + + found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "34"); + assertEquals("34\n", found); + } + + @Test public void testRewriteModeFlatTree() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT -> ID INT | INT ;\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;}\n" + + "s : ID a ;\n" + + "a : INT -> INT[\"1\"]\n"+ + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "s", "abc 34"); + assertEquals("abc 1\n", found); + } + + @Test public void testRewriteModeChainRuleFlatTree() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT -> ID INT | INT ;\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;}\n" + + "s : a ;\n" + + "a : b ;\n" + + "b : ID INT -> INT ID\n"+ + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "s", "abc 34"); + assertEquals("34 abc\n", found); + } + + @Test public void testRewriteModeChainRuleTree() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT -> ^(ID INT) ;\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;}\n" + + "s : a ;\n" + + "a : b ;\n" + // a.tree must become b.tree + "b : ^(ID INT) -> INT\n"+ + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "s", "abc 34"); + assertEquals("34\n", found); + } + + @Test public void testRewriteModeChainRuleTree2() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT -> ^(ID INT) ;\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;}\n" + + "tokens { X; }\n" + + "s : a* b ;\n" + // only b contributes to tree, but it's after a*; s.tree = b.tree + "a : X ;\n" + + "b : ^(ID INT) -> INT\n"+ + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "s", "abc 34"); + assertEquals("34\n", found); + } + + @Test public void testRewriteModeChainRuleTree3() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : 'boo' ID INT -> 'boo' ^(ID INT) ;\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;}\n" + + "tokens { X; }\n" + + "s : 'boo' a* b ;\n" + // don't reset s.tree to b.tree due to 'boo' + "a : X ;\n" + + "b : ^(ID INT) -> INT\n"+ + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "s", "boo abc 34"); + assertEquals("boo 34\n", found); + } + + @Test public void testRewriteModeChainRuleTree4() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : 'boo' ID INT -> ^('boo' ^(ID INT)) ;\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;}\n" + + "tokens { X; }\n" + + "s : ^('boo' a* b) ;\n" + // don't reset s.tree to b.tree due to 'boo' + "a : X ;\n" + + "b : ^(ID INT) -> INT\n"+ + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "s", "boo abc 34"); + assertEquals("(boo 34)\n", found); + } + + @Test public void testRewriteModeChainRuleTree5() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : 'boo' ID INT -> ^('boo' ^(ID INT)) ;\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;}\n" + + "tokens { X; }\n" + + "s : ^(a b) ;\n" + // s.tree is a.tree + "a : 'boo' ;\n" + + "b : ^(ID INT) -> INT\n"+ + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "s", "boo abc 34"); + assertEquals("(boo 34)\n", found); + } + + @Test public void testRewriteOfRuleRef() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT -> ID INT | INT ;\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;}\n" + + "s : a -> a ;\n" + + "a : ID INT -> ID INT ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "s", "abc 34"); + assertEquals("abc 34\n", found); + } + + @Test public void testRewriteOfRuleRefRoot() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT INT -> ^(INT ^(ID INT));\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;}\n" + + "s : ^(a ^(ID INT)) -> a ;\n" + + "a : INT ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "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. + assertEquals("(12 (abc 34))\n", found); + } + + @Test public void testRewriteOfRuleRefRootLabeled() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT INT -> ^(INT ^(ID INT));\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;}\n" + + "s : ^(label=a ^(ID INT)) -> a ;\n" + + "a : INT ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "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. + assertEquals("(12 (abc 34))\n", found); + } + + @Ignore + @Test public void testRewriteOfRuleRefRootListLabeled() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT INT -> ^(INT ^(ID INT));\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;}\n" + + "s : ^(label+=a ^(ID INT)) -> a ;\n" + + "a : INT ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "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. + assertEquals("(12 (abc 34))\n", found); + } + + @Test public void testRewriteOfRuleRefChild() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT -> ^(ID ^(INT INT));\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;}\n" + + "s : ^(ID a) -> a ;\n" + + "a : ^(INT INT) ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "s", "abc 34"); + assertEquals("(34 34)\n", found); + } + + @Test public void testRewriteOfRuleRefLabel() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT -> ^(ID ^(INT INT));\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;}\n" + + "s : ^(ID label=a) -> a ;\n" + + "a : ^(INT INT) ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "s", "abc 34"); + assertEquals("(34 34)\n", found); + } + + @Test public void testRewriteOfRuleRefListLabel() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT -> ^(ID ^(INT INT));\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;}\n" + + "s : ^(ID label+=a) -> a ;\n" + + "a : ^(INT INT) ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "s", "abc 34"); + assertEquals("(34 34)\n", found); + } + + @Test public void testRewriteModeWithPredicatedRewrites() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT -> ^(ID[\"root\"] ^(ID INT)) | INT -> ^(ID[\"root\"] INT) ;\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;}\n" + + "s : ^(ID a) {System.out.println(\"altered tree=\"+$s.start.toStringTree());};\n" + + "a : ^(ID INT) -> {true}? ^(ID[\"ick\"] INT)\n" + + " -> INT\n" + + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "s", "abc 34"); + assertEquals("altered tree=(root (ick 34))\n" + + "(root (ick 34))\n", found); + } + + @Test public void testWildcardSingleNode() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT -> ^(ID[\"root\"] INT);\n"+ + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "s : ^(ID c=.) -> $c\n" + + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "s", "abc 34"); + assertEquals("34\n", found); + } + + @Test public void testWildcardUnlabeledSingleNode() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID INT -> ^(ID INT);\n"+ + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "s : ^(ID .) -> ID\n" + + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "s", "abc 34"); + assertEquals("abc\n", found); + } + + @Test public void testWildcardGrabsSubtree() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID x=INT y=INT z=INT -> ^(ID[\"root\"] ^($x $y $z));\n"+ + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "s : ^(ID c=.) -> $c\n" + + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "s", "abc 1 2 3"); + assertEquals("(1 2 3)\n", found); + } + + @Test public void testWildcardGrabsSubtree2() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID x=INT y=INT z=INT -> ID ^($x $y $z);\n"+ + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "s : ID c=. -> $c\n" + + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "s", "abc 1 2 3"); + assertEquals("(1 2 3)\n", found); + } + + @Test public void testWildcardListLabel() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : INT INT INT ;\n"+ + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "s : (c+=.)+ -> $c+\n" + + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "s", "1 2 3"); + assertEquals("1 2 3\n", found); + } + + @Test public void testWildcardListLabel2() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST; ASTLabelType=CommonTree;}\n" + + "a : x=INT y=INT z=INT -> ^($x ^($y $z) ^($y $z));\n"+ + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; ASTLabelType=CommonTree; tokenVocab=T; rewrite=true;}\n" + + "s : ^(INT (c+=.)+) -> $c+\n" + + " ;\n"; + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "s", "1 2 3"); + assertEquals("(2 3) (2 3)\n", found); + } + + @Test public void testRuleResultAsRoot() throws Exception { + String grammar = + "grammar T;\n" + + "options {output=AST;}\n" + + "a : ID '=' INT -> ^('=' ID INT);\n" + + "ID : 'a'..'z'+ ;\n" + + "INT : '0'..'9'+;\n" + + "COLON : ':' ;\n" + + "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; + + String treeGrammar = + "tree grammar TP;\n"+ + "options {output=AST; rewrite=true; ASTLabelType=CommonTree; tokenVocab=T;}\n" + + "a : ^(eq e1=ID e2=.) -> ^(eq $e2 $e1) ;\n" + + "eq : '=' | ':' {;} ;\n"; // bug in set match, doesn't add to tree!! booh. force nonset. + + String found = execTreeParser("T.g", grammar, "TParser", "TP.g", + treeGrammar, "TP", "TLexer", "a", "a", "abc = 34"); + assertEquals("(= 34 abc)\n", found); + } + +} |