| /* |
| * [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.junit.Test; |
| |
| public class TestSyntacticPredicateEvaluation extends BaseTest { |
| @Test public void testTwoPredsWithNakedAlt() throws Exception { |
| String grammar = |
| "grammar T;\n" + |
| "s : (a ';')+ ;\n" + |
| "a\n" + |
| "options {\n" + |
| " k=1;\n" + |
| "}\n" + |
| " : (b '.')=> b '.' {System.out.println(\"alt 1\");}\n" + |
| " | (b)=> b {System.out.println(\"alt 2\");}\n" + |
| " | c {System.out.println(\"alt 3\");}\n" + |
| " ;\n" + |
| "b\n" + |
| "@init {System.out.println(\"enter b\");}\n" + |
| " : '(' 'x' ')' ;\n" + |
| "c\n" + |
| "@init {System.out.println(\"enter c\");}\n" + |
| " : '(' c ')' | 'x' ;\n" + |
| "WS : (' '|'\\n')+ {$channel=HIDDEN;}\n" + |
| " ;\n" ; |
| String found = execParser("T.g", grammar, "TParser", "TLexer", |
| "a", "(x) ;", false); |
| String expecting = |
| "enter b\n" + |
| "enter b\n" + |
| "enter b\n" + |
| "alt 2\n"; |
| assertEquals(expecting, found); |
| |
| found = execParser("T.g", grammar, "TParser", "TLexer", |
| "a", "(x). ;", false); |
| expecting = |
| "enter b\n" + |
| "enter b\n" + |
| "alt 1\n"; |
| assertEquals(expecting, found); |
| |
| found = execParser("T.g", grammar, "TParser", "TLexer", |
| "a", "((x)) ;", false); |
| expecting = |
| "enter b\n" + |
| "enter b\n" + |
| "enter c\n" + |
| "enter c\n" + |
| "enter c\n" + |
| "alt 3\n"; |
| assertEquals(expecting, found); |
| } |
| |
| @Test public void testTwoPredsWithNakedAltNotLast() throws Exception { |
| String grammar = |
| "grammar T;\n" + |
| "s : (a ';')+ ;\n" + |
| "a\n" + |
| "options {\n" + |
| " k=1;\n" + |
| "}\n" + |
| " : (b '.')=> b '.' {System.out.println(\"alt 1\");}\n" + |
| " | c {System.out.println(\"alt 2\");}\n" + |
| " | (b)=> b {System.out.println(\"alt 3\");}\n" + |
| " ;\n" + |
| "b\n" + |
| "@init {System.out.println(\"enter b\");}\n" + |
| " : '(' 'x' ')' ;\n" + |
| "c\n" + |
| "@init {System.out.println(\"enter c\");}\n" + |
| " : '(' c ')' | 'x' ;\n" + |
| "WS : (' '|'\\n')+ {$channel=HIDDEN;}\n" + |
| " ;\n" ; |
| String found = execParser("T.g", grammar, "TParser", "TLexer", |
| "a", "(x) ;", false); |
| String expecting = |
| "enter b\n" + |
| "enter c\n" + |
| "enter c\n" + |
| "alt 2\n"; |
| assertEquals(expecting, found); |
| |
| found = execParser("T.g", grammar, "TParser", "TLexer", |
| "a", "(x). ;", false); |
| expecting = |
| "enter b\n" + |
| "enter b\n" + |
| "alt 1\n"; |
| assertEquals(expecting, found); |
| |
| found = execParser("T.g", grammar, "TParser", "TLexer", |
| "a", "((x)) ;", false); |
| expecting = |
| "enter b\n" + |
| "enter c\n" + |
| "enter c\n" + |
| "enter c\n" + |
| "alt 2\n"; |
| assertEquals(expecting, found); |
| } |
| |
| @Test public void testLexerPred() throws Exception { |
| String grammar = |
| "grammar T;\n" + |
| "s : A ;\n" + |
| "A options {k=1;}\n" + // force backtracking |
| " : (B '.')=>B '.' {System.out.println(\"alt1\");}\n" + |
| " | B {System.out.println(\"alt2\");}" + |
| " ;\n" + |
| "fragment\n" + |
| "B : 'x'+ ;\n" ; |
| String found = execParser("T.g", grammar, "TParser", "TLexer", |
| "s", "xxx", false); |
| |
| assertEquals("alt2\n", found); |
| |
| found = execParser("T.g", grammar, "TParser", "TLexer", |
| "s", "xxx.", false); |
| |
| assertEquals("alt1\n", found); |
| } |
| |
| @Test public void testLexerWithPredLongerThanAlt() throws Exception { |
| String grammar = |
| "grammar T;\n" + |
| "s : A ;\n" + |
| "A options {k=1;}\n" + // force backtracking |
| " : (B '.')=>B {System.out.println(\"alt1\");}\n" + |
| " | B {System.out.println(\"alt2\");}" + |
| " ;\n" + |
| "D : '.' {System.out.println(\"D\");} ;\n" + |
| "fragment\n" + |
| "B : 'x'+ ;\n" ; |
| String found = execParser("T.g", grammar, "TParser", "TLexer", |
| "s", "xxx", false); |
| |
| assertEquals("alt2\n", found); |
| |
| found = execParser("T.g", grammar, "TParser", "TLexer", |
| "s", "xxx.", false); |
| |
| assertEquals("alt1\nD\n", found); |
| } |
| |
| @Test public void testLexerPredCyclicPrediction() throws Exception { |
| String grammar = |
| "grammar T;\n" + |
| "s : A ;\n" + |
| "A : (B)=>(B|'y'+) {System.out.println(\"alt1\");}\n" + |
| " | B {System.out.println(\"alt2\");}\n" + |
| " | 'y'+ ';'" + |
| " ;\n" + |
| "fragment\n" + |
| "B : 'x'+ ;\n" ; |
| String found = execParser("T.g", grammar, "TParser", "TLexer", |
| "s", "xxx", false); |
| |
| assertEquals("alt1\n", found); |
| } |
| |
| @Test public void testLexerPredCyclicPrediction2() throws Exception { |
| String grammar = |
| "grammar T;\n" + |
| "s : A ;\n" + |
| "A : (B '.')=>(B|'y'+) {System.out.println(\"alt1\");}\n" + |
| " | B {System.out.println(\"alt2\");}\n" + |
| " | 'y'+ ';'" + |
| " ;\n" + |
| "fragment\n" + |
| "B : 'x'+ ;\n" ; |
| String found = execParser("T.g", grammar, "TParser", "TLexer", |
| "s", "xxx", false); |
| assertEquals("alt2\n", found); |
| } |
| |
| @Test public void testSimpleNestedPred() throws Exception { |
| String grammar = |
| "grammar T;\n" + |
| "s : (expr ';')+ ;\n" + |
| "expr\n" + |
| "options {\n" + |
| " k=1;\n" + |
| "}\n" + |
| "@init {System.out.println(\"enter expr \"+input.LT(1).getText());}\n" + |
| " : (atom 'x') => atom 'x'\n" + |
| " | atom\n" + |
| ";\n" + |
| "atom\n" + |
| "@init {System.out.println(\"enter atom \"+input.LT(1).getText());}\n" + |
| " : '(' expr ')'\n" + |
| " | INT\n" + |
| " ;\n" + |
| "INT: '0'..'9'+ ;\n" + |
| "WS : (' '|'\\n')+ {$channel=HIDDEN;}\n" + |
| " ;\n" ; |
| String found = execParser("T.g", grammar, "TParser", "TLexer", |
| "s", "(34)x;", false); |
| String expecting = |
| "enter expr (\n" + |
| "enter atom (\n" + |
| "enter expr 34\n" + |
| "enter atom 34\n" + |
| "enter atom 34\n" + |
| "enter atom (\n" + |
| "enter expr 34\n" + |
| "enter atom 34\n" + |
| "enter atom 34\n"; |
| assertEquals(expecting, found); |
| } |
| |
| @Test public void testTripleNestedPredInLexer() throws Exception { |
| String grammar = |
| "grammar T;\n" + |
| "s : (.)+ {System.out.println(\"done\");} ;\n" + |
| "EXPR\n" + |
| "options {\n" + |
| " k=1;\n" + |
| "}\n" + |
| "@init {System.out.println(\"enter expr \"+(char)input.LT(1));}\n" + |
| " : (ATOM 'x') => ATOM 'x' {System.out.println(\"ATOM x\");}\n" + |
| " | ATOM {System.out.println(\"ATOM \"+$ATOM.text);}\n" + |
| ";\n" + |
| "fragment ATOM\n" + |
| "@init {System.out.println(\"enter atom \"+(char)input.LT(1));}\n" + |
| " : '(' EXPR ')'\n" + |
| " | INT\n" + |
| " ;\n" + |
| "fragment INT: '0'..'9'+ ;\n" + |
| "fragment WS : (' '|'\\n')+ \n" + |
| " ;\n" ; |
| String found = execParser("T.g", grammar, "TParser", "TLexer", |
| "s", "((34)x)x", false); |
| String expecting = // has no memoization |
| "enter expr (\n" + |
| "enter atom (\n" + |
| "enter expr (\n" + |
| "enter atom (\n" + |
| "enter expr 3\n" + |
| "enter atom 3\n" + |
| "enter atom 3\n" + |
| "enter atom (\n" + |
| "enter expr 3\n" + |
| "enter atom 3\n" + |
| "enter atom 3\n" + |
| "enter atom (\n" + |
| "enter expr (\n" + |
| "enter atom (\n" + |
| "enter expr 3\n" + |
| "enter atom 3\n" + |
| "enter atom 3\n" + |
| "enter atom (\n" + |
| "enter expr 3\n" + |
| "enter atom 3\n" + |
| "enter atom 3\n" + |
| "ATOM 34\n" + |
| "ATOM x\n" + |
| "ATOM x\n" + |
| "done\n"; |
| assertEquals(expecting, found); |
| } |
| |
| @Test public void testTreeParserWithSynPred() throws Exception { |
| String grammar = |
| "grammar T;\n" + |
| "options {output=AST;}\n" + |
| "a : ID INT+ (PERIOD|SEMI);\n" + |
| "ID : 'a'..'z'+ ;\n" + |
| "INT : '0'..'9'+;\n" + |
| "SEMI : ';' ;\n"+ |
| "PERIOD : '.' ;\n"+ |
| "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; |
| |
| String treeGrammar = |
| "tree grammar TP;\n" + |
| "options {k=1; backtrack=true; ASTLabelType=CommonTree; tokenVocab=T;}\n" + |
| "a : ID INT+ PERIOD {System.out.print(\"alt 1\");}"+ |
| " | ID INT+ SEMI {System.out.print(\"alt 2\");}\n" + |
| " ;\n"; |
| |
| String found = execTreeParser("T.g", grammar, "TParser", "TP.g", |
| treeGrammar, "TP", "TLexer", "a", "a", "a 1 2 3;"); |
| assertEquals("alt 2\n", found); |
| } |
| |
| @Test public void testTreeParserWithNestedSynPred() throws Exception { |
| String grammar = |
| "grammar T;\n" + |
| "options {output=AST;}\n" + |
| "a : ID INT+ (PERIOD|SEMI);\n" + |
| "ID : 'a'..'z'+ ;\n" + |
| "INT : '0'..'9'+;\n" + |
| "SEMI : ';' ;\n"+ |
| "PERIOD : '.' ;\n"+ |
| "WS : (' '|'\\n') {$channel=HIDDEN;} ;\n"; |
| |
| // backtracks in a and b due to k=1 |
| String treeGrammar = |
| "tree grammar TP;\n" + |
| "options {k=1; backtrack=true; ASTLabelType=CommonTree; tokenVocab=T;}\n" + |
| "a : ID b {System.out.print(\" a:alt 1\");}"+ |
| " | ID INT+ SEMI {System.out.print(\" a:alt 2\");}\n" + |
| " ;\n" + |
| "b : INT PERIOD {System.out.print(\"b:alt 1\");}" + // choose this alt for just one INT |
| " | INT+ PERIOD {System.out.print(\"b:alt 2\");}" + |
| " ;"; |
| |
| String found = execTreeParser("T.g", grammar, "TParser", "TP.g", |
| treeGrammar, "TP", "TLexer", "a", "a", "a 1 2 3."); |
| assertEquals("b:alt 2 a:alt 1\n", found); |
| } |
| |
| @Test public void testSynPredWithOutputTemplate() throws Exception { |
| // really just seeing if it will compile |
| String grammar = |
| "grammar T;\n" + |
| "options {output=template;}\n" + |
| "a\n" + |
| "options {\n" + |
| " k=1;\n" + |
| "}\n" + |
| " : ('x'+ 'y')=> 'x'+ 'y' -> template(a={$text}) <<1:<a>;>>\n" + |
| " | 'x'+ 'z' -> template(a={$text}) <<2:<a>;>>\n"+ |
| " ;\n" + |
| "WS : (' '|'\\n')+ {$channel=HIDDEN;}\n" + |
| " ;\n" ; |
| String found = execParser("T.g", grammar, "TParser", "TLexer", |
| "a", "xxxy", false); |
| |
| assertEquals("1:xxxy;\n", found); |
| } |
| |
| @Test public void testSynPredWithOutputAST() throws Exception { |
| // really just seeing if it will compile |
| String grammar = |
| "grammar T;\n" + |
| "options {output=AST;}\n" + |
| "a\n" + |
| "options {\n" + |
| " k=1;\n" + |
| "}\n" + |
| " : ('x'+ 'y')=> 'x'+ 'y'\n" + |
| " | 'x'+ 'z'\n"+ |
| " ;\n" + |
| "WS : (' '|'\\n')+ {$channel=HIDDEN;}\n" + |
| " ;\n" ; |
| String found = execParser("T.g", grammar, "TParser", "TLexer", |
| "a", "xxxy", false); |
| |
| assertEquals("x x x y\n", found); |
| } |
| |
| @Test public void testOptionalBlockWithSynPred() throws Exception { |
| String grammar = |
| "grammar T;\n" + |
| "\n" + |
| "a : ( (b)=> b {System.out.println(\"b\");})? b ;\n" + |
| "b : 'x' ;\n" ; |
| String found = execParser("T.g", grammar, "TParser", "TLexer", |
| "a", "xx", false); |
| assertEquals("b\n", found); |
| found = execParser("T.g", grammar, "TParser", "TLexer", |
| "a", "x", false); |
| assertEquals("", found); |
| } |
| |
| @Test public void testSynPredK2() throws Exception { |
| // all manually specified syn predicates are gated (i.e., forced |
| // to execute). |
| String grammar = |
| "grammar T;\n" + |
| "\n" + |
| "a : (b)=> b {System.out.println(\"alt1\");} | 'a' 'c' ;\n" + |
| "b : 'a' 'b' ;\n" ; |
| String found = execParser("T.g", grammar, "TParser", "TLexer", |
| "a", "ab", false); |
| |
| assertEquals("alt1\n", found); |
| } |
| |
| @Test public void testSynPredKStar() throws Exception { |
| String grammar = |
| "grammar T;\n" + |
| "\n" + |
| "a : (b)=> b {System.out.println(\"alt1\");} | 'a'+ 'c' ;\n" + |
| "b : 'a'+ 'b' ;\n" ; |
| String found = execParser("T.g", grammar, "TParser", "TLexer", |
| "a", "aaab", false); |
| |
| assertEquals("alt1\n", found); |
| } |
| |
| } |