jasder
/
antlr
1
0
Fork 1
Code Issues Pull Requests Releases 1 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 RANGE16 = 7;
public static final short WILDCARD = 8;
//public static final short NOT = 8; ???
public static final short SAVE = 9;
/** 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 byte[] code;
Map<String, Integer> ruleToAddr;
public int[] tokenTypeToAddr;
// 7, 29 -> rule
// 7..28, 29..len
public NFA(byte[] code, Map<String, Integer> ruleToAddr) {
this.code = code;
@ -193,8 +196,10 @@ workLoop:
addToClosure(closure, ip);
do { // while more work
c = input.LA(1);
int i = 0;
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);
ip = closure.get(i);
trace(ip);
@ -221,10 +226,13 @@ processOneChar:
addToClosure(reach, ip+4);
}
break;
case Bytecode.WILDCARD :
if ( c!=Token.EOF ) addToClosure(reach, ip);
break;
case Bytecode.ACCEPT :
int ttype = getShort(code, ip);
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 ) {
prevAcceptLastCharIndex = tokenLastCharIndex;
// choose longest match so far regardless of rule priority
@ -238,17 +246,34 @@ processOneChar:
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;
case Bytecode.JMP :
//break processOneChar;
case Bytecode.JMP : // ignore
case Bytecode.SPLIT :
break;
default :
throw new RuntimeException("invalid instruction @ "+ip+": "+opcode);
}
i++;
}
if ( reach.size()>0 ) { // if we reached other states, consume and process them
System.out.println("CONSUME");
input.consume();
}
// swap to avoid reallocating space
@ -258,7 +283,7 @@ processOneChar:
reach.clear();
} 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);
return ttype;
}

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

@ -19,7 +19,8 @@ public class CodeGenPipeline {
LexerGrammar lg = (LexerGrammar)g;
for (String modeName : lg.modes.keySet()) { // for each mode
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;
while ( ttype!= Token.EOF ) {
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 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 {
Token token;
int c;
@ -199,10 +206,13 @@ public class NFABytecodeGenerator extends TreeParser {
gen.emit(s0);
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
GrammarAST blk = (GrammarAST)r.ast.getFirstChildWithType(ANTLRParser.BLOCK);
CommonTreeNodeStream nodes = new CommonTreeNodeStream(adaptor,blk);
gen.setTreeNodeStream(nodes);
int ttype = lg.getTokenType(r.name);
tokenTypeToAddr[ttype] = gen.ip;
ruleToAddr.put(r.name, gen.ip);
if ( !r.isFragment() ) s0.addrs.add(gen.ip);
try {
@ -220,6 +230,7 @@ public class NFABytecodeGenerator extends TreeParser {
System.out.println("rule addrs="+ruleToAddr);
NFA nfa = new NFA(code, ruleToAddr);
nfa.tokenTypeToAddr = tokenTypeToAddr;
return nfa;
}

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

@ -97,14 +97,15 @@ ebnf
int start=ip;
SplitInstr S = new SplitInstr(2);
emit(S);
S.addrs.add(ip);
int blk = ip;
}
^(CLOSURE block)
{
JumpInstr J = new JumpInstr();
emit(J);
J.target = start;
S.addrs.add(ip);
S.addrs.add(blk);
S.addrs.add(ip); // reverse for nongreedy
}
| {int start=ip;} ^(POSITIVE_CLOSURE block)
{
@ -132,8 +133,8 @@ atom
| range
| ^(DOT ID terminal)
| ^(DOT ID ruleref)
| ^(WILDCARD .)
| WILDCARD
| ^(WILDCARD .) {emit(new WildcardInstr($WILDCARD.token));}
| WILDCARD {emit(new WildcardInstr($WILDCARD.token));}
| terminal
| 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;
import org.antlr.runtime.*;
import org.antlr.runtime.tree.TreeNodeStream;
import org.antlr.runtime.tree.TreeRuleReturnScope;
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.ArrayList;
public class NFABytecodeTriggers extends NFABytecodeGenerator {
public static final String[] tokenNames = new String[] {
@ -744,7 +743,7 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
int start=ip;
SplitInstr S = new SplitInstr(2);
emit(S);
S.addrs.add(ip);
int blk = ip;
match(input,CLOSURE,FOLLOW_CLOSURE_in_ebnf429);
@ -760,13 +759,14 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
JumpInstr J = new JumpInstr();
emit(J);
J.target = start;
S.addrs.add(ip);
S.addrs.add(blk);
S.addrs.add(ip); // reverse for nongreedy
}
break;
case 4 :
// NFABytecodeTriggers.g:109:4: ^( POSITIVE_CLOSURE block )
// NFABytecodeTriggers.g:110:4: ^( POSITIVE_CLOSURE block )
{
int start=ip;
match(input,POSITIVE_CLOSURE,FOLLOW_POSITIVE_CLOSURE_in_ebnf447);
@ -790,7 +790,7 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
}
break;
case 5 :
// NFABytecodeTriggers.g:117:5: block
// NFABytecodeTriggers.g:118:5: block
{
pushFollow(FOLLOW_block_in_ebnf460);
block();
@ -815,10 +815,10 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
// $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 {
try {
// NFABytecodeTriggers.g:121:5: ( ROOT | IMPLIES | BANG )
// NFABytecodeTriggers.g:122:5: ( ROOT | IMPLIES | BANG )
// NFABytecodeTriggers.g:
{
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"
// 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 {
GrammarAST WILDCARD1=null;
GrammarAST WILDCARD2=null;
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;
alt10 = dfa10.predict(input);
switch (alt10) {
case 1 :
// NFABytecodeTriggers.g:127:4: ^( ROOT range )
// NFABytecodeTriggers.g:128:4: ^( ROOT range )
{
match(input,ROOT,FOLLOW_ROOT_in_atom514);
@ -870,7 +873,7 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
}
break;
case 2 :
// NFABytecodeTriggers.g:128:4: ^( BANG range )
// NFABytecodeTriggers.g:129:4: ^( BANG range )
{
match(input,BANG,FOLLOW_BANG_in_atom526);
@ -886,7 +889,7 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
}
break;
case 3 :
// NFABytecodeTriggers.g:129:4: ^( ROOT notSet )
// NFABytecodeTriggers.g:130:4: ^( ROOT notSet )
{
match(input,ROOT,FOLLOW_ROOT_in_atom538);
@ -902,7 +905,7 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
}
break;
case 4 :
// NFABytecodeTriggers.g:130:4: ^( BANG notSet )
// NFABytecodeTriggers.g:131:4: ^( BANG notSet )
{
match(input,BANG,FOLLOW_BANG_in_atom550);
@ -918,7 +921,7 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
}
break;
case 5 :
// NFABytecodeTriggers.g:131:4: notSet
// NFABytecodeTriggers.g:132:4: notSet
{
pushFollow(FOLLOW_notSet_in_atom561);
notSet();
@ -929,7 +932,7 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
}
break;
case 6 :
// NFABytecodeTriggers.g:132:4: range
// NFABytecodeTriggers.g:133:4: range
{
pushFollow(FOLLOW_range_in_atom571);
range();
@ -940,7 +943,7 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
}
break;
case 7 :
// NFABytecodeTriggers.g:133:4: ^( DOT ID terminal )
// NFABytecodeTriggers.g:134:4: ^( DOT ID terminal )
{
match(input,DOT,FOLLOW_DOT_in_atom582);
@ -957,7 +960,7 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
}
break;
case 8 :
// NFABytecodeTriggers.g:134:4: ^( DOT ID ruleref )
// NFABytecodeTriggers.g:135:4: ^( DOT ID ruleref )
{
match(input,DOT,FOLLOW_DOT_in_atom595);
@ -974,28 +977,30 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
}
break;
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);
matchAny(input);
match(input, Token.UP, null);
emit(new WildcardInstr(WILDCARD1.token));
}
break;
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;
case 11 :
// NFABytecodeTriggers.g:137:9: terminal
// NFABytecodeTriggers.g:138:9: terminal
{
pushFollow(FOLLOW_terminal_in_atom639);
pushFollow(FOLLOW_terminal_in_atom642);
terminal();
state._fsp--;
@ -1004,9 +1009,9 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
}
break;
case 12 :
// NFABytecodeTriggers.g:138:9: ruleref
// NFABytecodeTriggers.g:139:9: ruleref
{
pushFollow(FOLLOW_ruleref_in_atom653);
pushFollow(FOLLOW_ruleref_in_atom656);
ruleref();
state._fsp--;
@ -1029,10 +1034,10 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
// $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 {
try {
// NFABytecodeTriggers.g:142:5: ( ^( NOT terminal ) | ^( NOT block ) )
// NFABytecodeTriggers.g:143:5: ( ^( NOT terminal ) | ^( NOT block ) )
int alt11=2;
int LA11_0 = input.LA(1);
@ -1042,12 +1047,12 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
if ( (LA11_1==DOWN) ) {
int LA11_2 = input.LA(3);
if ( (LA11_2==BLOCK) ) {
alt11=2;
}
else if ( (LA11_2==BANG||LA11_2==ROOT||LA11_2==TOKEN_REF||LA11_2==STRING_LITERAL) ) {
if ( (LA11_2==BANG||LA11_2==ROOT||LA11_2==TOKEN_REF||LA11_2==STRING_LITERAL) ) {
alt11=1;
}
else if ( (LA11_2==BLOCK) ) {
alt11=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 11, 2, input);
@ -1070,12 +1075,12 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
}
switch (alt11) {
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);
pushFollow(FOLLOW_terminal_in_notSet678);
pushFollow(FOLLOW_terminal_in_notSet681);
terminal();
state._fsp--;
@ -1086,12 +1091,12 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
}
break;
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);
pushFollow(FOLLOW_block_in_notSet692);
pushFollow(FOLLOW_block_in_notSet695);
block();
state._fsp--;
@ -1116,10 +1121,10 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
// $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 {
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;
switch ( input.LA(1) ) {
case ROOT:
@ -1146,16 +1151,16 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
switch (alt15) {
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,RULE_REF,FOLLOW_RULE_REF_in_ruleref717);
match(input,RULE_REF,FOLLOW_RULE_REF_in_ruleref720);
if ( input.LA(1)==Token.DOWN ) {
match(input, Token.DOWN, null);
// NFABytecodeTriggers.g:147:25: ( ARG_ACTION )?
// NFABytecodeTriggers.g:148:25: ( ARG_ACTION )?
int alt12=2;
int LA12_0 = input.LA(1);
@ -1164,9 +1169,9 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
}
switch (alt12) {
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;
@ -1182,16 +1187,16 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
}
break;
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,RULE_REF,FOLLOW_RULE_REF_in_ruleref735);
match(input,RULE_REF,FOLLOW_RULE_REF_in_ruleref738);
if ( input.LA(1)==Token.DOWN ) {
match(input, Token.DOWN, null);
// NFABytecodeTriggers.g:148:25: ( ARG_ACTION )?
// NFABytecodeTriggers.g:149:25: ( ARG_ACTION )?
int alt13=2;
int LA13_0 = input.LA(1);
@ -1200,9 +1205,9 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
}
switch (alt13) {
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;
@ -1218,13 +1223,13 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
}
break;
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 ) {
match(input, Token.DOWN, null);
// NFABytecodeTriggers.g:149:18: ( ARG_ACTION )?
// NFABytecodeTriggers.g:150:18: ( ARG_ACTION )?
int alt14=2;
int LA14_0 = input.LA(1);
@ -1233,9 +1238,9 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
}
switch (alt14) {
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;
@ -1263,20 +1268,20 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
// $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 {
GrammarAST a=null;
GrammarAST b=null;
try {
// NFABytecodeTriggers.g:153:5: ( ^( RANGE a= STRING_LITERAL b= STRING_LITERAL ) )
// NFABytecodeTriggers.g:153:7: ^( RANGE a= STRING_LITERAL b= STRING_LITERAL )
// NFABytecodeTriggers.g:154:5: ( ^( 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);
a=(GrammarAST)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_range779);
b=(GrammarAST)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_range783);
a=(GrammarAST)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_range782);
b=(GrammarAST)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_range786);
match(input, Token.UP, null);
emit(new RangeInstr(a.token, b.token));
@ -1296,44 +1301,44 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
// $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 {
GrammarAST STRING_LITERAL1=null;
GrammarAST STRING_LITERAL2=null;
GrammarAST STRING_LITERAL3=null;
GrammarAST STRING_LITERAL4=null;
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;
alt16 = dfa16.predict(input);
switch (alt16) {
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);
matchAny(input);
match(input, Token.UP, null);
emitString(STRING_LITERAL1.token);
emitString(STRING_LITERAL3.token);
}
break;
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);
emitString(STRING_LITERAL2.token);
STRING_LITERAL4=(GrammarAST)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_terminal828);
emitString(STRING_LITERAL4.token);
}
break;
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,ARG_ACTION,FOLLOW_ARG_ACTION_in_terminal841);
match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_terminal844);
matchAny(input);
match(input, Token.UP, null);
@ -1341,9 +1346,9 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
}
break;
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);
matchAny(input);
@ -1353,19 +1358,19 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
}
break;
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;
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);
pushFollow(FOLLOW_terminal_in_terminal885);
pushFollow(FOLLOW_terminal_in_terminal888);
terminal();
state._fsp--;
@ -1376,12 +1381,12 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
}
break;
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);
pushFollow(FOLLOW_terminal_in_terminal900);
pushFollow(FOLLOW_terminal_in_terminal903);
terminal();
state._fsp--;
@ -1616,7 +1621,7 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
this.transition = DFA10_transition;
}
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 =
@ -1682,7 +1687,7 @@ public class NFABytecodeTriggers extends NFABytecodeGenerator {
this.transition = DFA16_transition;
}
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_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_atom625 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_terminal_in_atom639 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_ruleref_in_atom653 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_NOT_in_notSet676 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_terminal_in_notSet678 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_NOT_in_notSet690 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_block_in_notSet692 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_ROOT_in_ruleref714 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_RULE_REF_in_ruleref717 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ARG_ACTION_in_ruleref719 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_BANG_in_ruleref732 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_RULE_REF_in_ruleref735 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ARG_ACTION_in_ruleref737 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_RULE_REF_in_ruleref750 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ARG_ACTION_in_ruleref752 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_RANGE_in_range775 = 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_range783 = 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_terminal825 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_TOKEN_REF_in_terminal839 = 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_TOKEN_REF_in_terminal854 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_TOKEN_REF_in_terminal869 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_ROOT_in_terminal883 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_terminal_in_terminal885 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_BANG_in_terminal898 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_terminal_in_terminal900 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_WILDCARD_in_atom627 = 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_atom656 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_NOT_in_notSet679 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_terminal_in_notSet681 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_NOT_in_notSet693 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_block_in_notSet695 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_ROOT_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_ruleref722 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_BANG_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_ruleref740 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_RULE_REF_in_ruleref753 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ARG_ACTION_in_ruleref755 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_RANGE_in_range778 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_STRING_LITERAL_in_range782 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
public static final BitSet FOLLOW_STRING_LITERAL_in_range786 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_STRING_LITERAL_in_terminal813 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_STRING_LITERAL_in_terminal828 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_TOKEN_REF_in_terminal842 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ARG_ACTION_in_terminal844 = new BitSet(new long[]{0xFFFFFFFFFFFFFFF0L,0x0000007FFFFFFFFFL});
public static final BitSet FOLLOW_TOKEN_REF_in_terminal857 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_TOKEN_REF_in_terminal872 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_ROOT_in_terminal886 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_terminal_in_terminal888 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_BANG_in_terminal901 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_terminal_in_terminal903 = new BitSet(new long[]{0x0000000000000008L});
}