org.antlr.v4.parse.LeftRecursiveRuleWalker Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of antlr4 Show documentation
Show all versions of antlr4 Show documentation
The ANTLR 4 grammar compiler.
// $ANTLR 3.5 org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g 2014-02-08 10:59:30
package org.antlr.v4.parse;
import org.antlr.v4.misc.*;
import org.antlr.v4.tool.*;
import org.antlr.v4.tool.ast.*;
import org.antlr.runtime.*;
import org.antlr.runtime.tree.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
/** Find left-recursive rules */
@SuppressWarnings("all")
public class LeftRecursiveRuleWalker extends TreeParser {
public static final String[] tokenNames = new String[] {
"", "", "", "", "ACTION", "ACTION_CHAR_LITERAL",
"ACTION_ESC", "ACTION_STRING_LITERAL", "ARG_ACTION", "ARG_OR_CHARSET",
"ASSIGN", "AT", "CATCH", "COLON", "COLONCOLON", "COMMA", "COMMENT", "DOC_COMMENT",
"DOLLAR", "DOT", "ERRCHAR", "ESC_SEQ", "FINALLY", "FRAGMENT", "GRAMMAR",
"GT", "HEX_DIGIT", "ID", "IMPORT", "INT", "LEXER", "LEXER_CHAR_SET", "LOCALS",
"LPAREN", "LT", "MODE", "NESTED_ACTION", "NLCHARS", "NOT", "NameChar",
"NameStartChar", "OPTIONS", "OR", "PARSER", "PLUS", "PLUS_ASSIGN", "POUND",
"PRIVATE", "PROTECTED", "PUBLIC", "QUESTION", "RANGE", "RARROW", "RBRACE",
"RETURNS", "RPAREN", "RULE_REF", "SEMI", "SEMPRED", "SRC", "STAR", "STRING_LITERAL",
"SYNPRED", "THROWS", "TOKENS_SPEC", "TOKEN_REF", "TREE_GRAMMAR", "UNICODE_ESC",
"UnicodeBOM", "WS", "WSCHARS", "WSNLCHARS", "ALT", "ALTLIST", "ARG", "ARGLIST",
"BLOCK", "CHAR_RANGE", "CLOSURE", "COMBINED", "ELEMENT_OPTIONS", "EPSILON",
"INITACTION", "LABEL", "LEXER_ACTION_CALL", "LEXER_ALT_ACTION", "LIST",
"OPTIONAL", "POSITIVE_CLOSURE", "PREC_RULE", "RESULT", "RET", "RULE",
"RULEACTIONS", "RULEMODIFIERS", "RULES", "SET", "TEMPLATE", "WILDCARD"
};
public static final int EOF=-1;
public static final int ACTION=4;
public static final int ACTION_CHAR_LITERAL=5;
public static final int ACTION_ESC=6;
public static final int ACTION_STRING_LITERAL=7;
public static final int ARG_ACTION=8;
public static final int ARG_OR_CHARSET=9;
public static final int ASSIGN=10;
public static final int AT=11;
public static final int CATCH=12;
public static final int COLON=13;
public static final int COLONCOLON=14;
public static final int COMMA=15;
public static final int COMMENT=16;
public static final int DOC_COMMENT=17;
public static final int DOLLAR=18;
public static final int DOT=19;
public static final int ERRCHAR=20;
public static final int ESC_SEQ=21;
public static final int FINALLY=22;
public static final int FRAGMENT=23;
public static final int GRAMMAR=24;
public static final int GT=25;
public static final int HEX_DIGIT=26;
public static final int ID=27;
public static final int IMPORT=28;
public static final int INT=29;
public static final int LEXER=30;
public static final int LEXER_CHAR_SET=31;
public static final int LOCALS=32;
public static final int LPAREN=33;
public static final int LT=34;
public static final int MODE=35;
public static final int NESTED_ACTION=36;
public static final int NLCHARS=37;
public static final int NOT=38;
public static final int NameChar=39;
public static final int NameStartChar=40;
public static final int OPTIONS=41;
public static final int OR=42;
public static final int PARSER=43;
public static final int PLUS=44;
public static final int PLUS_ASSIGN=45;
public static final int POUND=46;
public static final int PRIVATE=47;
public static final int PROTECTED=48;
public static final int PUBLIC=49;
public static final int QUESTION=50;
public static final int RANGE=51;
public static final int RARROW=52;
public static final int RBRACE=53;
public static final int RETURNS=54;
public static final int RPAREN=55;
public static final int RULE_REF=56;
public static final int SEMI=57;
public static final int SEMPRED=58;
public static final int SRC=59;
public static final int STAR=60;
public static final int STRING_LITERAL=61;
public static final int SYNPRED=62;
public static final int THROWS=63;
public static final int TOKENS_SPEC=64;
public static final int TOKEN_REF=65;
public static final int TREE_GRAMMAR=66;
public static final int UNICODE_ESC=67;
public static final int UnicodeBOM=68;
public static final int WS=69;
public static final int WSCHARS=70;
public static final int WSNLCHARS=71;
public static final int ALT=72;
public static final int ALTLIST=73;
public static final int ARG=74;
public static final int ARGLIST=75;
public static final int BLOCK=76;
public static final int CHAR_RANGE=77;
public static final int CLOSURE=78;
public static final int COMBINED=79;
public static final int ELEMENT_OPTIONS=80;
public static final int EPSILON=81;
public static final int INITACTION=82;
public static final int LABEL=83;
public static final int LEXER_ACTION_CALL=84;
public static final int LEXER_ALT_ACTION=85;
public static final int LIST=86;
public static final int OPTIONAL=87;
public static final int POSITIVE_CLOSURE=88;
public static final int PREC_RULE=89;
public static final int RESULT=90;
public static final int RET=91;
public static final int RULE=92;
public static final int RULEACTIONS=93;
public static final int RULEMODIFIERS=94;
public static final int RULES=95;
public static final int SET=96;
public static final int TEMPLATE=97;
public static final int WILDCARD=98;
// delegates
public TreeParser[] getDelegates() {
return new TreeParser[] {};
}
// delegators
public LeftRecursiveRuleWalker(TreeNodeStream input) {
this(input, new RecognizerSharedState());
}
public LeftRecursiveRuleWalker(TreeNodeStream input, RecognizerSharedState state) {
super(input, state);
}
@Override public String[] getTokenNames() { return LeftRecursiveRuleWalker.tokenNames; }
@Override public String getGrammarFileName() { return "org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g"; }
private String ruleName;
private int currentOuterAltNumber; // which outer alt of rule?
public int numAlts; // how many alts for this rule total?
public void setAltAssoc(AltAST altTree, int alt) {}
public void binaryAlt(AltAST altTree, int alt) {}
public void prefixAlt(AltAST altTree, int alt) {}
public void suffixAlt(AltAST altTree, int alt) {}
public void otherAlt(AltAST altTree, int alt) {}
public void setReturnValues(GrammarAST t) {}
// $ANTLR start "rec_rule"
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:64:1: public rec_rule returns [boolean isLeftRec] : ^(r= RULE id= RULE_REF ( DOC_COMMENT )? ( ruleModifier )? ( ^( RETURNS a= ARG_ACTION ) )? ( ^( LOCALS ARG_ACTION ) )? ( ^( OPTIONS ( . )* ) | ^( AT ID ACTION ) )* ruleBlock exceptionGroup ) ;
public final boolean rec_rule() throws RecognitionException {
boolean isLeftRec = false;
GrammarAST r=null;
GrammarAST id=null;
GrammarAST a=null;
TreeRuleReturnScope ruleBlock1 =null;
currentOuterAltNumber = 1;
try {
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:69:2: ( ^(r= RULE id= RULE_REF ( DOC_COMMENT )? ( ruleModifier )? ( ^( RETURNS a= ARG_ACTION ) )? ( ^( LOCALS ARG_ACTION ) )? ( ^( OPTIONS ( . )* ) | ^( AT ID ACTION ) )* ruleBlock exceptionGroup ) )
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:69:4: ^(r= RULE id= RULE_REF ( DOC_COMMENT )? ( ruleModifier )? ( ^( RETURNS a= ARG_ACTION ) )? ( ^( LOCALS ARG_ACTION ) )? ( ^( OPTIONS ( . )* ) | ^( AT ID ACTION ) )* ruleBlock exceptionGroup )
{
r=(GrammarAST)match(input,RULE,FOLLOW_RULE_in_rec_rule72); if (state.failed) return isLeftRec;
match(input, Token.DOWN, null); if (state.failed) return isLeftRec;
id=(GrammarAST)match(input,RULE_REF,FOLLOW_RULE_REF_in_rec_rule76); if (state.failed) return isLeftRec;
if ( state.backtracking==0 ) {ruleName=id.getText();}
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:70:4: ( DOC_COMMENT )?
int alt1=2;
int LA1_0 = input.LA(1);
if ( (LA1_0==DOC_COMMENT) ) {
alt1=1;
}
switch (alt1) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:70:4: DOC_COMMENT
{
match(input,DOC_COMMENT,FOLLOW_DOC_COMMENT_in_rec_rule83); if (state.failed) return isLeftRec;
}
break;
}
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:70:17: ( ruleModifier )?
int alt2=2;
int LA2_0 = input.LA(1);
if ( ((LA2_0 >= PRIVATE && LA2_0 <= PUBLIC)) ) {
alt2=1;
}
switch (alt2) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:70:17: ruleModifier
{
pushFollow(FOLLOW_ruleModifier_in_rec_rule86);
ruleModifier();
state._fsp--;
if (state.failed) return isLeftRec;
}
break;
}
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:72:4: ( ^( RETURNS a= ARG_ACTION ) )?
int alt3=2;
int LA3_0 = input.LA(1);
if ( (LA3_0==RETURNS) ) {
alt3=1;
}
switch (alt3) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:72:5: ^( RETURNS a= ARG_ACTION )
{
match(input,RETURNS,FOLLOW_RETURNS_in_rec_rule95); if (state.failed) return isLeftRec;
match(input, Token.DOWN, null); if (state.failed) return isLeftRec;
a=(GrammarAST)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_rec_rule99); if (state.failed) return isLeftRec;
if ( state.backtracking==0 ) {setReturnValues(a);}
match(input, Token.UP, null); if (state.failed) return isLeftRec;
}
break;
}
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:74:9: ( ^( LOCALS ARG_ACTION ) )?
int alt4=2;
int LA4_0 = input.LA(1);
if ( (LA4_0==LOCALS) ) {
alt4=1;
}
switch (alt4) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:74:11: ^( LOCALS ARG_ACTION )
{
match(input,LOCALS,FOLLOW_LOCALS_in_rec_rule118); if (state.failed) return isLeftRec;
match(input, Token.DOWN, null); if (state.failed) return isLeftRec;
match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_rec_rule120); if (state.failed) return isLeftRec;
match(input, Token.UP, null); if (state.failed) return isLeftRec;
}
break;
}
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:75:9: ( ^( OPTIONS ( . )* ) | ^( AT ID ACTION ) )*
loop6:
while (true) {
int alt6=3;
int LA6_0 = input.LA(1);
if ( (LA6_0==OPTIONS) ) {
alt6=1;
}
else if ( (LA6_0==AT) ) {
alt6=2;
}
switch (alt6) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:75:11: ^( OPTIONS ( . )* )
{
match(input,OPTIONS,FOLLOW_OPTIONS_in_rec_rule138); if (state.failed) return isLeftRec;
if ( input.LA(1)==Token.DOWN ) {
match(input, Token.DOWN, null); if (state.failed) return isLeftRec;
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:75:21: ( . )*
loop5:
while (true) {
int alt5=2;
int LA5_0 = input.LA(1);
if ( ((LA5_0 >= ACTION && LA5_0 <= WILDCARD)) ) {
alt5=1;
}
else if ( (LA5_0==UP) ) {
alt5=2;
}
switch (alt5) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:75:21: .
{
matchAny(input); if (state.failed) return isLeftRec;
}
break;
default :
break loop5;
}
}
match(input, Token.UP, null); if (state.failed) return isLeftRec;
}
}
break;
case 2 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:76:11: ^( AT ID ACTION )
{
match(input,AT,FOLLOW_AT_in_rec_rule155); if (state.failed) return isLeftRec;
match(input, Token.DOWN, null); if (state.failed) return isLeftRec;
match(input,ID,FOLLOW_ID_in_rec_rule157); if (state.failed) return isLeftRec;
match(input,ACTION,FOLLOW_ACTION_in_rec_rule159); if (state.failed) return isLeftRec;
match(input, Token.UP, null); if (state.failed) return isLeftRec;
}
break;
default :
break loop6;
}
}
pushFollow(FOLLOW_ruleBlock_in_rec_rule175);
ruleBlock1=ruleBlock();
state._fsp--;
if (state.failed) return isLeftRec;
if ( state.backtracking==0 ) {isLeftRec = (ruleBlock1!=null?((LeftRecursiveRuleWalker.ruleBlock_return)ruleBlock1).isLeftRec:false);}
pushFollow(FOLLOW_exceptionGroup_in_rec_rule182);
exceptionGroup();
state._fsp--;
if (state.failed) return isLeftRec;
match(input, Token.UP, null); if (state.failed) return isLeftRec;
}
}
finally {
// do for sure before leaving
}
return isLeftRec;
}
// $ANTLR end "rec_rule"
// $ANTLR start "exceptionGroup"
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:83:1: exceptionGroup : ( exceptionHandler )* ( finallyClause )? ;
public final void exceptionGroup() throws RecognitionException {
try {
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:84:5: ( ( exceptionHandler )* ( finallyClause )? )
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:84:7: ( exceptionHandler )* ( finallyClause )?
{
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:84:7: ( exceptionHandler )*
loop7:
while (true) {
int alt7=2;
int LA7_0 = input.LA(1);
if ( (LA7_0==CATCH) ) {
alt7=1;
}
switch (alt7) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:84:7: exceptionHandler
{
pushFollow(FOLLOW_exceptionHandler_in_exceptionGroup200);
exceptionHandler();
state._fsp--;
if (state.failed) return;
}
break;
default :
break loop7;
}
}
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:84:25: ( finallyClause )?
int alt8=2;
int LA8_0 = input.LA(1);
if ( (LA8_0==FINALLY) ) {
alt8=1;
}
switch (alt8) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:84:25: finallyClause
{
pushFollow(FOLLOW_finallyClause_in_exceptionGroup203);
finallyClause();
state._fsp--;
if (state.failed) return;
}
break;
}
}
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "exceptionGroup"
// $ANTLR start "exceptionHandler"
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:87:1: exceptionHandler : ^( CATCH ARG_ACTION ACTION ) ;
public final void exceptionHandler() throws RecognitionException {
try {
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:88:2: ( ^( CATCH ARG_ACTION ACTION ) )
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:88:4: ^( CATCH ARG_ACTION ACTION )
{
match(input,CATCH,FOLLOW_CATCH_in_exceptionHandler219); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_exceptionHandler221); if (state.failed) return;
match(input,ACTION,FOLLOW_ACTION_in_exceptionHandler223); if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "exceptionHandler"
// $ANTLR start "finallyClause"
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:91:1: finallyClause : ^( FINALLY ACTION ) ;
public final void finallyClause() throws RecognitionException {
try {
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:92:2: ( ^( FINALLY ACTION ) )
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:92:4: ^( FINALLY ACTION )
{
match(input,FINALLY,FOLLOW_FINALLY_in_finallyClause236); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
match(input,ACTION,FOLLOW_ACTION_in_finallyClause238); if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "finallyClause"
// $ANTLR start "ruleModifier"
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:95:1: ruleModifier : ( PUBLIC | PRIVATE | PROTECTED );
public final void ruleModifier() throws RecognitionException {
try {
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:96:5: ( PUBLIC | PRIVATE | PROTECTED )
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:
{
if ( (input.LA(1) >= PRIVATE && input.LA(1) <= PUBLIC) ) {
input.consume();
state.errorRecovery=false;
state.failed=false;
}
else {
if (state.backtracking>0) {state.failed=true; return;}
MismatchedSetException mse = new MismatchedSetException(null,input);
throw mse;
}
}
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "ruleModifier"
public static class ruleBlock_return extends TreeRuleReturnScope {
public boolean isLeftRec;
};
// $ANTLR start "ruleBlock"
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:101:1: ruleBlock returns [boolean isLeftRec] : ^( BLOCK (o= outerAlternative )+ ) ;
public final LeftRecursiveRuleWalker.ruleBlock_return ruleBlock() throws RecognitionException {
LeftRecursiveRuleWalker.ruleBlock_return retval = new LeftRecursiveRuleWalker.ruleBlock_return();
retval.start = input.LT(1);
TreeRuleReturnScope o =null;
boolean lr=false; this.numAlts = ((GrammarAST)retval.start).getChildCount();
try {
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:103:2: ( ^( BLOCK (o= outerAlternative )+ ) )
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:103:4: ^( BLOCK (o= outerAlternative )+ )
{
match(input,BLOCK,FOLLOW_BLOCK_in_ruleBlock293); if (state.failed) return retval;
match(input, Token.DOWN, null); if (state.failed) return retval;
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:104:4: (o= outerAlternative )+
int cnt9=0;
loop9:
while (true) {
int alt9=2;
int LA9_0 = input.LA(1);
if ( (LA9_0==ALT) ) {
alt9=1;
}
switch (alt9) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:105:5: o= outerAlternative
{
pushFollow(FOLLOW_outerAlternative_in_ruleBlock306);
o=outerAlternative();
state._fsp--;
if (state.failed) return retval;
if ( state.backtracking==0 ) {if ((o!=null?((LeftRecursiveRuleWalker.outerAlternative_return)o).isLeftRec:false)) retval.isLeftRec = true;}
if ( state.backtracking==0 ) {currentOuterAltNumber++;}
}
break;
default :
if ( cnt9 >= 1 ) break loop9;
if (state.backtracking>0) {state.failed=true; return retval;}
EarlyExitException eee = new EarlyExitException(9, input);
throw eee;
}
cnt9++;
}
match(input, Token.UP, null); if (state.failed) return retval;
}
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "ruleBlock"
public static class outerAlternative_return extends TreeRuleReturnScope {
public boolean isLeftRec;
};
// $ANTLR start "outerAlternative"
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:113:1: outerAlternative returns [boolean isLeftRec] : ( ( binary )=> binary | ( prefix )=> prefix | ( suffix )=> suffix | nonLeftRecur );
public final LeftRecursiveRuleWalker.outerAlternative_return outerAlternative() throws RecognitionException {
LeftRecursiveRuleWalker.outerAlternative_return retval = new LeftRecursiveRuleWalker.outerAlternative_return();
retval.start = input.LT(1);
try {
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:114:5: ( ( binary )=> binary | ( prefix )=> prefix | ( suffix )=> suffix | nonLeftRecur )
int alt10=4;
int LA10_0 = input.LA(1);
if ( (LA10_0==ALT) ) {
int LA10_1 = input.LA(2);
if ( (synpred1_LeftRecursiveRuleWalker()) ) {
alt10=1;
}
else if ( (synpred2_LeftRecursiveRuleWalker()) ) {
alt10=2;
}
else if ( (synpred3_LeftRecursiveRuleWalker()) ) {
alt10=3;
}
else if ( (true) ) {
alt10=4;
}
}
else {
if (state.backtracking>0) {state.failed=true; return retval;}
NoViableAltException nvae =
new NoViableAltException("", 10, 0, input);
throw nvae;
}
switch (alt10) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:114:9: ( binary )=> binary
{
pushFollow(FOLLOW_binary_in_outerAlternative365);
binary();
state._fsp--;
if (state.failed) return retval;
if ( state.backtracking==0 ) {binaryAlt((AltAST)((GrammarAST)retval.start), currentOuterAltNumber); retval.isLeftRec =true;}
}
break;
case 2 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:116:9: ( prefix )=> prefix
{
pushFollow(FOLLOW_prefix_in_outerAlternative421);
prefix();
state._fsp--;
if (state.failed) return retval;
if ( state.backtracking==0 ) {prefixAlt((AltAST)((GrammarAST)retval.start), currentOuterAltNumber);}
}
break;
case 3 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:118:9: ( suffix )=> suffix
{
pushFollow(FOLLOW_suffix_in_outerAlternative477);
suffix();
state._fsp--;
if (state.failed) return retval;
if ( state.backtracking==0 ) {suffixAlt((AltAST)((GrammarAST)retval.start), currentOuterAltNumber); retval.isLeftRec =true;}
}
break;
case 4 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:120:9: nonLeftRecur
{
pushFollow(FOLLOW_nonLeftRecur_in_outerAlternative518);
nonLeftRecur();
state._fsp--;
if (state.failed) return retval;
if ( state.backtracking==0 ) {otherAlt((AltAST)((GrammarAST)retval.start), currentOuterAltNumber);}
}
break;
}
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "outerAlternative"
// $ANTLR start "binary"
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:123:1: binary : ^( ALT ( elementOptions )? recurse ( element )+ recurse ( ACTION )? ) ;
public final void binary() throws RecognitionException {
GrammarAST ALT2=null;
try {
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:124:2: ( ^( ALT ( elementOptions )? recurse ( element )+ recurse ( ACTION )? ) )
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:124:4: ^( ALT ( elementOptions )? recurse ( element )+ recurse ( ACTION )? )
{
ALT2=(GrammarAST)match(input,ALT,FOLLOW_ALT_in_binary544); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:124:11: ( elementOptions )?
int alt11=2;
int LA11_0 = input.LA(1);
if ( (LA11_0==ELEMENT_OPTIONS) ) {
alt11=1;
}
switch (alt11) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:124:11: elementOptions
{
pushFollow(FOLLOW_elementOptions_in_binary546);
elementOptions();
state._fsp--;
if (state.failed) return;
}
break;
}
pushFollow(FOLLOW_recurse_in_binary549);
recurse();
state._fsp--;
if (state.failed) return;
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:124:35: ( element )+
int cnt12=0;
loop12:
while (true) {
int alt12=2;
switch ( input.LA(1) ) {
case ASSIGN:
{
int LA12_1 = input.LA(2);
if ( (LA12_1==DOWN) ) {
int LA12_4 = input.LA(3);
if ( (LA12_4==ID) ) {
int LA12_7 = input.LA(4);
if ( (LA12_7==RULE_REF) ) {
int LA12_8 = input.LA(5);
if ( (LA12_8==DOWN) ) {
alt12=1;
}
else if ( (LA12_8==UP) ) {
int LA12_9 = input.LA(6);
if ( (LA12_9==ACTION) ) {
int LA12_10 = input.LA(7);
if ( (LA12_10==ACTION||LA12_10==ASSIGN||LA12_10==DOT||LA12_10==NOT||LA12_10==PLUS_ASSIGN||LA12_10==RANGE||LA12_10==RULE_REF||LA12_10==SEMPRED||LA12_10==STRING_LITERAL||LA12_10==TOKEN_REF||LA12_10==BLOCK||LA12_10==CLOSURE||LA12_10==EPSILON||(LA12_10 >= OPTIONAL && LA12_10 <= POSITIVE_CLOSURE)||LA12_10==SET||LA12_10==WILDCARD) ) {
alt12=1;
}
}
else if ( (LA12_9==ASSIGN||LA12_9==DOT||LA12_9==NOT||LA12_9==PLUS_ASSIGN||LA12_9==RANGE||LA12_9==RULE_REF||LA12_9==SEMPRED||LA12_9==STRING_LITERAL||LA12_9==TOKEN_REF||LA12_9==BLOCK||LA12_9==CLOSURE||LA12_9==EPSILON||(LA12_9 >= OPTIONAL && LA12_9 <= POSITIVE_CLOSURE)||LA12_9==SET||LA12_9==WILDCARD) ) {
alt12=1;
}
}
}
else if ( (LA12_7==ACTION||LA12_7==ASSIGN||LA12_7==DOT||LA12_7==NOT||LA12_7==PLUS_ASSIGN||LA12_7==RANGE||LA12_7==SEMPRED||LA12_7==STRING_LITERAL||LA12_7==TOKEN_REF||LA12_7==BLOCK||LA12_7==CLOSURE||LA12_7==EPSILON||(LA12_7 >= OPTIONAL && LA12_7 <= POSITIVE_CLOSURE)||LA12_7==SET||LA12_7==WILDCARD) ) {
alt12=1;
}
}
}
}
break;
case RULE_REF:
{
int LA12_2 = input.LA(2);
if ( (LA12_2==DOWN||LA12_2==ASSIGN||LA12_2==DOT||LA12_2==NOT||LA12_2==PLUS_ASSIGN||LA12_2==RANGE||LA12_2==RULE_REF||LA12_2==SEMPRED||LA12_2==STRING_LITERAL||LA12_2==TOKEN_REF||LA12_2==BLOCK||LA12_2==CLOSURE||LA12_2==EPSILON||(LA12_2 >= OPTIONAL && LA12_2 <= POSITIVE_CLOSURE)||LA12_2==SET||LA12_2==WILDCARD) ) {
alt12=1;
}
else if ( (LA12_2==ACTION) ) {
int LA12_5 = input.LA(3);
if ( (LA12_5==ACTION||LA12_5==ASSIGN||LA12_5==DOT||LA12_5==NOT||LA12_5==PLUS_ASSIGN||LA12_5==RANGE||LA12_5==RULE_REF||LA12_5==SEMPRED||LA12_5==STRING_LITERAL||LA12_5==TOKEN_REF||LA12_5==BLOCK||LA12_5==CLOSURE||LA12_5==EPSILON||(LA12_5 >= OPTIONAL && LA12_5 <= POSITIVE_CLOSURE)||LA12_5==SET||LA12_5==WILDCARD) ) {
alt12=1;
}
}
}
break;
case ACTION:
case DOT:
case NOT:
case PLUS_ASSIGN:
case RANGE:
case SEMPRED:
case STRING_LITERAL:
case TOKEN_REF:
case BLOCK:
case CLOSURE:
case EPSILON:
case OPTIONAL:
case POSITIVE_CLOSURE:
case SET:
case WILDCARD:
{
alt12=1;
}
break;
}
switch (alt12) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:124:35: element
{
pushFollow(FOLLOW_element_in_binary551);
element();
state._fsp--;
if (state.failed) return;
}
break;
default :
if ( cnt12 >= 1 ) break loop12;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(12, input);
throw eee;
}
cnt12++;
}
pushFollow(FOLLOW_recurse_in_binary554);
recurse();
state._fsp--;
if (state.failed) return;
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:124:52: ( ACTION )?
int alt13=2;
int LA13_0 = input.LA(1);
if ( (LA13_0==ACTION) ) {
alt13=1;
}
switch (alt13) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:124:52: ACTION
{
match(input,ACTION,FOLLOW_ACTION_in_binary556); if (state.failed) return;
}
break;
}
match(input, Token.UP, null); if (state.failed) return;
if ( state.backtracking==0 ) {setAltAssoc((AltAST)ALT2,currentOuterAltNumber);}
}
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "binary"
// $ANTLR start "prefix"
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:128:1: prefix : ^( ALT ( elementOptions )? ({...}? element )+ recurse ( ACTION )? ) ;
public final void prefix() throws RecognitionException {
GrammarAST ALT3=null;
try {
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:129:2: ( ^( ALT ( elementOptions )? ({...}? element )+ recurse ( ACTION )? ) )
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:129:4: ^( ALT ( elementOptions )? ({...}? element )+ recurse ( ACTION )? )
{
ALT3=(GrammarAST)match(input,ALT,FOLLOW_ALT_in_prefix582); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:129:11: ( elementOptions )?
int alt14=2;
int LA14_0 = input.LA(1);
if ( (LA14_0==ELEMENT_OPTIONS) ) {
alt14=1;
}
switch (alt14) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:129:11: elementOptions
{
pushFollow(FOLLOW_elementOptions_in_prefix584);
elementOptions();
state._fsp--;
if (state.failed) return;
}
break;
}
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:130:4: ({...}? element )+
int cnt15=0;
loop15:
while (true) {
int alt15=2;
switch ( input.LA(1) ) {
case ASSIGN:
{
int LA15_1 = input.LA(2);
if ( (LA15_1==DOWN) ) {
int LA15_4 = input.LA(3);
if ( (LA15_4==ID) ) {
int LA15_7 = input.LA(4);
if ( (LA15_7==RULE_REF) ) {
int LA15_8 = input.LA(5);
if ( (LA15_8==DOWN) ) {
alt15=1;
}
else if ( (LA15_8==UP) ) {
int LA15_9 = input.LA(6);
if ( (LA15_9==ACTION) ) {
int LA15_10 = input.LA(7);
if ( (LA15_10==ACTION||LA15_10==ASSIGN||LA15_10==DOT||LA15_10==NOT||LA15_10==PLUS_ASSIGN||LA15_10==RANGE||LA15_10==RULE_REF||LA15_10==SEMPRED||LA15_10==STRING_LITERAL||LA15_10==TOKEN_REF||LA15_10==BLOCK||LA15_10==CLOSURE||LA15_10==EPSILON||(LA15_10 >= OPTIONAL && LA15_10 <= POSITIVE_CLOSURE)||LA15_10==SET||LA15_10==WILDCARD) ) {
alt15=1;
}
}
else if ( (LA15_9==ASSIGN||LA15_9==DOT||LA15_9==NOT||LA15_9==PLUS_ASSIGN||LA15_9==RANGE||LA15_9==RULE_REF||LA15_9==SEMPRED||LA15_9==STRING_LITERAL||LA15_9==TOKEN_REF||LA15_9==BLOCK||LA15_9==CLOSURE||LA15_9==EPSILON||(LA15_9 >= OPTIONAL && LA15_9 <= POSITIVE_CLOSURE)||LA15_9==SET||LA15_9==WILDCARD) ) {
alt15=1;
}
}
}
else if ( (LA15_7==ACTION||LA15_7==ASSIGN||LA15_7==DOT||LA15_7==NOT||LA15_7==PLUS_ASSIGN||LA15_7==RANGE||LA15_7==SEMPRED||LA15_7==STRING_LITERAL||LA15_7==TOKEN_REF||LA15_7==BLOCK||LA15_7==CLOSURE||LA15_7==EPSILON||(LA15_7 >= OPTIONAL && LA15_7 <= POSITIVE_CLOSURE)||LA15_7==SET||LA15_7==WILDCARD) ) {
alt15=1;
}
}
}
}
break;
case RULE_REF:
{
int LA15_2 = input.LA(2);
if ( (LA15_2==DOWN||LA15_2==ASSIGN||LA15_2==DOT||LA15_2==NOT||LA15_2==PLUS_ASSIGN||LA15_2==RANGE||LA15_2==RULE_REF||LA15_2==SEMPRED||LA15_2==STRING_LITERAL||LA15_2==TOKEN_REF||LA15_2==BLOCK||LA15_2==CLOSURE||LA15_2==EPSILON||(LA15_2 >= OPTIONAL && LA15_2 <= POSITIVE_CLOSURE)||LA15_2==SET||LA15_2==WILDCARD) ) {
alt15=1;
}
else if ( (LA15_2==ACTION) ) {
int LA15_5 = input.LA(3);
if ( (LA15_5==ACTION||LA15_5==ASSIGN||LA15_5==DOT||LA15_5==NOT||LA15_5==PLUS_ASSIGN||LA15_5==RANGE||LA15_5==RULE_REF||LA15_5==SEMPRED||LA15_5==STRING_LITERAL||LA15_5==TOKEN_REF||LA15_5==BLOCK||LA15_5==CLOSURE||LA15_5==EPSILON||(LA15_5 >= OPTIONAL && LA15_5 <= POSITIVE_CLOSURE)||LA15_5==SET||LA15_5==WILDCARD) ) {
alt15=1;
}
}
}
break;
case ACTION:
case DOT:
case NOT:
case PLUS_ASSIGN:
case RANGE:
case SEMPRED:
case STRING_LITERAL:
case TOKEN_REF:
case BLOCK:
case CLOSURE:
case EPSILON:
case OPTIONAL:
case POSITIVE_CLOSURE:
case SET:
case WILDCARD:
{
alt15=1;
}
break;
}
switch (alt15) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:130:5: {...}? element
{
if ( !((!((CommonTree)input.LT(1)).getText().equals(ruleName))) ) {
if (state.backtracking>0) {state.failed=true; return;}
throw new FailedPredicateException(input, "prefix", "!((CommonTree)input.LT(1)).getText().equals(ruleName)");
}
pushFollow(FOLLOW_element_in_prefix593);
element();
state._fsp--;
if (state.failed) return;
}
break;
default :
if ( cnt15 >= 1 ) break loop15;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(15, input);
throw eee;
}
cnt15++;
}
pushFollow(FOLLOW_recurse_in_prefix600);
recurse();
state._fsp--;
if (state.failed) return;
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:131:12: ( ACTION )?
int alt16=2;
int LA16_0 = input.LA(1);
if ( (LA16_0==ACTION) ) {
alt16=1;
}
switch (alt16) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:131:12: ACTION
{
match(input,ACTION,FOLLOW_ACTION_in_prefix602); if (state.failed) return;
}
break;
}
match(input, Token.UP, null); if (state.failed) return;
if ( state.backtracking==0 ) {setAltAssoc((AltAST)ALT3,currentOuterAltNumber);}
}
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "prefix"
// $ANTLR start "suffix"
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:136:1: suffix : ^( ALT ( elementOptions )? recurse ( element )+ ) ;
public final void suffix() throws RecognitionException {
GrammarAST ALT4=null;
try {
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:137:5: ( ^( ALT ( elementOptions )? recurse ( element )+ ) )
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:137:9: ^( ALT ( elementOptions )? recurse ( element )+ )
{
ALT4=(GrammarAST)match(input,ALT,FOLLOW_ALT_in_suffix637); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:137:16: ( elementOptions )?
int alt17=2;
int LA17_0 = input.LA(1);
if ( (LA17_0==ELEMENT_OPTIONS) ) {
alt17=1;
}
switch (alt17) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:137:16: elementOptions
{
pushFollow(FOLLOW_elementOptions_in_suffix639);
elementOptions();
state._fsp--;
if (state.failed) return;
}
break;
}
pushFollow(FOLLOW_recurse_in_suffix642);
recurse();
state._fsp--;
if (state.failed) return;
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:137:40: ( element )+
int cnt18=0;
loop18:
while (true) {
int alt18=2;
int LA18_0 = input.LA(1);
if ( (LA18_0==ACTION||LA18_0==ASSIGN||LA18_0==DOT||LA18_0==NOT||LA18_0==PLUS_ASSIGN||LA18_0==RANGE||LA18_0==RULE_REF||LA18_0==SEMPRED||LA18_0==STRING_LITERAL||LA18_0==TOKEN_REF||LA18_0==BLOCK||LA18_0==CLOSURE||LA18_0==EPSILON||(LA18_0 >= OPTIONAL && LA18_0 <= POSITIVE_CLOSURE)||LA18_0==SET||LA18_0==WILDCARD) ) {
alt18=1;
}
switch (alt18) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:137:40: element
{
pushFollow(FOLLOW_element_in_suffix644);
element();
state._fsp--;
if (state.failed) return;
}
break;
default :
if ( cnt18 >= 1 ) break loop18;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(18, input);
throw eee;
}
cnt18++;
}
match(input, Token.UP, null); if (state.failed) return;
if ( state.backtracking==0 ) {setAltAssoc((AltAST)ALT4,currentOuterAltNumber);}
}
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "suffix"
// $ANTLR start "nonLeftRecur"
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:141:1: nonLeftRecur : ^( ALT ( element )+ ) ;
public final void nonLeftRecur() throws RecognitionException {
try {
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:142:5: ( ^( ALT ( element )+ ) )
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:142:9: ^( ALT ( element )+ )
{
match(input,ALT,FOLLOW_ALT_in_nonLeftRecur678); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:142:15: ( element )+
int cnt19=0;
loop19:
while (true) {
int alt19=2;
int LA19_0 = input.LA(1);
if ( (LA19_0==ACTION||LA19_0==ASSIGN||LA19_0==DOT||LA19_0==NOT||LA19_0==PLUS_ASSIGN||LA19_0==RANGE||LA19_0==RULE_REF||LA19_0==SEMPRED||LA19_0==STRING_LITERAL||LA19_0==TOKEN_REF||LA19_0==BLOCK||LA19_0==CLOSURE||LA19_0==EPSILON||(LA19_0 >= OPTIONAL && LA19_0 <= POSITIVE_CLOSURE)||LA19_0==SET||LA19_0==WILDCARD) ) {
alt19=1;
}
switch (alt19) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:142:15: element
{
pushFollow(FOLLOW_element_in_nonLeftRecur680);
element();
state._fsp--;
if (state.failed) return;
}
break;
default :
if ( cnt19 >= 1 ) break loop19;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(19, input);
throw eee;
}
cnt19++;
}
match(input, Token.UP, null); if (state.failed) return;
}
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "nonLeftRecur"
// $ANTLR start "recurse"
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:145:1: recurse : ( ^( ASSIGN ID recurseNoLabel ) | recurseNoLabel );
public final void recurse() throws RecognitionException {
try {
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:146:2: ( ^( ASSIGN ID recurseNoLabel ) | recurseNoLabel )
int alt20=2;
int LA20_0 = input.LA(1);
if ( (LA20_0==ASSIGN) ) {
alt20=1;
}
else if ( (LA20_0==RULE_REF) ) {
alt20=2;
}
else {
if (state.backtracking>0) {state.failed=true; return;}
NoViableAltException nvae =
new NoViableAltException("", 20, 0, input);
throw nvae;
}
switch (alt20) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:146:4: ^( ASSIGN ID recurseNoLabel )
{
match(input,ASSIGN,FOLLOW_ASSIGN_in_recurse699); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
match(input,ID,FOLLOW_ID_in_recurse701); if (state.failed) return;
pushFollow(FOLLOW_recurseNoLabel_in_recurse703);
recurseNoLabel();
state._fsp--;
if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
case 2 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:147:4: recurseNoLabel
{
pushFollow(FOLLOW_recurseNoLabel_in_recurse709);
recurseNoLabel();
state._fsp--;
if (state.failed) return;
}
break;
}
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "recurse"
// $ANTLR start "recurseNoLabel"
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:150:1: recurseNoLabel :{...}? RULE_REF ;
public final void recurseNoLabel() throws RecognitionException {
try {
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:150:16: ({...}? RULE_REF )
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:150:18: {...}? RULE_REF
{
if ( !((((CommonTree)input.LT(1)).getText().equals(ruleName))) ) {
if (state.backtracking>0) {state.failed=true; return;}
throw new FailedPredicateException(input, "recurseNoLabel", "((CommonTree)input.LT(1)).getText().equals(ruleName)");
}
match(input,RULE_REF,FOLLOW_RULE_REF_in_recurseNoLabel721); if (state.failed) return;
}
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "recurseNoLabel"
// $ANTLR start "token"
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:152:1: token returns [GrammarAST t=null] : ( ^( ASSIGN ID s= token ) | ^( PLUS_ASSIGN ID s= token ) |b= STRING_LITERAL | ^(b= STRING_LITERAL elementOptions ) | ^(c= TOKEN_REF elementOptions ) |c= TOKEN_REF );
public final GrammarAST token() throws RecognitionException {
GrammarAST t = null;
GrammarAST b=null;
GrammarAST c=null;
GrammarAST s =null;
try {
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:153:2: ( ^( ASSIGN ID s= token ) | ^( PLUS_ASSIGN ID s= token ) |b= STRING_LITERAL | ^(b= STRING_LITERAL elementOptions ) | ^(c= TOKEN_REF elementOptions ) |c= TOKEN_REF )
int alt21=6;
switch ( input.LA(1) ) {
case ASSIGN:
{
alt21=1;
}
break;
case PLUS_ASSIGN:
{
alt21=2;
}
break;
case STRING_LITERAL:
{
int LA21_3 = input.LA(2);
if ( (LA21_3==DOWN) ) {
alt21=4;
}
else if ( (LA21_3==UP) ) {
alt21=3;
}
else {
if (state.backtracking>0) {state.failed=true; return t;}
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 21, 3, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case TOKEN_REF:
{
int LA21_4 = input.LA(2);
if ( (LA21_4==DOWN) ) {
alt21=5;
}
else if ( (LA21_4==UP) ) {
alt21=6;
}
else {
if (state.backtracking>0) {state.failed=true; return t;}
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 21, 4, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
default:
if (state.backtracking>0) {state.failed=true; return t;}
NoViableAltException nvae =
new NoViableAltException("", 21, 0, input);
throw nvae;
}
switch (alt21) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:153:4: ^( ASSIGN ID s= token )
{
match(input,ASSIGN,FOLLOW_ASSIGN_in_token735); if (state.failed) return t;
match(input, Token.DOWN, null); if (state.failed) return t;
match(input,ID,FOLLOW_ID_in_token737); if (state.failed) return t;
pushFollow(FOLLOW_token_in_token741);
s=token();
state._fsp--;
if (state.failed) return t;
if ( state.backtracking==0 ) {t = s;}
match(input, Token.UP, null); if (state.failed) return t;
}
break;
case 2 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:154:4: ^( PLUS_ASSIGN ID s= token )
{
match(input,PLUS_ASSIGN,FOLLOW_PLUS_ASSIGN_in_token750); if (state.failed) return t;
match(input, Token.DOWN, null); if (state.failed) return t;
match(input,ID,FOLLOW_ID_in_token752); if (state.failed) return t;
pushFollow(FOLLOW_token_in_token756);
s=token();
state._fsp--;
if (state.failed) return t;
if ( state.backtracking==0 ) {t = s;}
match(input, Token.UP, null); if (state.failed) return t;
}
break;
case 3 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:155:4: b= STRING_LITERAL
{
b=(GrammarAST)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_token766); if (state.failed) return t;
if ( state.backtracking==0 ) {t = b;}
}
break;
case 4 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:156:7: ^(b= STRING_LITERAL elementOptions )
{
b=(GrammarAST)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_token787); if (state.failed) return t;
match(input, Token.DOWN, null); if (state.failed) return t;
pushFollow(FOLLOW_elementOptions_in_token789);
elementOptions();
state._fsp--;
if (state.failed) return t;
match(input, Token.UP, null); if (state.failed) return t;
if ( state.backtracking==0 ) {t = b;}
}
break;
case 5 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:157:7: ^(c= TOKEN_REF elementOptions )
{
c=(GrammarAST)match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_token804); if (state.failed) return t;
match(input, Token.DOWN, null); if (state.failed) return t;
pushFollow(FOLLOW_elementOptions_in_token806);
elementOptions();
state._fsp--;
if (state.failed) return t;
match(input, Token.UP, null); if (state.failed) return t;
if ( state.backtracking==0 ) {t = c;}
}
break;
case 6 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:158:4: c= TOKEN_REF
{
c=(GrammarAST)match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_token818); if (state.failed) return t;
if ( state.backtracking==0 ) {t = c;}
}
break;
}
}
finally {
// do for sure before leaving
}
return t;
}
// $ANTLR end "token"
// $ANTLR start "elementOptions"
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:161:1: elementOptions : ^( ELEMENT_OPTIONS ( elementOption )* ) ;
public final void elementOptions() throws RecognitionException {
try {
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:162:5: ( ^( ELEMENT_OPTIONS ( elementOption )* ) )
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:162:7: ^( ELEMENT_OPTIONS ( elementOption )* )
{
match(input,ELEMENT_OPTIONS,FOLLOW_ELEMENT_OPTIONS_in_elementOptions848); if (state.failed) return;
if ( input.LA(1)==Token.DOWN ) {
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:162:25: ( elementOption )*
loop22:
while (true) {
int alt22=2;
int LA22_0 = input.LA(1);
if ( (LA22_0==ASSIGN||LA22_0==ID) ) {
alt22=1;
}
switch (alt22) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:162:25: elementOption
{
pushFollow(FOLLOW_elementOption_in_elementOptions850);
elementOption();
state._fsp--;
if (state.failed) return;
}
break;
default :
break loop22;
}
}
match(input, Token.UP, null); if (state.failed) return;
}
}
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "elementOptions"
// $ANTLR start "elementOption"
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:165:1: elementOption : ( ID | ^( ASSIGN ID ID ) | ^( ASSIGN ID STRING_LITERAL ) | ^( ASSIGN ID ACTION ) | ^( ASSIGN ID INT ) );
public final void elementOption() throws RecognitionException {
try {
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:166:5: ( ID | ^( ASSIGN ID ID ) | ^( ASSIGN ID STRING_LITERAL ) | ^( ASSIGN ID ACTION ) | ^( ASSIGN ID INT ) )
int alt23=5;
int LA23_0 = input.LA(1);
if ( (LA23_0==ID) ) {
alt23=1;
}
else if ( (LA23_0==ASSIGN) ) {
int LA23_2 = input.LA(2);
if ( (LA23_2==DOWN) ) {
int LA23_3 = input.LA(3);
if ( (LA23_3==ID) ) {
switch ( input.LA(4) ) {
case ID:
{
alt23=2;
}
break;
case STRING_LITERAL:
{
alt23=3;
}
break;
case ACTION:
{
alt23=4;
}
break;
case INT:
{
alt23=5;
}
break;
default:
if (state.backtracking>0) {state.failed=true; return;}
int nvaeMark = input.mark();
try {
for (int nvaeConsume = 0; nvaeConsume < 4 - 1; nvaeConsume++) {
input.consume();
}
NoViableAltException nvae =
new NoViableAltException("", 23, 4, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
else {
if (state.backtracking>0) {state.failed=true; return;}
int nvaeMark = input.mark();
try {
for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) {
input.consume();
}
NoViableAltException nvae =
new NoViableAltException("", 23, 3, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
else {
if (state.backtracking>0) {state.failed=true; return;}
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 23, 2, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
else {
if (state.backtracking>0) {state.failed=true; return;}
NoViableAltException nvae =
new NoViableAltException("", 23, 0, input);
throw nvae;
}
switch (alt23) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:166:7: ID
{
match(input,ID,FOLLOW_ID_in_elementOption869); if (state.failed) return;
}
break;
case 2 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:167:9: ^( ASSIGN ID ID )
{
match(input,ASSIGN,FOLLOW_ASSIGN_in_elementOption880); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
match(input,ID,FOLLOW_ID_in_elementOption882); if (state.failed) return;
match(input,ID,FOLLOW_ID_in_elementOption884); if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
case 3 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:168:9: ^( ASSIGN ID STRING_LITERAL )
{
match(input,ASSIGN,FOLLOW_ASSIGN_in_elementOption896); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
match(input,ID,FOLLOW_ID_in_elementOption898); if (state.failed) return;
match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_elementOption900); if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
case 4 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:169:9: ^( ASSIGN ID ACTION )
{
match(input,ASSIGN,FOLLOW_ASSIGN_in_elementOption912); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
match(input,ID,FOLLOW_ID_in_elementOption914); if (state.failed) return;
match(input,ACTION,FOLLOW_ACTION_in_elementOption916); if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
case 5 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:170:9: ^( ASSIGN ID INT )
{
match(input,ASSIGN,FOLLOW_ASSIGN_in_elementOption928); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
match(input,ID,FOLLOW_ID_in_elementOption930); if (state.failed) return;
match(input,INT,FOLLOW_INT_in_elementOption932); if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
}
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "elementOption"
// $ANTLR start "element"
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:173:1: element : ( atom | ^( NOT element ) | ^( RANGE atom atom ) | ^( ASSIGN ID element ) | ^( PLUS_ASSIGN ID element ) | ^( SET ( setElement )+ ) | RULE_REF | ebnf | ACTION | SEMPRED | EPSILON );
public final void element() throws RecognitionException {
try {
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:174:2: ( atom | ^( NOT element ) | ^( RANGE atom atom ) | ^( ASSIGN ID element ) | ^( PLUS_ASSIGN ID element ) | ^( SET ( setElement )+ ) | RULE_REF | ebnf | ACTION | SEMPRED | EPSILON )
int alt25=11;
switch ( input.LA(1) ) {
case RULE_REF:
{
int LA25_1 = input.LA(2);
if ( (LA25_1==DOWN) ) {
alt25=1;
}
else if ( ((LA25_1 >= UP && LA25_1 <= ACTION)||LA25_1==ASSIGN||LA25_1==DOT||LA25_1==NOT||LA25_1==PLUS_ASSIGN||LA25_1==RANGE||LA25_1==RULE_REF||LA25_1==SEMPRED||LA25_1==STRING_LITERAL||LA25_1==TOKEN_REF||LA25_1==BLOCK||LA25_1==CLOSURE||LA25_1==EPSILON||(LA25_1 >= OPTIONAL && LA25_1 <= POSITIVE_CLOSURE)||LA25_1==SET||LA25_1==WILDCARD) ) {
alt25=7;
}
else {
if (state.backtracking>0) {state.failed=true; return;}
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 25, 1, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case DOT:
case STRING_LITERAL:
case TOKEN_REF:
case WILDCARD:
{
alt25=1;
}
break;
case NOT:
{
alt25=2;
}
break;
case RANGE:
{
alt25=3;
}
break;
case ASSIGN:
{
alt25=4;
}
break;
case PLUS_ASSIGN:
{
alt25=5;
}
break;
case SET:
{
alt25=6;
}
break;
case BLOCK:
case CLOSURE:
case OPTIONAL:
case POSITIVE_CLOSURE:
{
alt25=8;
}
break;
case ACTION:
{
alt25=9;
}
break;
case SEMPRED:
{
alt25=10;
}
break;
case EPSILON:
{
alt25=11;
}
break;
default:
if (state.backtracking>0) {state.failed=true; return;}
NoViableAltException nvae =
new NoViableAltException("", 25, 0, input);
throw nvae;
}
switch (alt25) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:174:4: atom
{
pushFollow(FOLLOW_atom_in_element947);
atom();
state._fsp--;
if (state.failed) return;
}
break;
case 2 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:175:4: ^( NOT element )
{
match(input,NOT,FOLLOW_NOT_in_element953); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
pushFollow(FOLLOW_element_in_element955);
element();
state._fsp--;
if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
case 3 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:176:4: ^( RANGE atom atom )
{
match(input,RANGE,FOLLOW_RANGE_in_element962); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
pushFollow(FOLLOW_atom_in_element964);
atom();
state._fsp--;
if (state.failed) return;
pushFollow(FOLLOW_atom_in_element966);
atom();
state._fsp--;
if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
case 4 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:177:4: ^( ASSIGN ID element )
{
match(input,ASSIGN,FOLLOW_ASSIGN_in_element973); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
match(input,ID,FOLLOW_ID_in_element975); if (state.failed) return;
pushFollow(FOLLOW_element_in_element977);
element();
state._fsp--;
if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
case 5 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:178:4: ^( PLUS_ASSIGN ID element )
{
match(input,PLUS_ASSIGN,FOLLOW_PLUS_ASSIGN_in_element984); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
match(input,ID,FOLLOW_ID_in_element986); if (state.failed) return;
pushFollow(FOLLOW_element_in_element988);
element();
state._fsp--;
if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
case 6 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:179:7: ^( SET ( setElement )+ )
{
match(input,SET,FOLLOW_SET_in_element998); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:179:13: ( setElement )+
int cnt24=0;
loop24:
while (true) {
int alt24=2;
int LA24_0 = input.LA(1);
if ( (LA24_0==STRING_LITERAL||LA24_0==TOKEN_REF) ) {
alt24=1;
}
switch (alt24) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:179:13: setElement
{
pushFollow(FOLLOW_setElement_in_element1000);
setElement();
state._fsp--;
if (state.failed) return;
}
break;
default :
if ( cnt24 >= 1 ) break loop24;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(24, input);
throw eee;
}
cnt24++;
}
match(input, Token.UP, null); if (state.failed) return;
}
break;
case 7 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:180:9: RULE_REF
{
match(input,RULE_REF,FOLLOW_RULE_REF_in_element1012); if (state.failed) return;
}
break;
case 8 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:181:4: ebnf
{
pushFollow(FOLLOW_ebnf_in_element1017);
ebnf();
state._fsp--;
if (state.failed) return;
}
break;
case 9 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:182:4: ACTION
{
match(input,ACTION,FOLLOW_ACTION_in_element1022); if (state.failed) return;
}
break;
case 10 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:183:4: SEMPRED
{
match(input,SEMPRED,FOLLOW_SEMPRED_in_element1027); if (state.failed) return;
}
break;
case 11 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:184:4: EPSILON
{
match(input,EPSILON,FOLLOW_EPSILON_in_element1032); if (state.failed) return;
}
break;
}
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "element"
// $ANTLR start "setElement"
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:187:1: setElement : ( STRING_LITERAL | TOKEN_REF );
public final void setElement() throws RecognitionException {
try {
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:188:2: ( STRING_LITERAL | TOKEN_REF )
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:
{
if ( input.LA(1)==STRING_LITERAL||input.LA(1)==TOKEN_REF ) {
input.consume();
state.errorRecovery=false;
state.failed=false;
}
else {
if (state.backtracking>0) {state.failed=true; return;}
MismatchedSetException mse = new MismatchedSetException(null,input);
throw mse;
}
}
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "setElement"
// $ANTLR start "ebnf"
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:192:1: ebnf : ( block | ^( OPTIONAL block ) | ^( CLOSURE block ) | ^( POSITIVE_CLOSURE block ) );
public final void ebnf() throws RecognitionException {
try {
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:192:5: ( block | ^( OPTIONAL block ) | ^( CLOSURE block ) | ^( POSITIVE_CLOSURE block ) )
int alt26=4;
switch ( input.LA(1) ) {
case BLOCK:
{
alt26=1;
}
break;
case OPTIONAL:
{
alt26=2;
}
break;
case CLOSURE:
{
alt26=3;
}
break;
case POSITIVE_CLOSURE:
{
alt26=4;
}
break;
default:
if (state.backtracking>0) {state.failed=true; return;}
NoViableAltException nvae =
new NoViableAltException("", 26, 0, input);
throw nvae;
}
switch (alt26) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:192:9: block
{
pushFollow(FOLLOW_block_in_ebnf1059);
block();
state._fsp--;
if (state.failed) return;
}
break;
case 2 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:193:9: ^( OPTIONAL block )
{
match(input,OPTIONAL,FOLLOW_OPTIONAL_in_ebnf1071); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
pushFollow(FOLLOW_block_in_ebnf1073);
block();
state._fsp--;
if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
case 3 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:194:9: ^( CLOSURE block )
{
match(input,CLOSURE,FOLLOW_CLOSURE_in_ebnf1087); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
pushFollow(FOLLOW_block_in_ebnf1089);
block();
state._fsp--;
if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
case 4 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:195:9: ^( POSITIVE_CLOSURE block )
{
match(input,POSITIVE_CLOSURE,FOLLOW_POSITIVE_CLOSURE_in_ebnf1103); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
pushFollow(FOLLOW_block_in_ebnf1105);
block();
state._fsp--;
if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
}
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "ebnf"
// $ANTLR start "block"
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:198:1: block : ^( BLOCK ( ACTION )? ( alternative )+ ) ;
public final void block() throws RecognitionException {
try {
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:199:5: ( ^( BLOCK ( ACTION )? ( alternative )+ ) )
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:199:7: ^( BLOCK ( ACTION )? ( alternative )+ )
{
match(input,BLOCK,FOLLOW_BLOCK_in_block1125); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:199:15: ( ACTION )?
int alt27=2;
int LA27_0 = input.LA(1);
if ( (LA27_0==ACTION) ) {
alt27=1;
}
switch (alt27) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:199:15: ACTION
{
match(input,ACTION,FOLLOW_ACTION_in_block1127); if (state.failed) return;
}
break;
}
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:199:23: ( alternative )+
int cnt28=0;
loop28:
while (true) {
int alt28=2;
int LA28_0 = input.LA(1);
if ( (LA28_0==ALT) ) {
alt28=1;
}
switch (alt28) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:199:23: alternative
{
pushFollow(FOLLOW_alternative_in_block1130);
alternative();
state._fsp--;
if (state.failed) return;
}
break;
default :
if ( cnt28 >= 1 ) break loop28;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(28, input);
throw eee;
}
cnt28++;
}
match(input, Token.UP, null); if (state.failed) return;
}
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "block"
// $ANTLR start "alternative"
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:202:1: alternative : ^( ALT ( elementOptions )? ( element )+ ) ;
public final void alternative() throws RecognitionException {
try {
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:203:2: ( ^( ALT ( elementOptions )? ( element )+ ) )
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:203:4: ^( ALT ( elementOptions )? ( element )+ )
{
match(input,ALT,FOLLOW_ALT_in_alternative1147); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:203:10: ( elementOptions )?
int alt29=2;
int LA29_0 = input.LA(1);
if ( (LA29_0==ELEMENT_OPTIONS) ) {
alt29=1;
}
switch (alt29) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:203:10: elementOptions
{
pushFollow(FOLLOW_elementOptions_in_alternative1149);
elementOptions();
state._fsp--;
if (state.failed) return;
}
break;
}
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:203:26: ( element )+
int cnt30=0;
loop30:
while (true) {
int alt30=2;
int LA30_0 = input.LA(1);
if ( (LA30_0==ACTION||LA30_0==ASSIGN||LA30_0==DOT||LA30_0==NOT||LA30_0==PLUS_ASSIGN||LA30_0==RANGE||LA30_0==RULE_REF||LA30_0==SEMPRED||LA30_0==STRING_LITERAL||LA30_0==TOKEN_REF||LA30_0==BLOCK||LA30_0==CLOSURE||LA30_0==EPSILON||(LA30_0 >= OPTIONAL && LA30_0 <= POSITIVE_CLOSURE)||LA30_0==SET||LA30_0==WILDCARD) ) {
alt30=1;
}
switch (alt30) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:203:26: element
{
pushFollow(FOLLOW_element_in_alternative1152);
element();
state._fsp--;
if (state.failed) return;
}
break;
default :
if ( cnt30 >= 1 ) break loop30;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(30, input);
throw eee;
}
cnt30++;
}
match(input, Token.UP, null); if (state.failed) return;
}
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "alternative"
// $ANTLR start "atom"
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:206:1: atom : ( ^( RULE_REF ( ARG_ACTION )? ( elementOptions )? ) | ^( STRING_LITERAL elementOptions ) | STRING_LITERAL | ^( TOKEN_REF elementOptions ) | TOKEN_REF | ^( WILDCARD elementOptions ) | WILDCARD | ^( DOT ID element ) );
public final void atom() throws RecognitionException {
try {
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:207:2: ( ^( RULE_REF ( ARG_ACTION )? ( elementOptions )? ) | ^( STRING_LITERAL elementOptions ) | STRING_LITERAL | ^( TOKEN_REF elementOptions ) | TOKEN_REF | ^( WILDCARD elementOptions ) | WILDCARD | ^( DOT ID element ) )
int alt33=8;
switch ( input.LA(1) ) {
case RULE_REF:
{
alt33=1;
}
break;
case STRING_LITERAL:
{
int LA33_2 = input.LA(2);
if ( (LA33_2==DOWN) ) {
alt33=2;
}
else if ( ((LA33_2 >= UP && LA33_2 <= ACTION)||LA33_2==ASSIGN||LA33_2==DOT||LA33_2==NOT||LA33_2==PLUS_ASSIGN||LA33_2==RANGE||LA33_2==RULE_REF||LA33_2==SEMPRED||LA33_2==STRING_LITERAL||LA33_2==TOKEN_REF||LA33_2==BLOCK||LA33_2==CLOSURE||LA33_2==EPSILON||(LA33_2 >= OPTIONAL && LA33_2 <= POSITIVE_CLOSURE)||LA33_2==SET||LA33_2==WILDCARD) ) {
alt33=3;
}
else {
if (state.backtracking>0) {state.failed=true; return;}
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 33, 2, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case TOKEN_REF:
{
int LA33_3 = input.LA(2);
if ( (LA33_3==DOWN) ) {
alt33=4;
}
else if ( ((LA33_3 >= UP && LA33_3 <= ACTION)||LA33_3==ASSIGN||LA33_3==DOT||LA33_3==NOT||LA33_3==PLUS_ASSIGN||LA33_3==RANGE||LA33_3==RULE_REF||LA33_3==SEMPRED||LA33_3==STRING_LITERAL||LA33_3==TOKEN_REF||LA33_3==BLOCK||LA33_3==CLOSURE||LA33_3==EPSILON||(LA33_3 >= OPTIONAL && LA33_3 <= POSITIVE_CLOSURE)||LA33_3==SET||LA33_3==WILDCARD) ) {
alt33=5;
}
else {
if (state.backtracking>0) {state.failed=true; return;}
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 33, 3, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case WILDCARD:
{
int LA33_4 = input.LA(2);
if ( (LA33_4==DOWN) ) {
alt33=6;
}
else if ( ((LA33_4 >= UP && LA33_4 <= ACTION)||LA33_4==ASSIGN||LA33_4==DOT||LA33_4==NOT||LA33_4==PLUS_ASSIGN||LA33_4==RANGE||LA33_4==RULE_REF||LA33_4==SEMPRED||LA33_4==STRING_LITERAL||LA33_4==TOKEN_REF||LA33_4==BLOCK||LA33_4==CLOSURE||LA33_4==EPSILON||(LA33_4 >= OPTIONAL && LA33_4 <= POSITIVE_CLOSURE)||LA33_4==SET||LA33_4==WILDCARD) ) {
alt33=7;
}
else {
if (state.backtracking>0) {state.failed=true; return;}
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 33, 4, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case DOT:
{
alt33=8;
}
break;
default:
if (state.backtracking>0) {state.failed=true; return;}
NoViableAltException nvae =
new NoViableAltException("", 33, 0, input);
throw nvae;
}
switch (alt33) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:207:4: ^( RULE_REF ( ARG_ACTION )? ( elementOptions )? )
{
match(input,RULE_REF,FOLLOW_RULE_REF_in_atom1169); if (state.failed) return;
if ( input.LA(1)==Token.DOWN ) {
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:207:15: ( ARG_ACTION )?
int alt31=2;
int LA31_0 = input.LA(1);
if ( (LA31_0==ARG_ACTION) ) {
alt31=1;
}
switch (alt31) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:207:15: ARG_ACTION
{
match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_atom1171); if (state.failed) return;
}
break;
}
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:207:27: ( elementOptions )?
int alt32=2;
int LA32_0 = input.LA(1);
if ( (LA32_0==ELEMENT_OPTIONS) ) {
alt32=1;
}
switch (alt32) {
case 1 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:207:27: elementOptions
{
pushFollow(FOLLOW_elementOptions_in_atom1174);
elementOptions();
state._fsp--;
if (state.failed) return;
}
break;
}
match(input, Token.UP, null); if (state.failed) return;
}
}
break;
case 2 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:208:8: ^( STRING_LITERAL elementOptions )
{
match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_atom1186); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
pushFollow(FOLLOW_elementOptions_in_atom1188);
elementOptions();
state._fsp--;
if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
case 3 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:209:4: STRING_LITERAL
{
match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_atom1194); if (state.failed) return;
}
break;
case 4 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:210:7: ^( TOKEN_REF elementOptions )
{
match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_atom1203); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
pushFollow(FOLLOW_elementOptions_in_atom1205);
elementOptions();
state._fsp--;
if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
case 5 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:211:4: TOKEN_REF
{
match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_atom1211); if (state.failed) return;
}
break;
case 6 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:212:7: ^( WILDCARD elementOptions )
{
match(input,WILDCARD,FOLLOW_WILDCARD_in_atom1220); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
pushFollow(FOLLOW_elementOptions_in_atom1222);
elementOptions();
state._fsp--;
if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
case 7 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:213:4: WILDCARD
{
match(input,WILDCARD,FOLLOW_WILDCARD_in_atom1228); if (state.failed) return;
}
break;
case 8 :
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:214:4: ^( DOT ID element )
{
match(input,DOT,FOLLOW_DOT_in_atom1234); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
match(input,ID,FOLLOW_ID_in_atom1236); if (state.failed) return;
pushFollow(FOLLOW_element_in_atom1238);
element();
state._fsp--;
if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
}
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "atom"
// $ANTLR start synpred1_LeftRecursiveRuleWalker
public final void synpred1_LeftRecursiveRuleWalker_fragment() throws RecognitionException {
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:114:9: ( binary )
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:114:10: binary
{
pushFollow(FOLLOW_binary_in_synpred1_LeftRecursiveRuleWalker351);
binary();
state._fsp--;
if (state.failed) return;
}
}
// $ANTLR end synpred1_LeftRecursiveRuleWalker
// $ANTLR start synpred2_LeftRecursiveRuleWalker
public final void synpred2_LeftRecursiveRuleWalker_fragment() throws RecognitionException {
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:116:9: ( prefix )
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:116:10: prefix
{
pushFollow(FOLLOW_prefix_in_synpred2_LeftRecursiveRuleWalker407);
prefix();
state._fsp--;
if (state.failed) return;
}
}
// $ANTLR end synpred2_LeftRecursiveRuleWalker
// $ANTLR start synpred3_LeftRecursiveRuleWalker
public final void synpred3_LeftRecursiveRuleWalker_fragment() throws RecognitionException {
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:118:9: ( suffix )
// org\\antlr\\v4\\parse\\LeftRecursiveRuleWalker.g:118:10: suffix
{
pushFollow(FOLLOW_suffix_in_synpred3_LeftRecursiveRuleWalker463);
suffix();
state._fsp--;
if (state.failed) return;
}
}
// $ANTLR end synpred3_LeftRecursiveRuleWalker
// Delegated rules
public final boolean synpred2_LeftRecursiveRuleWalker() {
state.backtracking++;
int start = input.mark();
try {
synpred2_LeftRecursiveRuleWalker_fragment(); // can never throw exception
} catch (RecognitionException re) {
System.err.println("impossible: "+re);
}
boolean success = !state.failed;
input.rewind(start);
state.backtracking--;
state.failed=false;
return success;
}
public final boolean synpred1_LeftRecursiveRuleWalker() {
state.backtracking++;
int start = input.mark();
try {
synpred1_LeftRecursiveRuleWalker_fragment(); // can never throw exception
} catch (RecognitionException re) {
System.err.println("impossible: "+re);
}
boolean success = !state.failed;
input.rewind(start);
state.backtracking--;
state.failed=false;
return success;
}
public final boolean synpred3_LeftRecursiveRuleWalker() {
state.backtracking++;
int start = input.mark();
try {
synpred3_LeftRecursiveRuleWalker_fragment(); // can never throw exception
} catch (RecognitionException re) {
System.err.println("impossible: "+re);
}
boolean success = !state.failed;
input.rewind(start);
state.backtracking--;
state.failed=false;
return success;
}
public static final BitSet FOLLOW_RULE_in_rec_rule72 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_RULE_REF_in_rec_rule76 = new BitSet(new long[]{0x0043820100020800L,0x0000000000001000L});
public static final BitSet FOLLOW_DOC_COMMENT_in_rec_rule83 = new BitSet(new long[]{0x0043820100000800L,0x0000000000001000L});
public static final BitSet FOLLOW_ruleModifier_in_rec_rule86 = new BitSet(new long[]{0x0040020100000800L,0x0000000000001000L});
public static final BitSet FOLLOW_RETURNS_in_rec_rule95 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ARG_ACTION_in_rec_rule99 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_LOCALS_in_rec_rule118 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ARG_ACTION_in_rec_rule120 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_OPTIONS_in_rec_rule138 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_AT_in_rec_rule155 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ID_in_rec_rule157 = new BitSet(new long[]{0x0000000000000010L});
public static final BitSet FOLLOW_ACTION_in_rec_rule159 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_ruleBlock_in_rec_rule175 = new BitSet(new long[]{0x0000000000401008L});
public static final BitSet FOLLOW_exceptionGroup_in_rec_rule182 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_exceptionHandler_in_exceptionGroup200 = new BitSet(new long[]{0x0000000000401002L});
public static final BitSet FOLLOW_finallyClause_in_exceptionGroup203 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_CATCH_in_exceptionHandler219 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ARG_ACTION_in_exceptionHandler221 = new BitSet(new long[]{0x0000000000000010L});
public static final BitSet FOLLOW_ACTION_in_exceptionHandler223 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_FINALLY_in_finallyClause236 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ACTION_in_finallyClause238 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_BLOCK_in_ruleBlock293 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_outerAlternative_in_ruleBlock306 = new BitSet(new long[]{0x0000000000000008L,0x0000000000000100L});
public static final BitSet FOLLOW_binary_in_outerAlternative365 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_prefix_in_outerAlternative421 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_suffix_in_outerAlternative477 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_nonLeftRecur_in_outerAlternative518 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_ALT_in_binary544 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_elementOptions_in_binary546 = new BitSet(new long[]{0x0100000000000400L});
public static final BitSet FOLLOW_recurse_in_binary549 = new BitSet(new long[]{0x2508204000080410L,0x0000000501825002L});
public static final BitSet FOLLOW_element_in_binary551 = new BitSet(new long[]{0x2508204000080410L,0x0000000501825002L});
public static final BitSet FOLLOW_recurse_in_binary554 = new BitSet(new long[]{0x0000000000000018L});
public static final BitSet FOLLOW_ACTION_in_binary556 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_ALT_in_prefix582 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_elementOptions_in_prefix584 = new BitSet(new long[]{0x2508204000080410L,0x0000000501825002L});
public static final BitSet FOLLOW_element_in_prefix593 = new BitSet(new long[]{0x2508204000080410L,0x0000000501825002L});
public static final BitSet FOLLOW_recurse_in_prefix600 = new BitSet(new long[]{0x0000000000000018L});
public static final BitSet FOLLOW_ACTION_in_prefix602 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_ALT_in_suffix637 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_elementOptions_in_suffix639 = new BitSet(new long[]{0x0100000000000400L});
public static final BitSet FOLLOW_recurse_in_suffix642 = new BitSet(new long[]{0x2508204000080410L,0x0000000501825002L});
public static final BitSet FOLLOW_element_in_suffix644 = new BitSet(new long[]{0x2508204000080418L,0x0000000501825002L});
public static final BitSet FOLLOW_ALT_in_nonLeftRecur678 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_element_in_nonLeftRecur680 = new BitSet(new long[]{0x2508204000080418L,0x0000000501825002L});
public static final BitSet FOLLOW_ASSIGN_in_recurse699 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ID_in_recurse701 = new BitSet(new long[]{0x0100000000000000L});
public static final BitSet FOLLOW_recurseNoLabel_in_recurse703 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_recurseNoLabel_in_recurse709 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_RULE_REF_in_recurseNoLabel721 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_ASSIGN_in_token735 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ID_in_token737 = new BitSet(new long[]{0x2000200000000400L,0x0000000000000002L});
public static final BitSet FOLLOW_token_in_token741 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_PLUS_ASSIGN_in_token750 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ID_in_token752 = new BitSet(new long[]{0x2000200000000400L,0x0000000000000002L});
public static final BitSet FOLLOW_token_in_token756 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_STRING_LITERAL_in_token766 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_STRING_LITERAL_in_token787 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_elementOptions_in_token789 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_TOKEN_REF_in_token804 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_elementOptions_in_token806 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_TOKEN_REF_in_token818 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_ELEMENT_OPTIONS_in_elementOptions848 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_elementOption_in_elementOptions850 = new BitSet(new long[]{0x0000000008000408L});
public static final BitSet FOLLOW_ID_in_elementOption869 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_ASSIGN_in_elementOption880 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ID_in_elementOption882 = new BitSet(new long[]{0x0000000008000000L});
public static final BitSet FOLLOW_ID_in_elementOption884 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_ASSIGN_in_elementOption896 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ID_in_elementOption898 = new BitSet(new long[]{0x2000000000000000L});
public static final BitSet FOLLOW_STRING_LITERAL_in_elementOption900 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_ASSIGN_in_elementOption912 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ID_in_elementOption914 = new BitSet(new long[]{0x0000000000000010L});
public static final BitSet FOLLOW_ACTION_in_elementOption916 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_ASSIGN_in_elementOption928 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ID_in_elementOption930 = new BitSet(new long[]{0x0000000020000000L});
public static final BitSet FOLLOW_INT_in_elementOption932 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_atom_in_element947 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_NOT_in_element953 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_element_in_element955 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_RANGE_in_element962 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_atom_in_element964 = new BitSet(new long[]{0x2100000000080000L,0x0000000400000002L});
public static final BitSet FOLLOW_atom_in_element966 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_ASSIGN_in_element973 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ID_in_element975 = new BitSet(new long[]{0x2508204000080410L,0x0000000501825002L});
public static final BitSet FOLLOW_element_in_element977 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_PLUS_ASSIGN_in_element984 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ID_in_element986 = new BitSet(new long[]{0x2508204000080410L,0x0000000501825002L});
public static final BitSet FOLLOW_element_in_element988 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_SET_in_element998 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_setElement_in_element1000 = new BitSet(new long[]{0x2000000000000008L,0x0000000000000002L});
public static final BitSet FOLLOW_RULE_REF_in_element1012 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_ebnf_in_element1017 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_ACTION_in_element1022 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_SEMPRED_in_element1027 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_EPSILON_in_element1032 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_block_in_ebnf1059 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_OPTIONAL_in_ebnf1071 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_block_in_ebnf1073 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_CLOSURE_in_ebnf1087 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_block_in_ebnf1089 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_POSITIVE_CLOSURE_in_ebnf1103 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_block_in_ebnf1105 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_BLOCK_in_block1125 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ACTION_in_block1127 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
public static final BitSet FOLLOW_alternative_in_block1130 = new BitSet(new long[]{0x0000000000000008L,0x0000000000000100L});
public static final BitSet FOLLOW_ALT_in_alternative1147 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_elementOptions_in_alternative1149 = new BitSet(new long[]{0x2508204000080410L,0x0000000501825002L});
public static final BitSet FOLLOW_element_in_alternative1152 = new BitSet(new long[]{0x2508204000080418L,0x0000000501825002L});
public static final BitSet FOLLOW_RULE_REF_in_atom1169 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ARG_ACTION_in_atom1171 = new BitSet(new long[]{0x0000000000000008L,0x0000000000010000L});
public static final BitSet FOLLOW_elementOptions_in_atom1174 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_STRING_LITERAL_in_atom1186 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_elementOptions_in_atom1188 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_STRING_LITERAL_in_atom1194 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_TOKEN_REF_in_atom1203 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_elementOptions_in_atom1205 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_TOKEN_REF_in_atom1211 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_WILDCARD_in_atom1220 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_elementOptions_in_atom1222 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_WILDCARD_in_atom1228 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_DOT_in_atom1234 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ID_in_atom1236 = new BitSet(new long[]{0x2508204000080410L,0x0000000501825002L});
public static final BitSet FOLLOW_element_in_atom1238 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_binary_in_synpred1_LeftRecursiveRuleWalker351 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_prefix_in_synpred2_LeftRecursiveRuleWalker407 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_suffix_in_synpred3_LeftRecursiveRuleWalker463 = new BitSet(new long[]{0x0000000000000002L});
}