forgetest1
/
antlr
forked from jasder/antlr
1
0
Fork 0
Code Issues Pull Requests 1 Releases Wiki Activity

got it to kill all addrs within a rule once we hit its accept state; needed for nongreedy loops. 

[git-p4: depot-paths = "//depot/code/antlr4/main/": change = 6827]
This commit is contained in:
parrt 2010-04-30 16:54:38 -08:00
parent 43278cf701
commit 6b55114dd0
6 changed files with 176 additions and 132 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
runtime/Java/src/org/antlr/v4/runtime/nfa/Bytecode.java
View File

@ -47,6 +47,7 @@ public class Bytecode {
public static final short RANGE8 = 6; public static final short RANGE8 = 6;
public static final short RANGE16 = 7; public static final short RANGE16 = 7;
public static final short WILDCARD = 8; public static final short WILDCARD = 8;
//public static final short NOT = 8; ???
public static final short SAVE = 9; public static final short SAVE = 9;
/** Used for disassembly; describes instruction set */ /** Used for disassembly; describes instruction set */

39
runtime/Java/src/org/antlr/v4/runtime/nfa/NFA.java
View File

@ -35,6 +35,9 @@ for(;;){
public class NFA { public class NFA {
public byte[] code; public byte[] code;
Map<String, Integer> ruleToAddr; Map<String, Integer> ruleToAddr;
public int[] tokenTypeToAddr;
// 7, 29 -> rule
// 7..28, 29..len
public NFA(byte[] code, Map<String, Integer> ruleToAddr) { public NFA(byte[] code, Map<String, Integer> ruleToAddr) {
this.code = code; this.code = code;
@ -193,8 +196,10 @@ workLoop:
addToClosure(closure, ip); addToClosure(closure, ip);
do { // while more work do { // while more work
c = input.LA(1); c = input.LA(1);
int i = 0;
processOneChar: processOneChar:
for (int i=0; i<closure.size(); i++) { while ( i<closure.size() ) {
//for (int i=0; i<closure.size(); i++) {
System.out.println("input["+input.index()+"]=="+(char)c+" closure="+closure+", i="+i+", reach="+ reach); System.out.println("input["+input.index()+"]=="+(char)c+" closure="+closure+", i="+i+", reach="+ reach);
ip = closure.get(i); ip = closure.get(i);
trace(ip); trace(ip);
@ -221,10 +226,13 @@ processOneChar:
addToClosure(reach, ip+4); addToClosure(reach, ip+4);
} }
break; break;
case Bytecode.WILDCARD :
if ( c!=Token.EOF ) addToClosure(reach, ip);
break;
case Bytecode.ACCEPT : case Bytecode.ACCEPT :
int ttype = getShort(code, ip);
int tokenLastCharIndex = input.index() - 1; int tokenLastCharIndex = input.index() - 1;
System.out.println("ACCEPT "+ttype+" with last char position "+ tokenLastCharIndex); int ttype = getShort(code, ip);
System.out.println("ACCEPT "+ ttype +" with last char position "+ tokenLastCharIndex);
if ( tokenLastCharIndex > prevAcceptLastCharIndex ) { if ( tokenLastCharIndex > prevAcceptLastCharIndex ) {
prevAcceptLastCharIndex = tokenLastCharIndex; prevAcceptLastCharIndex = tokenLastCharIndex;
// choose longest match so far regardless of rule priority // choose longest match so far regardless of rule priority
@ -238,17 +246,34 @@ processOneChar:
prevAcceptAddr = ip-1; prevAcceptAddr = ip-1;
} }
} }
// keep trying for more to get longest match // if we reach accept state, toss out any addresses in rest
// of work list associated with accept's rule; that rule is done
int ruleStart = tokenTypeToAddr[ttype];
int ruleStop = code.length;
if ( ttype+1 < tokenTypeToAddr.length ) {
ruleStop = tokenTypeToAddr[ttype+1]-1;
}
System.out.println("kill range "+ruleStart+".."+ruleStop);
int j=i+1;
while ( j<closure.size() ) {
Integer cl = closure.get(j);
System.out.println("remaining "+ cl);
if ( cl>=ruleStart || cl<=ruleStop ) closure.remove(j);
else j++;
}
// then, move to next char, looking for longer match
// (we continue processing if there are states in reach)
break; break;
case Bytecode.JMP : //break processOneChar;
case Bytecode.JMP : // ignore
case Bytecode.SPLIT : case Bytecode.SPLIT :
break; break;
default : default :
throw new RuntimeException("invalid instruction @ "+ip+": "+opcode); throw new RuntimeException("invalid instruction @ "+ip+": "+opcode);
} }
i++;
} }
if ( reach.size()>0 ) { // if we reached other states, consume and process them if ( reach.size()>0 ) { // if we reached other states, consume and process them
System.out.println("CONSUME");
input.consume(); input.consume();
} }
// swap to avoid reallocating space // swap to avoid reallocating space
@ -258,7 +283,7 @@ processOneChar:
reach.clear(); reach.clear();
} while ( closure.size()>0 ); } while ( closure.size()>0 );
if ( prevAcceptAddr<0 ) return Token.INVALID_TOKEN_TYPE; if ( prevAcceptAddr >= code.length ) return Token.INVALID_TOKEN_TYPE;
int ttype = getShort(code, prevAcceptAddr+1); int ttype = getShort(code, prevAcceptAddr+1);
return ttype; return ttype;
} }

3
tool/src/org/antlr/v4/codegen/CodeGenPipeline.java
View File

@ -19,7 +19,8 @@ public class CodeGenPipeline {
LexerGrammar lg = (LexerGrammar)g; LexerGrammar lg = (LexerGrammar)g;
for (String modeName : lg.modes.keySet()) { // for each mode for (String modeName : lg.modes.keySet()) { // for each mode
NFA nfa = NFABytecodeGenerator.getBytecode(lg, modeName); NFA nfa = NFABytecodeGenerator.getBytecode(lg, modeName);
ANTLRStringStream input = new ANTLRStringStream("abc32ab"); ANTLRStringStream input = new ANTLRStringStream("/*x*/ab");
//ANTLRStringStream input = new ANTLRStringStream("abc32ab");
int ttype = 0; int ttype = 0;
while ( ttype!= Token.EOF ) { while ( ttype!= Token.EOF ) {
ttype = nfa.execThompson(input, 0); System.out.println("ttype="+ttype); ttype = nfa.execThompson(input, 0); System.out.println("ttype="+ttype);

11
tool/src/org/antlr/v4/codegen/NFABytecodeGenerator.java
View File

@ -33,6 +33,13 @@ public class NFABytecodeGenerator extends TreeParser {
public void write(byte[] code) { code[addr] = (byte)opcode(); } public void write(byte[] code) { code[addr] = (byte)opcode(); }
} }
public static class WildcardInstr extends Instr {
Token token;
public WildcardInstr(Token t) { super(); this.token = t; }
public short opcode() { return Bytecode.WILDCARD; }
public int nBytes() { return 1; }
}
public static class MatchInstr extends Instr { public static class MatchInstr extends Instr {
Token token; Token token;
int c; int c;
@ -199,10 +206,13 @@ public class NFABytecodeGenerator extends TreeParser {
gen.emit(s0); gen.emit(s0);
Map<String, Integer> ruleToAddr = new HashMap<String, Integer>(); Map<String, Integer> ruleToAddr = new HashMap<String, Integer>();
int[] tokenTypeToAddr = new int[lg.getMaxTokenType()+1];
for (Rule r : lg.modes.get(modeName)) { // for each rule in mode for (Rule r : lg.modes.get(modeName)) { // for each rule in mode
GrammarAST blk = (GrammarAST)r.ast.getFirstChildWithType(ANTLRParser.BLOCK); GrammarAST blk = (GrammarAST)r.ast.getFirstChildWithType(ANTLRParser.BLOCK);
CommonTreeNodeStream nodes = new CommonTreeNodeStream(adaptor,blk); CommonTreeNodeStream nodes = new CommonTreeNodeStream(adaptor,blk);
gen.setTreeNodeStream(nodes); gen.setTreeNodeStream(nodes);
int ttype = lg.getTokenType(r.name);
tokenTypeToAddr[ttype] = gen.ip;
ruleToAddr.put(r.name, gen.ip); ruleToAddr.put(r.name, gen.ip);
if ( !r.isFragment() ) s0.addrs.add(gen.ip); if ( !r.isFragment() ) s0.addrs.add(gen.ip);
try { try {
@ -220,6 +230,7 @@ public class NFABytecodeGenerator extends TreeParser {
System.out.println("rule addrs="+ruleToAddr); System.out.println("rule addrs="+ruleToAddr);
NFA nfa = new NFA(code, ruleToAddr); NFA nfa = new NFA(code, ruleToAddr);
nfa.tokenTypeToAddr = tokenTypeToAddr;
return nfa; return nfa;
} }

9
tool/src/org/antlr/v4/codegen/NFABytecodeTriggers.g
View File

@ -97,14 +97,15 @@ ebnf
int start=ip; int start=ip;
SplitInstr S = new SplitInstr(2); SplitInstr S = new SplitInstr(2);
emit(S); emit(S);
S.addrs.add(ip); int blk = ip;
} }
^(CLOSURE block) ^(CLOSURE block)
{ {
JumpInstr J = new JumpInstr(); JumpInstr J = new JumpInstr();
emit(J); emit(J);
J.target = start; J.target = start;
S.addrs.add(ip); S.addrs.add(blk);
S.addrs.add(ip); // reverse for nongreedy
} }
| {int start=ip;} ^(POSITIVE_CLOSURE block) | {int start=ip;} ^(POSITIVE_CLOSURE block)
{ {
@ -132,8 +133,8 @@ atom
| range | range
| ^(DOT ID terminal) | ^(DOT ID terminal)
| ^(DOT ID ruleref) | ^(DOT ID ruleref)
| ^(WILDCARD .) | ^(WILDCARD .) {emit(new WildcardInstr($WILDCARD.token));}
| WILDCARD | WILDCARD {emit(new WildcardInstr($WILDCARD.token));}
| terminal | terminal
| ruleref | ruleref
; ;

245
tool/src/org/antlr/v4/codegen/NFABytecodeTriggers.java
View File

@ -1,14 +1,13 @@
// $ANTLR ${project.version} ${buildNumber} NFABytecodeTriggers.g 2010-04-29 12:03:06 // $ANTLR ${project.version} ${buildNumber} NFABytecodeTriggers.g 2010-04-30 17:54:24
package org.antlr.v4.codegen; package org.antlr.v4.codegen;
import org.antlr.runtime.*;
import org.antlr.runtime.tree.TreeNodeStream;
import org.antlr.runtime.tree.TreeRuleReturnScope;
import org.antlr.v4.tool.GrammarAST; import org.antlr.v4.tool.GrammarAST;
import java.util.ArrayList;
import org.antlr.runtime.*;
import org.antlr.runtime.tree.*;import java.util.Stack;
import java.util.List; import java.util.List;
import java.util.ArrayList;
public class NFABytecodeTriggers extends NFABytecodeGenerator { public class NFABytecodeTriggers extends NFABytecodeGenerator {
public static final String[] tokenNames = new String[] { public static final String[] tokenNames = new String[] {
@ -744,7 +743,7 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
int start=ip; int start=ip;
SplitInstr S = new SplitInstr(2); SplitInstr S = new SplitInstr(2);
emit(S); emit(S);
S.addrs.add(ip); int blk = ip;
match(input,CLOSURE,FOLLOW_CLOSURE_in_ebnf429); match(input,CLOSURE,FOLLOW_CLOSURE_in_ebnf429);
@ -760,13 +759,14 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
JumpInstr J = new JumpInstr(); JumpInstr J = new JumpInstr();
emit(J); emit(J);
J.target = start; J.target = start;
S.addrs.add(ip); S.addrs.add(blk);
S.addrs.add(ip); // reverse for nongreedy
} }
break; break;
case 4 : case 4 :
// NFABytecodeTriggers.g:109:4: ^( POSITIVE_CLOSURE block ) // NFABytecodeTriggers.g:110:4: ^( POSITIVE_CLOSURE block )
{ {
int start=ip; int start=ip;
match(input,POSITIVE_CLOSURE,FOLLOW_POSITIVE_CLOSURE_in_ebnf447); match(input,POSITIVE_CLOSURE,FOLLOW_POSITIVE_CLOSURE_in_ebnf447);
@ -790,7 +790,7 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
} }
break; break;
case 5 : case 5 :
// NFABytecodeTriggers.g:117:5: block // NFABytecodeTriggers.g:118:5: block
{ {
pushFollow(FOLLOW_block_in_ebnf460); pushFollow(FOLLOW_block_in_ebnf460);
block(); block();
@ -815,10 +815,10 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
// $ANTLR start "astBlockSuffix" // $ANTLR start "astBlockSuffix"
// NFABytecodeTriggers.g:120:1: astBlockSuffix : ( ROOT | IMPLIES | BANG ); // NFABytecodeTriggers.g:121:1: astBlockSuffix : ( ROOT | IMPLIES | BANG );
public final void astBlockSuffix() throws RecognitionException { public final void astBlockSuffix() throws RecognitionException {
try { try {
// NFABytecodeTriggers.g:121:5: ( ROOT | IMPLIES | BANG ) // NFABytecodeTriggers.g:122:5: ( ROOT | IMPLIES | BANG )
// NFABytecodeTriggers.g: // NFABytecodeTriggers.g:
{ {
if ( input.LA(1)==IMPLIES||input.LA(1)==BANG||input.LA(1)==ROOT ) { if ( input.LA(1)==IMPLIES||input.LA(1)==BANG||input.LA(1)==ROOT ) {
@ -846,15 +846,18 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
// $ANTLR start "atom" // $ANTLR start "atom"
// NFABytecodeTriggers.g:126:1: atom : ( ^( ROOT range ) | ^( BANG range ) | ^( ROOT notSet ) | ^( BANG notSet ) | notSet | range | ^( DOT ID terminal ) | ^( DOT ID ruleref ) | ^( WILDCARD . ) | WILDCARD | terminal | ruleref ); // NFABytecodeTriggers.g:127:1: atom : ( ^( ROOT range ) | ^( BANG range ) | ^( ROOT notSet ) | ^( BANG notSet ) | notSet | range | ^( DOT ID terminal ) | ^( DOT ID ruleref ) | ^( WILDCARD . ) | WILDCARD | terminal | ruleref );
public final void atom() throws RecognitionException { public final void atom() throws RecognitionException {
GrammarAST WILDCARD1=null;
GrammarAST WILDCARD2=null;
try { try {
// NFABytecodeTriggers.g:127:2: ( ^( ROOT range ) | ^( BANG range ) | ^( ROOT notSet ) | ^( BANG notSet ) | notSet | range | ^( DOT ID terminal ) | ^( DOT ID ruleref ) | ^( WILDCARD . ) | WILDCARD | terminal | ruleref ) // NFABytecodeTriggers.g:128:2: ( ^( ROOT range ) | ^( BANG range ) | ^( ROOT notSet ) | ^( BANG notSet ) | notSet | range | ^( DOT ID terminal ) | ^( DOT ID ruleref ) | ^( WILDCARD . ) | WILDCARD | terminal | ruleref )
int alt10=12; int alt10=12;
alt10 = dfa10.predict(input); alt10 = dfa10.predict(input);
switch (alt10) { switch (alt10) {
case 1 : case 1 :
// NFABytecodeTriggers.g:127:4: ^( ROOT range ) // NFABytecodeTriggers.g:128:4: ^( ROOT range )
{ {
match(input,ROOT,FOLLOW_ROOT_in_atom514); match(input,ROOT,FOLLOW_ROOT_in_atom514);
@ -870,7 +873,7 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
} }
break; break;
case 2 : case 2 :
// NFABytecodeTriggers.g:128:4: ^( BANG range ) // NFABytecodeTriggers.g:129:4: ^( BANG range )
{ {
match(input,BANG,FOLLOW_BANG_in_atom526); match(input,BANG,FOLLOW_BANG_in_atom526);
@ -886,7 +889,7 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
} }
break; break;
case 3 : case 3 :
// NFABytecodeTriggers.g:129:4: ^( ROOT notSet ) // NFABytecodeTriggers.g:130:4: ^( ROOT notSet )
{ {
match(input,ROOT,FOLLOW_ROOT_in_atom538); match(input,ROOT,FOLLOW_ROOT_in_atom538);
@ -902,7 +905,7 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
} }
break; break;
case 4 : case 4 :
// NFABytecodeTriggers.g:130:4: ^( BANG notSet ) // NFABytecodeTriggers.g:131:4: ^( BANG notSet )
{ {
match(input,BANG,FOLLOW_BANG_in_atom550); match(input,BANG,FOLLOW_BANG_in_atom550);
@ -918,7 +921,7 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
} }
break; break;
case 5 : case 5 :
// NFABytecodeTriggers.g:131:4: notSet // NFABytecodeTriggers.g:132:4: notSet
{ {
pushFollow(FOLLOW_notSet_in_atom561); pushFollow(FOLLOW_notSet_in_atom561);
notSet(); notSet();
@ -929,7 +932,7 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
} }
break; break;
case 6 : case 6 :
// NFABytecodeTriggers.g:132:4: range // NFABytecodeTriggers.g:133:4: range
{ {
pushFollow(FOLLOW_range_in_atom571); pushFollow(FOLLOW_range_in_atom571);
range(); range();
@ -940,7 +943,7 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
} }
break; break;
case 7 : case 7 :
// NFABytecodeTriggers.g:133:4: ^( DOT ID terminal ) // NFABytecodeTriggers.g:134:4: ^( DOT ID terminal )
{ {
match(input,DOT,FOLLOW_DOT_in_atom582); match(input,DOT,FOLLOW_DOT_in_atom582);
@ -957,7 +960,7 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
} }
break; break;
case 8 : case 8 :
// NFABytecodeTriggers.g:134:4: ^( DOT ID ruleref ) // NFABytecodeTriggers.g:135:4: ^( DOT ID ruleref )
{ {
match(input,DOT,FOLLOW_DOT_in_atom595); match(input,DOT,FOLLOW_DOT_in_atom595);
@ -974,28 +977,30 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
} }
break; break;
case 9 : case 9 :
// NFABytecodeTriggers.g:135:7: ^( WILDCARD . ) // NFABytecodeTriggers.g:136:7: ^( WILDCARD . )
{ {
match(input,WILDCARD,FOLLOW_WILDCARD_in_atom611); WILDCARD1=(GrammarAST)match(input,WILDCARD,FOLLOW_WILDCARD_in_atom611);
match(input, Token.DOWN, null); match(input, Token.DOWN, null);
matchAny(input); matchAny(input);
match(input, Token.UP, null); match(input, Token.UP, null);
emit(new WildcardInstr(WILDCARD1.token));
} }
break; break;
case 10 : case 10 :
// NFABytecodeTriggers.g:136:7: WILDCARD // NFABytecodeTriggers.g:137:7: WILDCARD
{ {
match(input,WILDCARD,FOLLOW_WILDCARD_in_atom625); WILDCARD2=(GrammarAST)match(input,WILDCARD,FOLLOW_WILDCARD_in_atom627);
emit(new WildcardInstr(WILDCARD2.token));
} }
break; break;
case 11 : case 11 :
// NFABytecodeTriggers.g:137:9: terminal // NFABytecodeTriggers.g:138:9: terminal
{ {
pushFollow(FOLLOW_terminal_in_atom639); pushFollow(FOLLOW_terminal_in_atom642);
terminal(); terminal();
state._fsp--; state._fsp--;
@ -1004,9 +1009,9 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
} }
break; break;
case 12 : case 12 :
// NFABytecodeTriggers.g:138:9: ruleref // NFABytecodeTriggers.g:139:9: ruleref
{ {
pushFollow(FOLLOW_ruleref_in_atom653); pushFollow(FOLLOW_ruleref_in_atom656);
ruleref(); ruleref();
state._fsp--; state._fsp--;
@ -1029,10 +1034,10 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
// $ANTLR start "notSet" // $ANTLR start "notSet"
// NFABytecodeTriggers.g:141:1: notSet : ( ^( NOT terminal ) | ^( NOT block ) ); // NFABytecodeTriggers.g:142:1: notSet : ( ^( NOT terminal ) | ^( NOT block ) );
public final void notSet() throws RecognitionException { public final void notSet() throws RecognitionException {
try { try {
// NFABytecodeTriggers.g:142:5: ( ^( NOT terminal ) | ^( NOT block ) ) // NFABytecodeTriggers.g:143:5: ( ^( NOT terminal ) | ^( NOT block ) )
int alt11=2; int alt11=2;
int LA11_0 = input.LA(1); int LA11_0 = input.LA(1);
@ -1042,12 +1047,12 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
if ( (LA11_1==DOWN) ) { if ( (LA11_1==DOWN) ) {
int LA11_2 = input.LA(3); int LA11_2 = input.LA(3);
if ( (LA11_2==BLOCK) ) { if ( (LA11_2==BANG||LA11_2==ROOT||LA11_2==TOKEN_REF||LA11_2==STRING_LITERAL) ) {
alt11=2;
}
else if ( (LA11_2==BANG||LA11_2==ROOT||LA11_2==TOKEN_REF||LA11_2==STRING_LITERAL) ) {
alt11=1; alt11=1;
} }
else if ( (LA11_2==BLOCK) ) {
alt11=2;
}
else { else {
NoViableAltException nvae = NoViableAltException nvae =
new NoViableAltException("", 11, 2, input); new NoViableAltException("", 11, 2, input);
@ -1070,12 +1075,12 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
} }
switch (alt11) { switch (alt11) {
case 1 : case 1 :
// NFABytecodeTriggers.g:142:7: ^( NOT terminal ) // NFABytecodeTriggers.g:143:7: ^( NOT terminal )
{ {
match(input,NOT,FOLLOW_NOT_in_notSet676); match(input,NOT,FOLLOW_NOT_in_notSet679);
match(input, Token.DOWN, null); match(input, Token.DOWN, null);
pushFollow(FOLLOW_terminal_in_notSet678); pushFollow(FOLLOW_terminal_in_notSet681);
terminal(); terminal();
state._fsp--; state._fsp--;
@ -1086,12 +1091,12 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
} }
break; break;
case 2 : case 2 :
// NFABytecodeTriggers.g:143:7: ^( NOT block ) // NFABytecodeTriggers.g:144:7: ^( NOT block )
{ {
match(input,NOT,FOLLOW_NOT_in_notSet690); match(input,NOT,FOLLOW_NOT_in_notSet693);
match(input, Token.DOWN, null); match(input, Token.DOWN, null);
pushFollow(FOLLOW_block_in_notSet692); pushFollow(FOLLOW_block_in_notSet695);
block(); block();
state._fsp--; state._fsp--;
@ -1116,10 +1121,10 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
// $ANTLR start "ruleref" // $ANTLR start "ruleref"
// NFABytecodeTriggers.g:146:1: ruleref : ( ^( ROOT ^( RULE_REF ( ARG_ACTION )? ) ) | ^( BANG ^( RULE_REF ( ARG_ACTION )? ) ) | ^( RULE_REF ( ARG_ACTION )? ) ); // NFABytecodeTriggers.g:147:1: ruleref : ( ^( ROOT ^( RULE_REF ( ARG_ACTION )? ) ) | ^( BANG ^( RULE_REF ( ARG_ACTION )? ) ) | ^( RULE_REF ( ARG_ACTION )? ) );
public final void ruleref() throws RecognitionException { public final void ruleref() throws RecognitionException {
try { try {
// NFABytecodeTriggers.g:147:5: ( ^( ROOT ^( RULE_REF ( ARG_ACTION )? ) ) | ^( BANG ^( RULE_REF ( ARG_ACTION )? ) ) | ^( RULE_REF ( ARG_ACTION )? ) ) // NFABytecodeTriggers.g:148:5: ( ^( ROOT ^( RULE_REF ( ARG_ACTION )? ) ) | ^( BANG ^( RULE_REF ( ARG_ACTION )? ) ) | ^( RULE_REF ( ARG_ACTION )? ) )
int alt15=3; int alt15=3;
switch ( input.LA(1) ) { switch ( input.LA(1) ) {
case ROOT: case ROOT:
@ -1146,16 +1151,16 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
switch (alt15) { switch (alt15) {
case 1 : case 1 :
// NFABytecodeTriggers.g:147:7: ^( ROOT ^( RULE_REF ( ARG_ACTION )? ) ) // NFABytecodeTriggers.g:148:7: ^( ROOT ^( RULE_REF ( ARG_ACTION )? ) )
{ {
match(input,ROOT,FOLLOW_ROOT_in_ruleref714); match(input,ROOT,FOLLOW_ROOT_in_ruleref717);
match(input, Token.DOWN, null); match(input, Token.DOWN, null);
match(input,RULE_REF,FOLLOW_RULE_REF_in_ruleref717); match(input,RULE_REF,FOLLOW_RULE_REF_in_ruleref720);
if ( input.LA(1)==Token.DOWN ) { if ( input.LA(1)==Token.DOWN ) {
match(input, Token.DOWN, null); match(input, Token.DOWN, null);
// NFABytecodeTriggers.g:147:25: ( ARG_ACTION )? // NFABytecodeTriggers.g:148:25: ( ARG_ACTION )?
int alt12=2; int alt12=2;
int LA12_0 = input.LA(1); int LA12_0 = input.LA(1);
@ -1164,9 +1169,9 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
} }
switch (alt12) { switch (alt12) {
case 1 : case 1 :
// NFABytecodeTriggers.g:147:25: ARG_ACTION // NFABytecodeTriggers.g:148:25: ARG_ACTION
{ {
match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_ruleref719); match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_ruleref722);
} }
break; break;
@ -1182,16 +1187,16 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
} }
break; break;
case 2 : case 2 :
// NFABytecodeTriggers.g:148:7: ^( BANG ^( RULE_REF ( ARG_ACTION )? ) ) // NFABytecodeTriggers.g:149:7: ^( BANG ^( RULE_REF ( ARG_ACTION )? ) )
{ {
match(input,BANG,FOLLOW_BANG_in_ruleref732); match(input,BANG,FOLLOW_BANG_in_ruleref735);
match(input, Token.DOWN, null); match(input, Token.DOWN, null);
match(input,RULE_REF,FOLLOW_RULE_REF_in_ruleref735); match(input,RULE_REF,FOLLOW_RULE_REF_in_ruleref738);
if ( input.LA(1)==Token.DOWN ) { if ( input.LA(1)==Token.DOWN ) {
match(input, Token.DOWN, null); match(input, Token.DOWN, null);
// NFABytecodeTriggers.g:148:25: ( ARG_ACTION )? // NFABytecodeTriggers.g:149:25: ( ARG_ACTION )?
int alt13=2; int alt13=2;
int LA13_0 = input.LA(1); int LA13_0 = input.LA(1);
@ -1200,9 +1205,9 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
} }
switch (alt13) { switch (alt13) {
case 1 : case 1 :
// NFABytecodeTriggers.g:148:25: ARG_ACTION // NFABytecodeTriggers.g:149:25: ARG_ACTION
{ {
match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_ruleref737); match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_ruleref740);
} }
break; break;
@ -1218,13 +1223,13 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
} }
break; break;
case 3 : case 3 :
// NFABytecodeTriggers.g:149:7: ^( RULE_REF ( ARG_ACTION )? ) // NFABytecodeTriggers.g:150:7: ^( RULE_REF ( ARG_ACTION )? )
{ {
match(input,RULE_REF,FOLLOW_RULE_REF_in_ruleref750); match(input,RULE_REF,FOLLOW_RULE_REF_in_ruleref753);
if ( input.LA(1)==Token.DOWN ) { if ( input.LA(1)==Token.DOWN ) {
match(input, Token.DOWN, null); match(input, Token.DOWN, null);
// NFABytecodeTriggers.g:149:18: ( ARG_ACTION )? // NFABytecodeTriggers.g:150:18: ( ARG_ACTION )?
int alt14=2; int alt14=2;
int LA14_0 = input.LA(1); int LA14_0 = input.LA(1);
@ -1233,9 +1238,9 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
} }
switch (alt14) { switch (alt14) {
case 1 : case 1 :
// NFABytecodeTriggers.g:149:18: ARG_ACTION // NFABytecodeTriggers.g:150:18: ARG_ACTION
{ {
match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_ruleref752); match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_ruleref755);
} }
break; break;
@ -1263,20 +1268,20 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
// $ANTLR start "range" // $ANTLR start "range"
// NFABytecodeTriggers.g:152:1: range : ^( RANGE a= STRING_LITERAL b= STRING_LITERAL ) ; // NFABytecodeTriggers.g:153:1: range : ^( RANGE a= STRING_LITERAL b= STRING_LITERAL ) ;
public final void range() throws RecognitionException { public final void range() throws RecognitionException {
GrammarAST a=null; GrammarAST a=null;
GrammarAST b=null; GrammarAST b=null;
try { try {
// NFABytecodeTriggers.g:153:5: ( ^( RANGE a= STRING_LITERAL b= STRING_LITERAL ) ) // NFABytecodeTriggers.g:154:5: ( ^( RANGE a= STRING_LITERAL b= STRING_LITERAL ) )
// NFABytecodeTriggers.g:153:7: ^( RANGE a= STRING_LITERAL b= STRING_LITERAL ) // NFABytecodeTriggers.g:154:7: ^( RANGE a= STRING_LITERAL b= STRING_LITERAL )
{ {
match(input,RANGE,FOLLOW_RANGE_in_range775); match(input,RANGE,FOLLOW_RANGE_in_range778);
match(input, Token.DOWN, null); match(input, Token.DOWN, null);
a=(GrammarAST)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_range779); a=(GrammarAST)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_range782);
b=(GrammarAST)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_range783); b=(GrammarAST)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_range786);
match(input, Token.UP, null); match(input, Token.UP, null);
emit(new RangeInstr(a.token, b.token)); emit(new RangeInstr(a.token, b.token));
@ -1296,44 +1301,44 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
// $ANTLR start "terminal" // $ANTLR start "terminal"
// NFABytecodeTriggers.g:157:1: terminal : ( ^( STRING_LITERAL . ) | STRING_LITERAL | ^( TOKEN_REF ARG_ACTION . ) | ^( TOKEN_REF . ) | TOKEN_REF | ^( ROOT terminal ) | ^( BANG terminal ) ); // NFABytecodeTriggers.g:158:1: terminal : ( ^( STRING_LITERAL . ) | STRING_LITERAL | ^( TOKEN_REF ARG_ACTION . ) | ^( TOKEN_REF . ) | TOKEN_REF | ^( ROOT terminal ) | ^( BANG terminal ) );
public final void terminal() throws RecognitionException { public final void terminal() throws RecognitionException {
GrammarAST STRING_LITERAL1=null; GrammarAST STRING_LITERAL3=null;
GrammarAST STRING_LITERAL2=null; GrammarAST STRING_LITERAL4=null;
try { try {
// NFABytecodeTriggers.g:158:5: ( ^( STRING_LITERAL . ) | STRING_LITERAL | ^( TOKEN_REF ARG_ACTION . ) | ^( TOKEN_REF . ) | TOKEN_REF | ^( ROOT terminal ) | ^( BANG terminal ) ) // NFABytecodeTriggers.g:159:5: ( ^( STRING_LITERAL . ) | STRING_LITERAL | ^( TOKEN_REF ARG_ACTION . ) | ^( TOKEN_REF . ) | TOKEN_REF | ^( ROOT terminal ) | ^( BANG terminal ) )
int alt16=7; int alt16=7;
alt16 = dfa16.predict(input); alt16 = dfa16.predict(input);
switch (alt16) { switch (alt16) {
case 1 : case 1 :
// NFABytecodeTriggers.g:158:8: ^( STRING_LITERAL . ) // NFABytecodeTriggers.g:159:8: ^( STRING_LITERAL . )
{ {
STRING_LITERAL1=(GrammarAST)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_terminal810); STRING_LITERAL3=(GrammarAST)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_terminal813);
match(input, Token.DOWN, null); match(input, Token.DOWN, null);
matchAny(input); matchAny(input);
match(input, Token.UP, null); match(input, Token.UP, null);
emitString(STRING_LITERAL1.token); emitString(STRING_LITERAL3.token);
} }
break; break;
case 2 : case 2 :
// NFABytecodeTriggers.g:159:7: STRING_LITERAL // NFABytecodeTriggers.g:160:7: STRING_LITERAL
{ {
STRING_LITERAL2=(GrammarAST)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_terminal825); STRING_LITERAL4=(GrammarAST)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_terminal828);
emitString(STRING_LITERAL2.token); emitString(STRING_LITERAL4.token);
} }
break; break;
case 3 : case 3 :
// NFABytecodeTriggers.g:160:7: ^( TOKEN_REF ARG_ACTION . ) // NFABytecodeTriggers.g:161:7: ^( TOKEN_REF ARG_ACTION . )
{ {
match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_terminal839); match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_terminal842);
match(input, Token.DOWN, null); match(input, Token.DOWN, null);
match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_terminal841); match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_terminal844);
matchAny(input); matchAny(input);
match(input, Token.UP, null); match(input, Token.UP, null);
@ -1341,9 +1346,9 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
} }
break; break;
case 4 : case 4 :
// NFABytecodeTriggers.g:161:7: ^( TOKEN_REF . ) // NFABytecodeTriggers.g:162:7: ^( TOKEN_REF . )
{ {
match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_terminal854); match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_terminal857);
match(input, Token.DOWN, null); match(input, Token.DOWN, null);
matchAny(input); matchAny(input);
@ -1353,19 +1358,19 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
} }
break; break;
case 5 : case 5 :
// NFABytecodeTriggers.g:162:7: TOKEN_REF // NFABytecodeTriggers.g:163:7: TOKEN_REF
{ {
match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_terminal869); match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_terminal872);
} }
break; break;
case 6 : case 6 :
// NFABytecodeTriggers.g:163:7: ^( ROOT terminal ) // NFABytecodeTriggers.g:164:7: ^( ROOT terminal )
{ {
match(input,ROOT,FOLLOW_ROOT_in_terminal883); match(input,ROOT,FOLLOW_ROOT_in_terminal886);
match(input, Token.DOWN, null); match(input, Token.DOWN, null);
pushFollow(FOLLOW_terminal_in_terminal885); pushFollow(FOLLOW_terminal_in_terminal888);
terminal(); terminal();
state._fsp--; state._fsp--;
@ -1376,12 +1381,12 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
} }
break; break;
case 7 : case 7 :
// NFABytecodeTriggers.g:164:7: ^( BANG terminal ) // NFABytecodeTriggers.g:165:7: ^( BANG terminal )
{ {
match(input,BANG,FOLLOW_BANG_in_terminal898); match(input,BANG,FOLLOW_BANG_in_terminal901);
match(input, Token.DOWN, null); match(input, Token.DOWN, null);
pushFollow(FOLLOW_terminal_in_terminal900); pushFollow(FOLLOW_terminal_in_terminal903);
terminal(); terminal();
state._fsp--; state._fsp--;
@ -1616,7 +1621,7 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
this.transition = DFA10_transition; this.transition = DFA10_transition;
} }
public String getDescription() { public String getDescription() {
return "126:1: atom : ( ^( ROOT range ) | ^( BANG range ) | ^( ROOT notSet ) | ^( BANG notSet ) | notSet | range | ^( DOT ID terminal ) | ^( DOT ID ruleref ) | ^( WILDCARD . ) | WILDCARD | terminal | ruleref );"; return "127:1: atom : ( ^( ROOT range ) | ^( BANG range ) | ^( ROOT notSet ) | ^( BANG notSet ) | notSet | range | ^( DOT ID terminal ) | ^( DOT ID ruleref ) | ^( WILDCARD . ) | WILDCARD | terminal | ruleref );";
} }
} }
static final String DFA16_eotS = static final String DFA16_eotS =
@ -1682,7 +1687,7 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
this.transition = DFA16_transition; this.transition = DFA16_transition;
} }
public String getDescription() { public String getDescription() {
return "157:1: terminal : ( ^( STRING_LITERAL . ) | STRING_LITERAL | ^( TOKEN_REF ARG_ACTION . ) | ^( TOKEN_REF . ) | TOKEN_REF | ^( ROOT terminal ) | ^( BANG terminal ) );"; return "158:1: terminal : ( ^( STRING_LITERAL . ) | STRING_LITERAL | ^( TOKEN_REF ARG_ACTION . ) | ^( TOKEN_REF . ) | TOKEN_REF | ^( ROOT terminal ) | ^( BANG terminal ) );";
} }
} }
@ -1744,33 +1749,33 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
public static final BitSet FOLLOW_ID_in_atom597 = new BitSet(new long[]{0xA1A1000000000000L,0x0000000200000011L}); public static final BitSet FOLLOW_ID_in_atom597 = new BitSet(new long[]{0xA1A1000000000000L,0x0000000200000011L});
public static final BitSet FOLLOW_ruleref_in_atom599 = new BitSet(new long[]{0x0000000000000008L}); public static final BitSet FOLLOW_ruleref_in_atom599 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_WILDCARD_in_atom611 = new BitSet(new long[]{0x0000000000000004L}); public static final BitSet FOLLOW_WILDCARD_in_atom611 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_WILDCARD_in_atom625 = new BitSet(new long[]{0x0000000000000002L}); public static final BitSet FOLLOW_WILDCARD_in_atom627 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_terminal_in_atom639 = new BitSet(new long[]{0x0000000000000002L}); public static final BitSet FOLLOW_terminal_in_atom642 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_ruleref_in_atom653 = new BitSet(new long[]{0x0000000000000002L}); public static final BitSet FOLLOW_ruleref_in_atom656 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_NOT_in_notSet676 = new BitSet(new long[]{0x0000000000000004L}); public static final BitSet FOLLOW_NOT_in_notSet679 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_terminal_in_notSet678 = new BitSet(new long[]{0x0000000000000008L}); public static final BitSet FOLLOW_terminal_in_notSet681 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_NOT_in_notSet690 = new BitSet(new long[]{0x0000000000000004L}); public static final BitSet FOLLOW_NOT_in_notSet693 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_block_in_notSet692 = new BitSet(new long[]{0x0000000000000008L}); public static final BitSet FOLLOW_block_in_notSet695 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_ROOT_in_ruleref714 = new BitSet(new long[]{0x0000000000000004L}); public static final BitSet FOLLOW_ROOT_in_ruleref717 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_RULE_REF_in_ruleref717 = new BitSet(new long[]{0x0000000000000004L}); public static final BitSet FOLLOW_RULE_REF_in_ruleref720 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ARG_ACTION_in_ruleref719 = new BitSet(new long[]{0x0000000000000008L}); public static final BitSet FOLLOW_ARG_ACTION_in_ruleref722 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_BANG_in_ruleref732 = new BitSet(new long[]{0x0000000000000004L}); public static final BitSet FOLLOW_BANG_in_ruleref735 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_RULE_REF_in_ruleref735 = new BitSet(new long[]{0x0000000000000004L}); public static final BitSet FOLLOW_RULE_REF_in_ruleref738 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ARG_ACTION_in_ruleref737 = new BitSet(new long[]{0x0000000000000008L}); public static final BitSet FOLLOW_ARG_ACTION_in_ruleref740 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_RULE_REF_in_ruleref750 = new BitSet(new long[]{0x0000000000000004L}); public static final BitSet FOLLOW_RULE_REF_in_ruleref753 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ARG_ACTION_in_ruleref752 = new BitSet(new long[]{0x0000000000000008L}); public static final BitSet FOLLOW_ARG_ACTION_in_ruleref755 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_RANGE_in_range775 = new BitSet(new long[]{0x0000000000000004L}); public static final BitSet FOLLOW_RANGE_in_range778 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_STRING_LITERAL_in_range779 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L}); public static final BitSet FOLLOW_STRING_LITERAL_in_range782 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
public static final BitSet FOLLOW_STRING_LITERAL_in_range783 = new BitSet(new long[]{0x0000000000000008L}); public static final BitSet FOLLOW_STRING_LITERAL_in_range786 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_STRING_LITERAL_in_terminal810 = new BitSet(new long[]{0x0000000000000004L}); public static final BitSet FOLLOW_STRING_LITERAL_in_terminal813 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_STRING_LITERAL_in_terminal825 = new BitSet(new long[]{0x0000000000000002L}); public static final BitSet FOLLOW_STRING_LITERAL_in_terminal828 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_TOKEN_REF_in_terminal839 = new BitSet(new long[]{0x0000000000000004L}); public static final BitSet FOLLOW_TOKEN_REF_in_terminal842 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ARG_ACTION_in_terminal841 = new BitSet(new long[]{0xFFFFFFFFFFFFFFF0L,0x0000007FFFFFFFFFL}); public static final BitSet FOLLOW_ARG_ACTION_in_terminal844 = new BitSet(new long[]{0xFFFFFFFFFFFFFFF0L,0x0000007FFFFFFFFFL});
public static final BitSet FOLLOW_TOKEN_REF_in_terminal854 = new BitSet(new long[]{0x0000000000000004L}); public static final BitSet FOLLOW_TOKEN_REF_in_terminal857 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_TOKEN_REF_in_terminal869 = new BitSet(new long[]{0x0000000000000002L}); public static final BitSet FOLLOW_TOKEN_REF_in_terminal872 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_ROOT_in_terminal883 = new BitSet(new long[]{0x0000000000000004L}); public static final BitSet FOLLOW_ROOT_in_terminal886 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_terminal_in_terminal885 = new BitSet(new long[]{0x0000000000000008L}); public static final BitSet FOLLOW_terminal_in_terminal888 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_BANG_in_terminal898 = new BitSet(new long[]{0x0000000000000004L}); public static final BitSet FOLLOW_BANG_in_terminal901 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_terminal_in_terminal900 = new BitSet(new long[]{0x0000000000000008L}); public static final BitSet FOLLOW_terminal_in_terminal903 = new BitSet(new long[]{0x0000000000000008L});
} }