org.cassandraunit.shaded.org.antlr.grammar.v3.LeftRecursiveRuleWalker Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of cassandra-unit-shaded Show documentation
Show all versions of cassandra-unit-shaded Show documentation
Shaded version of cassandra-unit
// $ANTLR 3.5 org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g 2014-03-25 07:04:53
package org.antlr.grammar.v3;
import org.antlr.analysis.*;
import org.antlr.misc.*;
import org.antlr.tool.*;
import org.antlr.runtime.BitSet;
import org.antlr.runtime.DFA;
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", "ALT", "AMPERSAND", "ARG", "ARGLIST",
"ARG_ACTION", "ASSIGN", "BACKTRACK_SEMPRED", "BANG", "BLOCK", "CATCH",
"CHAR_LITERAL", "CHAR_RANGE", "CLOSE_ELEMENT_OPTION", "CLOSURE", "COLON",
"COMBINED_GRAMMAR", "COMMA", "COMMENT", "DIGIT", "DOC_COMMENT", "DOLLAR",
"DOT", "DOUBLE_ANGLE_STRING_LITERAL", "DOUBLE_QUOTE_STRING_LITERAL", "EOA",
"EOB", "EOR", "EPSILON", "ESC", "ETC", "FINALLY", "FORCED_ACTION", "FRAGMENT",
"GATED_SEMPRED", "GRAMMAR", "ID", "IMPLIES", "IMPORT", "INITACTION", "INT",
"LABEL", "LEXER", "LEXER_GRAMMAR", "LPAREN", "ML_COMMENT", "NESTED_ACTION",
"NESTED_ARG_ACTION", "NOT", "OPEN_ELEMENT_OPTION", "OPTIONAL", "OPTIONS",
"OR", "PARSER", "PARSER_GRAMMAR", "PLUS", "PLUS_ASSIGN", "POSITIVE_CLOSURE",
"PREC_RULE", "PRIVATE", "PROTECTED", "PUBLIC", "QUESTION", "RANGE", "RCURLY",
"RECURSIVE_RULE_REF", "RET", "RETURNS", "REWRITE", "REWRITES", "ROOT",
"RPAREN", "RULE", "RULE_REF", "SCOPE", "SEMI", "SEMPRED", "SL_COMMENT",
"SRC", "STAR", "STRAY_BRACKET", "STRING_LITERAL", "SYNPRED", "SYN_SEMPRED",
"TEMPLATE", "THROWS", "TOKENS", "TOKEN_REF", "TREE", "TREE_BEGIN", "TREE_GRAMMAR",
"WILDCARD", "WS", "WS_LOOP", "WS_OPT", "XDIGIT"
};
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 ALT=8;
public static final int AMPERSAND=9;
public static final int ARG=10;
public static final int ARGLIST=11;
public static final int ARG_ACTION=12;
public static final int ASSIGN=13;
public static final int BACKTRACK_SEMPRED=14;
public static final int BANG=15;
public static final int BLOCK=16;
public static final int CATCH=17;
public static final int CHAR_LITERAL=18;
public static final int CHAR_RANGE=19;
public static final int CLOSE_ELEMENT_OPTION=20;
public static final int CLOSURE=21;
public static final int COLON=22;
public static final int COMBINED_GRAMMAR=23;
public static final int COMMA=24;
public static final int COMMENT=25;
public static final int DIGIT=26;
public static final int DOC_COMMENT=27;
public static final int DOLLAR=28;
public static final int DOT=29;
public static final int DOUBLE_ANGLE_STRING_LITERAL=30;
public static final int DOUBLE_QUOTE_STRING_LITERAL=31;
public static final int EOA=32;
public static final int EOB=33;
public static final int EOR=34;
public static final int EPSILON=35;
public static final int ESC=36;
public static final int ETC=37;
public static final int FINALLY=38;
public static final int FORCED_ACTION=39;
public static final int FRAGMENT=40;
public static final int GATED_SEMPRED=41;
public static final int GRAMMAR=42;
public static final int ID=43;
public static final int IMPLIES=44;
public static final int IMPORT=45;
public static final int INITACTION=46;
public static final int INT=47;
public static final int LABEL=48;
public static final int LEXER=49;
public static final int LEXER_GRAMMAR=50;
public static final int LPAREN=51;
public static final int ML_COMMENT=52;
public static final int NESTED_ACTION=53;
public static final int NESTED_ARG_ACTION=54;
public static final int NOT=55;
public static final int OPEN_ELEMENT_OPTION=56;
public static final int OPTIONAL=57;
public static final int OPTIONS=58;
public static final int OR=59;
public static final int PARSER=60;
public static final int PARSER_GRAMMAR=61;
public static final int PLUS=62;
public static final int PLUS_ASSIGN=63;
public static final int POSITIVE_CLOSURE=64;
public static final int PREC_RULE=65;
public static final int PRIVATE=66;
public static final int PROTECTED=67;
public static final int PUBLIC=68;
public static final int QUESTION=69;
public static final int RANGE=70;
public static final int RCURLY=71;
public static final int RECURSIVE_RULE_REF=72;
public static final int RET=73;
public static final int RETURNS=74;
public static final int REWRITE=75;
public static final int REWRITES=76;
public static final int ROOT=77;
public static final int RPAREN=78;
public static final int RULE=79;
public static final int RULE_REF=80;
public static final int SCOPE=81;
public static final int SEMI=82;
public static final int SEMPRED=83;
public static final int SL_COMMENT=84;
public static final int SRC=85;
public static final int STAR=86;
public static final int STRAY_BRACKET=87;
public static final int STRING_LITERAL=88;
public static final int SYNPRED=89;
public static final int SYN_SEMPRED=90;
public static final int TEMPLATE=91;
public static final int THROWS=92;
public static final int TOKENS=93;
public static final int TOKEN_REF=94;
public static final int TREE=95;
public static final int TREE_BEGIN=96;
public static final int TREE_GRAMMAR=97;
public static final int WILDCARD=98;
public static final int WS=99;
public static final int WS_LOOP=100;
public static final int WS_OPT=101;
public static final int XDIGIT=102;
// 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\\grammar\\v3\\LeftRecursiveRuleWalker.g"; }
protected Grammar grammar;
private String ruleName;
private int outerAlt; // which outer alt of rule?
public int numAlts; // how many alts for this rule total?
@Override
public void reportError(RecognitionException ex)
{
Token token = null;
if (ex instanceof MismatchedTokenException)
{
token = ((MismatchedTokenException)ex).token;
}
else if (ex instanceof NoViableAltException)
{
token = ((NoViableAltException)ex).token;
}
ErrorManager.syntaxError(
ErrorManager.MSG_SYNTAX_ERROR,
grammar,
token,
"assign.types: " + ex.toString(),
ex);
}
public void setTokenPrec(GrammarAST t, int alt) {}
public void binaryAlt(GrammarAST altTree, GrammarAST rewriteTree, int alt) {}
public void ternaryAlt(GrammarAST altTree, GrammarAST rewriteTree, int alt) {}
public void prefixAlt(GrammarAST altTree, GrammarAST rewriteTree, int alt) {}
public void suffixAlt(GrammarAST altTree, GrammarAST rewriteTree, int alt) {}
public void otherAlt(GrammarAST altTree, GrammarAST rewriteTree, int alt) {}
public void setReturnValues(GrammarAST t) {}
// $ANTLR start "optionsSpec"
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:89:1: optionsSpec : ^( OPTIONS ( option )+ ) ;
public final void optionsSpec() throws RecognitionException {
try {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:90:2: ( ^( OPTIONS ( option )+ ) )
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:90:4: ^( OPTIONS ( option )+ )
{
match(input,OPTIONS,FOLLOW_OPTIONS_in_optionsSpec57); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:90:14: ( option )+
int cnt1=0;
loop1:
while (true) {
int alt1=2;
int LA1_0 = input.LA(1);
if ( (LA1_0==ASSIGN) ) {
alt1=1;
}
switch (alt1) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:90:14: option
{
pushFollow(FOLLOW_option_in_optionsSpec59);
option();
state._fsp--;
if (state.failed) return;
}
break;
default :
if ( cnt1 >= 1 ) break loop1;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(1, input);
throw eee;
}
cnt1++;
}
match(input, Token.UP, null); if (state.failed) return;
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "optionsSpec"
// $ANTLR start "option"
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:93:1: option : ^( ASSIGN ID optionValue ) ;
public final void option() throws RecognitionException {
try {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:94:2: ( ^( ASSIGN ID optionValue ) )
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:94:4: ^( ASSIGN ID optionValue )
{
match(input,ASSIGN,FOLLOW_ASSIGN_in_option73); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
match(input,ID,FOLLOW_ID_in_option75); if (state.failed) return;
pushFollow(FOLLOW_optionValue_in_option77);
optionValue();
state._fsp--;
if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "option"
// $ANTLR start "optionValue"
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:97:1: optionValue : ( ID | STRING_LITERAL | CHAR_LITERAL | INT );
public final void optionValue() throws RecognitionException {
try {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:98:2: ( ID | STRING_LITERAL | CHAR_LITERAL | INT )
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:
{
if ( input.LA(1)==CHAR_LITERAL||input.LA(1)==ID||input.LA(1)==INT||input.LA(1)==STRING_LITERAL ) {
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;
}
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "optionValue"
// $ANTLR start "charSetElement"
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:104:1: charSetElement : ( CHAR_LITERAL | ^( OR CHAR_LITERAL CHAR_LITERAL ) | ^( RANGE CHAR_LITERAL CHAR_LITERAL ) );
public final void charSetElement() throws RecognitionException {
try {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:105:2: ( CHAR_LITERAL | ^( OR CHAR_LITERAL CHAR_LITERAL ) | ^( RANGE CHAR_LITERAL CHAR_LITERAL ) )
int alt2=3;
switch ( input.LA(1) ) {
case CHAR_LITERAL:
{
alt2=1;
}
break;
case OR:
{
alt2=2;
}
break;
case RANGE:
{
alt2=3;
}
break;
default:
if (state.backtracking>0) {state.failed=true; return;}
NoViableAltException nvae =
new NoViableAltException("", 2, 0, input);
throw nvae;
}
switch (alt2) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:105:4: CHAR_LITERAL
{
match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_charSetElement115); if (state.failed) return;
}
break;
case 2 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:106:4: ^( OR CHAR_LITERAL CHAR_LITERAL )
{
match(input,OR,FOLLOW_OR_in_charSetElement121); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_charSetElement123); if (state.failed) return;
match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_charSetElement125); if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
case 3 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:107:4: ^( RANGE CHAR_LITERAL CHAR_LITERAL )
{
match(input,RANGE,FOLLOW_RANGE_in_charSetElement132); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_charSetElement134); if (state.failed) return;
match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_charSetElement136); if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "charSetElement"
// $ANTLR start "rec_rule"
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:111:1: public rec_rule[Grammar g] returns [boolean isLeftRec] : ^(r= RULE id= ID ( modifier )? ^( ARG ( ARG_ACTION )? ) ^( RET ( ARG_ACTION )? ) ( optionsSpec )? ( ruleScopeSpec )? ( ^( AMPERSAND ( . )* ) )* ruleBlock ( exceptionGroup )? EOR ) ;
public final boolean rec_rule(Grammar g) throws RecognitionException {
boolean isLeftRec = false;
GrammarAST r=null;
GrammarAST id=null;
TreeRuleReturnScope ruleBlock1 =null;
grammar = g;
outerAlt = 1;
try {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:117:2: ( ^(r= RULE id= ID ( modifier )? ^( ARG ( ARG_ACTION )? ) ^( RET ( ARG_ACTION )? ) ( optionsSpec )? ( ruleScopeSpec )? ( ^( AMPERSAND ( . )* ) )* ruleBlock ( exceptionGroup )? EOR ) )
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:117:4: ^(r= RULE id= ID ( modifier )? ^( ARG ( ARG_ACTION )? ) ^( RET ( ARG_ACTION )? ) ( optionsSpec )? ( ruleScopeSpec )? ( ^( AMPERSAND ( . )* ) )* ruleBlock ( exceptionGroup )? EOR )
{
r=(GrammarAST)match(input,RULE,FOLLOW_RULE_in_rec_rule164); if (state.failed) return isLeftRec;
match(input, Token.DOWN, null); if (state.failed) return isLeftRec;
id=(GrammarAST)match(input,ID,FOLLOW_ID_in_rec_rule168); if (state.failed) return isLeftRec;
if ( state.backtracking==0 ) {ruleName=id.getText();}
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:118:4: ( modifier )?
int alt3=2;
int LA3_0 = input.LA(1);
if ( (LA3_0==FRAGMENT||(LA3_0 >= PRIVATE && LA3_0 <= PUBLIC)) ) {
alt3=1;
}
switch (alt3) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:118:4: modifier
{
pushFollow(FOLLOW_modifier_in_rec_rule175);
modifier();
state._fsp--;
if (state.failed) return isLeftRec;
}
break;
}
match(input,ARG,FOLLOW_ARG_in_rec_rule182); if (state.failed) return isLeftRec;
if ( input.LA(1)==Token.DOWN ) {
match(input, Token.DOWN, null); if (state.failed) return isLeftRec;
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:119:10: ( ARG_ACTION )?
int alt4=2;
int LA4_0 = input.LA(1);
if ( (LA4_0==ARG_ACTION) ) {
alt4=1;
}
switch (alt4) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:119:10: ARG_ACTION
{
match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_rec_rule184); if (state.failed) return isLeftRec;
}
break;
}
match(input, Token.UP, null); if (state.failed) return isLeftRec;
}
match(input,RET,FOLLOW_RET_in_rec_rule192); if (state.failed) return isLeftRec;
if ( input.LA(1)==Token.DOWN ) {
match(input, Token.DOWN, null); if (state.failed) return isLeftRec;
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:120:10: ( ARG_ACTION )?
int alt5=2;
int LA5_0 = input.LA(1);
if ( (LA5_0==ARG_ACTION) ) {
alt5=1;
}
switch (alt5) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:120:10: ARG_ACTION
{
match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_rec_rule194); if (state.failed) return isLeftRec;
}
break;
}
match(input, Token.UP, null); if (state.failed) return isLeftRec;
}
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:121:4: ( optionsSpec )?
int alt6=2;
int LA6_0 = input.LA(1);
if ( (LA6_0==OPTIONS) ) {
alt6=1;
}
switch (alt6) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:121:4: optionsSpec
{
pushFollow(FOLLOW_optionsSpec_in_rec_rule201);
optionsSpec();
state._fsp--;
if (state.failed) return isLeftRec;
}
break;
}
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:122:4: ( ruleScopeSpec )?
int alt7=2;
int LA7_0 = input.LA(1);
if ( (LA7_0==SCOPE) ) {
alt7=1;
}
switch (alt7) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:122:4: ruleScopeSpec
{
pushFollow(FOLLOW_ruleScopeSpec_in_rec_rule207);
ruleScopeSpec();
state._fsp--;
if (state.failed) return isLeftRec;
}
break;
}
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:123:4: ( ^( AMPERSAND ( . )* ) )*
loop9:
while (true) {
int alt9=2;
int LA9_0 = input.LA(1);
if ( (LA9_0==AMPERSAND) ) {
alt9=1;
}
switch (alt9) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:123:5: ^( AMPERSAND ( . )* )
{
match(input,AMPERSAND,FOLLOW_AMPERSAND_in_rec_rule215); if (state.failed) return isLeftRec;
if ( input.LA(1)==Token.DOWN ) {
match(input, Token.DOWN, null); if (state.failed) return isLeftRec;
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:123:17: ( . )*
loop8:
while (true) {
int alt8=2;
int LA8_0 = input.LA(1);
if ( ((LA8_0 >= ACTION && LA8_0 <= XDIGIT)) ) {
alt8=1;
}
else if ( (LA8_0==UP) ) {
alt8=2;
}
switch (alt8) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:123:17: .
{
matchAny(input); if (state.failed) return isLeftRec;
}
break;
default :
break loop8;
}
}
match(input, Token.UP, null); if (state.failed) return isLeftRec;
}
}
break;
default :
break loop9;
}
}
pushFollow(FOLLOW_ruleBlock_in_rec_rule226);
ruleBlock1=ruleBlock();
state._fsp--;
if (state.failed) return isLeftRec;
if ( state.backtracking==0 ) {isLeftRec = (ruleBlock1!=null?((LeftRecursiveRuleWalker.ruleBlock_return)ruleBlock1).isLeftRec:false);}
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:125:4: ( exceptionGroup )?
int alt10=2;
int LA10_0 = input.LA(1);
if ( (LA10_0==CATCH||LA10_0==FINALLY) ) {
alt10=1;
}
switch (alt10) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:125:4: exceptionGroup
{
pushFollow(FOLLOW_exceptionGroup_in_rec_rule233);
exceptionGroup();
state._fsp--;
if (state.failed) return isLeftRec;
}
break;
}
match(input,EOR,FOLLOW_EOR_in_rec_rule239); if (state.failed) return isLeftRec;
match(input, Token.UP, null); if (state.failed) return isLeftRec;
if ( state.backtracking==0 ) {if ((ruleBlock1!=null?((LeftRecursiveRuleWalker.ruleBlock_return)ruleBlock1).isLeftRec:false)) r.setType(PREC_RULE);}
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
return isLeftRec;
}
// $ANTLR end "rec_rule"
// $ANTLR start "modifier"
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:131:1: modifier : ( 'protected' | 'public' | 'private' | 'fragment' );
public final void modifier() throws RecognitionException {
try {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:132:2: ( 'protected' | 'public' | 'private' | 'fragment' )
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:
{
if ( input.LA(1)==FRAGMENT||(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;
}
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "modifier"
// $ANTLR start "ruleScopeSpec"
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:138:1: ruleScopeSpec : ^( 'scope' ( ACTION )? ( ID )* ) ;
public final void ruleScopeSpec() throws RecognitionException {
try {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:139:3: ( ^( 'scope' ( ACTION )? ( ID )* ) )
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:139:5: ^( 'scope' ( ACTION )? ( ID )* )
{
match(input,SCOPE,FOLLOW_SCOPE_in_ruleScopeSpec286); if (state.failed) return;
if ( input.LA(1)==Token.DOWN ) {
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:139:15: ( ACTION )?
int alt11=2;
int LA11_0 = input.LA(1);
if ( (LA11_0==ACTION) ) {
alt11=1;
}
switch (alt11) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:139:15: ACTION
{
match(input,ACTION,FOLLOW_ACTION_in_ruleScopeSpec288); if (state.failed) return;
}
break;
}
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:139:23: ( ID )*
loop12:
while (true) {
int alt12=2;
int LA12_0 = input.LA(1);
if ( (LA12_0==ID) ) {
alt12=1;
}
switch (alt12) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:139:23: ID
{
match(input,ID,FOLLOW_ID_in_ruleScopeSpec291); if (state.failed) return;
}
break;
default :
break loop12;
}
}
match(input, Token.UP, null); if (state.failed) return;
}
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "ruleScopeSpec"
public static class ruleBlock_return extends TreeRuleReturnScope {
public boolean isLeftRec;
};
// $ANTLR start "ruleBlock"
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:142:1: ruleBlock returns [boolean isLeftRec] : ^( BLOCK ( optionsSpec )? ( outerAlternative ( rewrite )? )+ EOB ) ;
public final LeftRecursiveRuleWalker.ruleBlock_return ruleBlock() throws RecognitionException {
LeftRecursiveRuleWalker.ruleBlock_return retval = new LeftRecursiveRuleWalker.ruleBlock_return();
retval.start = input.LT(1);
TreeRuleReturnScope outerAlternative2 =null;
boolean lr=false; this.numAlts = ((GrammarAST)retval.start).getChildCount();
try {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:144:2: ( ^( BLOCK ( optionsSpec )? ( outerAlternative ( rewrite )? )+ EOB ) )
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:144:4: ^( BLOCK ( optionsSpec )? ( outerAlternative ( rewrite )? )+ EOB )
{
match(input,BLOCK,FOLLOW_BLOCK_in_ruleBlock315); if (state.failed) return retval;
match(input, Token.DOWN, null); if (state.failed) return retval;
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:145:4: ( optionsSpec )?
int alt13=2;
int LA13_0 = input.LA(1);
if ( (LA13_0==OPTIONS) ) {
alt13=1;
}
switch (alt13) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:145:4: optionsSpec
{
pushFollow(FOLLOW_optionsSpec_in_ruleBlock320);
optionsSpec();
state._fsp--;
if (state.failed) return retval;
}
break;
}
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:146:4: ( outerAlternative ( rewrite )? )+
int cnt15=0;
loop15:
while (true) {
int alt15=2;
int LA15_0 = input.LA(1);
if ( (LA15_0==ALT) ) {
alt15=1;
}
switch (alt15) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:146:6: outerAlternative ( rewrite )?
{
pushFollow(FOLLOW_outerAlternative_in_ruleBlock328);
outerAlternative2=outerAlternative();
state._fsp--;
if (state.failed) return retval;
if ( state.backtracking==0 ) {if ((outerAlternative2!=null?((LeftRecursiveRuleWalker.outerAlternative_return)outerAlternative2).isLeftRec:false)) retval.isLeftRec = true;}
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:148:5: ( rewrite )?
int alt14=2;
int LA14_0 = input.LA(1);
if ( (LA14_0==REWRITES) ) {
alt14=1;
}
switch (alt14) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:148:5: rewrite
{
pushFollow(FOLLOW_rewrite_in_ruleBlock340);
rewrite();
state._fsp--;
if (state.failed) return retval;
}
break;
}
if ( state.backtracking==0 ) {outerAlt++;}
}
break;
default :
if ( cnt15 >= 1 ) break loop15;
if (state.backtracking>0) {state.failed=true; return retval;}
EarlyExitException eee = new EarlyExitException(15, input);
throw eee;
}
cnt15++;
}
match(input,EOB,FOLLOW_EOB_in_ruleBlock358); if (state.failed) return retval;
match(input, Token.UP, null); if (state.failed) return retval;
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "ruleBlock"
// $ANTLR start "block"
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:155:1: block : ^( BLOCK ( optionsSpec )? ( ^( ALT ( element )+ EOA ) ( rewrite )? )+ EOB ) ;
public final void block() throws RecognitionException {
try {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:156:5: ( ^( BLOCK ( optionsSpec )? ( ^( ALT ( element )+ EOA ) ( rewrite )? )+ EOB ) )
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:156:9: ^( BLOCK ( optionsSpec )? ( ^( ALT ( element )+ EOA ) ( rewrite )? )+ EOB )
{
match(input,BLOCK,FOLLOW_BLOCK_in_block381); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:157:13: ( optionsSpec )?
int alt16=2;
int LA16_0 = input.LA(1);
if ( (LA16_0==OPTIONS) ) {
alt16=1;
}
switch (alt16) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:157:13: optionsSpec
{
pushFollow(FOLLOW_optionsSpec_in_block395);
optionsSpec();
state._fsp--;
if (state.failed) return;
}
break;
}
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:158:13: ( ^( ALT ( element )+ EOA ) ( rewrite )? )+
int cnt19=0;
loop19:
while (true) {
int alt19=2;
int LA19_0 = input.LA(1);
if ( (LA19_0==ALT) ) {
alt19=1;
}
switch (alt19) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:158:15: ^( ALT ( element )+ EOA ) ( rewrite )?
{
match(input,ALT,FOLLOW_ALT_in_block413); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:158:21: ( element )+
int cnt17=0;
loop17:
while (true) {
int alt17=2;
int LA17_0 = input.LA(1);
if ( (LA17_0==ACTION||(LA17_0 >= ASSIGN && LA17_0 <= BLOCK)||LA17_0==CHAR_LITERAL||LA17_0==CLOSURE||LA17_0==DOT||LA17_0==EPSILON||LA17_0==FORCED_ACTION||LA17_0==GATED_SEMPRED||LA17_0==NOT||LA17_0==OPTIONAL||(LA17_0 >= PLUS_ASSIGN && LA17_0 <= POSITIVE_CLOSURE)||LA17_0==RANGE||LA17_0==ROOT||LA17_0==RULE_REF||LA17_0==SEMPRED||(LA17_0 >= STRING_LITERAL && LA17_0 <= SYN_SEMPRED)||LA17_0==TOKEN_REF||LA17_0==TREE_BEGIN||LA17_0==WILDCARD) ) {
alt17=1;
}
switch (alt17) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:158:21: element
{
pushFollow(FOLLOW_element_in_block415);
element();
state._fsp--;
if (state.failed) return;
}
break;
default :
if ( cnt17 >= 1 ) break loop17;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(17, input);
throw eee;
}
cnt17++;
}
match(input,EOA,FOLLOW_EOA_in_block418); if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:158:35: ( rewrite )?
int alt18=2;
int LA18_0 = input.LA(1);
if ( (LA18_0==REWRITES) ) {
alt18=1;
}
switch (alt18) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:158:35: rewrite
{
pushFollow(FOLLOW_rewrite_in_block421);
rewrite();
state._fsp--;
if (state.failed) return;
}
break;
}
}
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,EOB,FOLLOW_EOB_in_block439); if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "block"
public static class outerAlternative_return extends TreeRuleReturnScope {
public boolean isLeftRec;
};
// $ANTLR start "outerAlternative"
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:164:1: outerAlternative returns [boolean isLeftRec] : ( ( binaryMultipleOp )=> binaryMultipleOp | ( binary )=> binary | ( ternary )=> ternary | ( prefix )=> prefix | ( suffix )=> suffix | ^( ALT ( element )+ EOA ) );
public final LeftRecursiveRuleWalker.outerAlternative_return outerAlternative() throws RecognitionException {
LeftRecursiveRuleWalker.outerAlternative_return retval = new LeftRecursiveRuleWalker.outerAlternative_return();
retval.start = input.LT(1);
GrammarAST rew = ((GrammarAST)retval.start).getNextSibling();
if (rew.getType() != REWRITES)
rew = null;
try {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:171:5: ( ( binaryMultipleOp )=> binaryMultipleOp | ( binary )=> binary | ( ternary )=> ternary | ( prefix )=> prefix | ( suffix )=> suffix | ^( ALT ( element )+ EOA ) )
int alt21=6;
int LA21_0 = input.LA(1);
if ( (LA21_0==ALT) ) {
int LA21_1 = input.LA(2);
if ( (synpred1_LeftRecursiveRuleWalker()) ) {
alt21=1;
}
else if ( (synpred2_LeftRecursiveRuleWalker()) ) {
alt21=2;
}
else if ( (synpred3_LeftRecursiveRuleWalker()) ) {
alt21=3;
}
else if ( (synpred4_LeftRecursiveRuleWalker()) ) {
alt21=4;
}
else if ( (synpred5_LeftRecursiveRuleWalker()) ) {
alt21=5;
}
else if ( (true) ) {
alt21=6;
}
}
else {
if (state.backtracking>0) {state.failed=true; return retval;}
NoViableAltException nvae =
new NoViableAltException("", 21, 0, input);
throw nvae;
}
switch (alt21) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:171:9: ( binaryMultipleOp )=> binaryMultipleOp
{
pushFollow(FOLLOW_binaryMultipleOp_in_outerAlternative488);
binaryMultipleOp();
state._fsp--;
if (state.failed) return retval;
if ( state.backtracking==0 ) {binaryAlt(((GrammarAST)retval.start), rew, outerAlt); retval.isLeftRec =true;}
}
break;
case 2 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:173:9: ( binary )=> binary
{
pushFollow(FOLLOW_binary_in_outerAlternative544);
binary();
state._fsp--;
if (state.failed) return retval;
if ( state.backtracking==0 ) {binaryAlt(((GrammarAST)retval.start), rew, outerAlt); retval.isLeftRec =true;}
}
break;
case 3 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:175:9: ( ternary )=> ternary
{
pushFollow(FOLLOW_ternary_in_outerAlternative606);
ternary();
state._fsp--;
if (state.failed) return retval;
if ( state.backtracking==0 ) {ternaryAlt(((GrammarAST)retval.start), rew, outerAlt); retval.isLeftRec =true;}
}
break;
case 4 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:177:9: ( prefix )=> prefix
{
pushFollow(FOLLOW_prefix_in_outerAlternative662);
prefix();
state._fsp--;
if (state.failed) return retval;
if ( state.backtracking==0 ) {prefixAlt(((GrammarAST)retval.start), rew, outerAlt);}
}
break;
case 5 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:179:9: ( suffix )=> suffix
{
pushFollow(FOLLOW_suffix_in_outerAlternative718);
suffix();
state._fsp--;
if (state.failed) return retval;
if ( state.backtracking==0 ) {suffixAlt(((GrammarAST)retval.start), rew, outerAlt); retval.isLeftRec =true;}
}
break;
case 6 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:181:9: ^( ALT ( element )+ EOA )
{
match(input,ALT,FOLLOW_ALT_in_outerAlternative760); if (state.failed) return retval;
match(input, Token.DOWN, null); if (state.failed) return retval;
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:181:15: ( element )+
int cnt20=0;
loop20:
while (true) {
int alt20=2;
int LA20_0 = input.LA(1);
if ( (LA20_0==ACTION||(LA20_0 >= ASSIGN && LA20_0 <= BLOCK)||LA20_0==CHAR_LITERAL||LA20_0==CLOSURE||LA20_0==DOT||LA20_0==EPSILON||LA20_0==FORCED_ACTION||LA20_0==GATED_SEMPRED||LA20_0==NOT||LA20_0==OPTIONAL||(LA20_0 >= PLUS_ASSIGN && LA20_0 <= POSITIVE_CLOSURE)||LA20_0==RANGE||LA20_0==ROOT||LA20_0==RULE_REF||LA20_0==SEMPRED||(LA20_0 >= STRING_LITERAL && LA20_0 <= SYN_SEMPRED)||LA20_0==TOKEN_REF||LA20_0==TREE_BEGIN||LA20_0==WILDCARD) ) {
alt20=1;
}
switch (alt20) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:181:15: element
{
pushFollow(FOLLOW_element_in_outerAlternative762);
element();
state._fsp--;
if (state.failed) return retval;
}
break;
default :
if ( cnt20 >= 1 ) break loop20;
if (state.backtracking>0) {state.failed=true; return retval;}
EarlyExitException eee = new EarlyExitException(20, input);
throw eee;
}
cnt20++;
}
match(input,EOA,FOLLOW_EOA_in_outerAlternative765); if (state.failed) return retval;
match(input, Token.UP, null); if (state.failed) return retval;
if ( state.backtracking==0 ) {otherAlt(((GrammarAST)retval.start), rew, outerAlt);}
}
break;
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "outerAlternative"
// $ANTLR start "binary"
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:185:1: binary : ^( ALT ( ^( BACKTRACK_SEMPRED ( . )* ) )? recurseNoLabel op= token recurse EOA ) ;
public final void binary() throws RecognitionException {
GrammarAST op =null;
try {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:186:2: ( ^( ALT ( ^( BACKTRACK_SEMPRED ( . )* ) )? recurseNoLabel op= token recurse EOA ) )
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:186:4: ^( ALT ( ^( BACKTRACK_SEMPRED ( . )* ) )? recurseNoLabel op= token recurse EOA )
{
match(input,ALT,FOLLOW_ALT_in_binary814); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:186:11: ( ^( BACKTRACK_SEMPRED ( . )* ) )?
int alt23=2;
int LA23_0 = input.LA(1);
if ( (LA23_0==BACKTRACK_SEMPRED) ) {
alt23=1;
}
switch (alt23) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:186:12: ^( BACKTRACK_SEMPRED ( . )* )
{
match(input,BACKTRACK_SEMPRED,FOLLOW_BACKTRACK_SEMPRED_in_binary818); if (state.failed) return;
if ( input.LA(1)==Token.DOWN ) {
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:186:32: ( . )*
loop22:
while (true) {
int alt22=2;
int LA22_0 = input.LA(1);
if ( ((LA22_0 >= ACTION && LA22_0 <= XDIGIT)) ) {
alt22=1;
}
else if ( (LA22_0==UP) ) {
alt22=2;
}
switch (alt22) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:186:32: .
{
matchAny(input); if (state.failed) return;
}
break;
default :
break loop22;
}
}
match(input, Token.UP, null); if (state.failed) return;
}
}
break;
}
pushFollow(FOLLOW_recurseNoLabel_in_binary826);
recurseNoLabel();
state._fsp--;
if (state.failed) return;
pushFollow(FOLLOW_token_in_binary830);
op=token();
state._fsp--;
if (state.failed) return;
pushFollow(FOLLOW_recurse_in_binary832);
recurse();
state._fsp--;
if (state.failed) return;
match(input,EOA,FOLLOW_EOA_in_binary834); if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
if ( state.backtracking==0 ) {setTokenPrec(op, outerAlt);}
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "binary"
// $ANTLR start "binaryMultipleOp"
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:189:1: binaryMultipleOp : ^( ALT ( ^( BACKTRACK_SEMPRED ( . )* ) )? recurseNoLabel ^( BLOCK ( ^( ALT op= token EOA ) )+ EOB ) recurse EOA ) ;
public final void binaryMultipleOp() throws RecognitionException {
GrammarAST op =null;
try {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:190:2: ( ^( ALT ( ^( BACKTRACK_SEMPRED ( . )* ) )? recurseNoLabel ^( BLOCK ( ^( ALT op= token EOA ) )+ EOB ) recurse EOA ) )
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:190:4: ^( ALT ( ^( BACKTRACK_SEMPRED ( . )* ) )? recurseNoLabel ^( BLOCK ( ^( ALT op= token EOA ) )+ EOB ) recurse EOA )
{
match(input,ALT,FOLLOW_ALT_in_binaryMultipleOp851); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:190:11: ( ^( BACKTRACK_SEMPRED ( . )* ) )?
int alt25=2;
int LA25_0 = input.LA(1);
if ( (LA25_0==BACKTRACK_SEMPRED) ) {
alt25=1;
}
switch (alt25) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:190:12: ^( BACKTRACK_SEMPRED ( . )* )
{
match(input,BACKTRACK_SEMPRED,FOLLOW_BACKTRACK_SEMPRED_in_binaryMultipleOp855); if (state.failed) return;
if ( input.LA(1)==Token.DOWN ) {
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:190:32: ( . )*
loop24:
while (true) {
int alt24=2;
int LA24_0 = input.LA(1);
if ( ((LA24_0 >= ACTION && LA24_0 <= XDIGIT)) ) {
alt24=1;
}
else if ( (LA24_0==UP) ) {
alt24=2;
}
switch (alt24) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:190:32: .
{
matchAny(input); if (state.failed) return;
}
break;
default :
break loop24;
}
}
match(input, Token.UP, null); if (state.failed) return;
}
}
break;
}
pushFollow(FOLLOW_recurseNoLabel_in_binaryMultipleOp863);
recurseNoLabel();
state._fsp--;
if (state.failed) return;
match(input,BLOCK,FOLLOW_BLOCK_in_binaryMultipleOp867); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:190:62: ( ^( ALT op= token EOA ) )+
int cnt26=0;
loop26:
while (true) {
int alt26=2;
int LA26_0 = input.LA(1);
if ( (LA26_0==ALT) ) {
alt26=1;
}
switch (alt26) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:190:64: ^( ALT op= token EOA )
{
match(input,ALT,FOLLOW_ALT_in_binaryMultipleOp873); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
pushFollow(FOLLOW_token_in_binaryMultipleOp877);
op=token();
state._fsp--;
if (state.failed) return;
match(input,EOA,FOLLOW_EOA_in_binaryMultipleOp879); if (state.failed) return;
if ( state.backtracking==0 ) {setTokenPrec(op, outerAlt);}
match(input, Token.UP, null); if (state.failed) return;
}
break;
default :
if ( cnt26 >= 1 ) break loop26;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(26, input);
throw eee;
}
cnt26++;
}
match(input,EOB,FOLLOW_EOB_in_binaryMultipleOp888); if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
pushFollow(FOLLOW_recurse_in_binaryMultipleOp892);
recurse();
state._fsp--;
if (state.failed) return;
match(input,EOA,FOLLOW_EOA_in_binaryMultipleOp894); if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "binaryMultipleOp"
// $ANTLR start "ternary"
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:193:1: ternary : ^( ALT ( ^( BACKTRACK_SEMPRED ( . )* ) )? recurseNoLabel op= token recurse token recurse EOA ) ;
public final void ternary() throws RecognitionException {
GrammarAST op =null;
try {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:194:2: ( ^( ALT ( ^( BACKTRACK_SEMPRED ( . )* ) )? recurseNoLabel op= token recurse token recurse EOA ) )
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:194:4: ^( ALT ( ^( BACKTRACK_SEMPRED ( . )* ) )? recurseNoLabel op= token recurse token recurse EOA )
{
match(input,ALT,FOLLOW_ALT_in_ternary909); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:194:11: ( ^( BACKTRACK_SEMPRED ( . )* ) )?
int alt28=2;
int LA28_0 = input.LA(1);
if ( (LA28_0==BACKTRACK_SEMPRED) ) {
alt28=1;
}
switch (alt28) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:194:12: ^( BACKTRACK_SEMPRED ( . )* )
{
match(input,BACKTRACK_SEMPRED,FOLLOW_BACKTRACK_SEMPRED_in_ternary913); if (state.failed) return;
if ( input.LA(1)==Token.DOWN ) {
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:194:32: ( . )*
loop27:
while (true) {
int alt27=2;
int LA27_0 = input.LA(1);
if ( ((LA27_0 >= ACTION && LA27_0 <= XDIGIT)) ) {
alt27=1;
}
else if ( (LA27_0==UP) ) {
alt27=2;
}
switch (alt27) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:194:32: .
{
matchAny(input); if (state.failed) return;
}
break;
default :
break loop27;
}
}
match(input, Token.UP, null); if (state.failed) return;
}
}
break;
}
pushFollow(FOLLOW_recurseNoLabel_in_ternary921);
recurseNoLabel();
state._fsp--;
if (state.failed) return;
pushFollow(FOLLOW_token_in_ternary925);
op=token();
state._fsp--;
if (state.failed) return;
pushFollow(FOLLOW_recurse_in_ternary927);
recurse();
state._fsp--;
if (state.failed) return;
pushFollow(FOLLOW_token_in_ternary929);
token();
state._fsp--;
if (state.failed) return;
pushFollow(FOLLOW_recurse_in_ternary931);
recurse();
state._fsp--;
if (state.failed) return;
match(input,EOA,FOLLOW_EOA_in_ternary933); if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
if ( state.backtracking==0 ) {setTokenPrec(op, outerAlt);}
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "ternary"
// $ANTLR start "prefix"
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:197:1: prefix : ^( ALT ( ^( BACKTRACK_SEMPRED ( . )* ) )? ({...}? element )+ recurse EOA ) ;
public final void prefix() throws RecognitionException {
try {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:197:8: ( ^( ALT ( ^( BACKTRACK_SEMPRED ( . )* ) )? ({...}? element )+ recurse EOA ) )
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:197:10: ^( ALT ( ^( BACKTRACK_SEMPRED ( . )* ) )? ({...}? element )+ recurse EOA )
{
match(input,ALT,FOLLOW_ALT_in_prefix949); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:197:17: ( ^( BACKTRACK_SEMPRED ( . )* ) )?
int alt30=2;
int LA30_0 = input.LA(1);
if ( (LA30_0==BACKTRACK_SEMPRED) ) {
int LA30_1 = input.LA(2);
if ( (LA30_1==DOWN) ) {
alt30=1;
}
}
switch (alt30) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:197:18: ^( BACKTRACK_SEMPRED ( . )* )
{
match(input,BACKTRACK_SEMPRED,FOLLOW_BACKTRACK_SEMPRED_in_prefix953); if (state.failed) return;
if ( input.LA(1)==Token.DOWN ) {
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:197:38: ( . )*
loop29:
while (true) {
int alt29=2;
int LA29_0 = input.LA(1);
if ( ((LA29_0 >= ACTION && LA29_0 <= XDIGIT)) ) {
alt29=1;
}
else if ( (LA29_0==UP) ) {
alt29=2;
}
switch (alt29) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:197:38: .
{
matchAny(input); if (state.failed) return;
}
break;
default :
break loop29;
}
}
match(input, Token.UP, null); if (state.failed) return;
}
}
break;
}
if ( state.backtracking==0 ) {setTokenPrec((GrammarAST)input.LT(1), outerAlt);}
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:197:95: ({...}? element )+
int cnt31=0;
loop31:
while (true) {
int alt31=2;
switch ( input.LA(1) ) {
case ASSIGN:
{
int LA31_1 = input.LA(2);
if ( (LA31_1==DOWN) ) {
int LA31_5 = input.LA(3);
if ( (LA31_5==ID) ) {
int LA31_8 = input.LA(4);
if ( (LA31_8==RULE_REF) ) {
int LA31_10 = input.LA(5);
if ( (LA31_10==DOWN) ) {
alt31=1;
}
}
else if ( (LA31_8==ACTION||(LA31_8 >= ASSIGN && LA31_8 <= BLOCK)||LA31_8==CHAR_LITERAL||LA31_8==CLOSURE||LA31_8==DOT||LA31_8==EPSILON||LA31_8==FORCED_ACTION||LA31_8==GATED_SEMPRED||LA31_8==NOT||LA31_8==OPTIONAL||(LA31_8 >= PLUS_ASSIGN && LA31_8 <= POSITIVE_CLOSURE)||LA31_8==RANGE||LA31_8==ROOT||LA31_8==SEMPRED||(LA31_8 >= STRING_LITERAL && LA31_8 <= SYN_SEMPRED)||LA31_8==TOKEN_REF||LA31_8==TREE_BEGIN||LA31_8==WILDCARD) ) {
alt31=1;
}
}
}
}
break;
case PLUS_ASSIGN:
{
int LA31_2 = input.LA(2);
if ( (LA31_2==DOWN) ) {
int LA31_6 = input.LA(3);
if ( (LA31_6==ID) ) {
int LA31_9 = input.LA(4);
if ( (LA31_9==RULE_REF) ) {
int LA31_11 = input.LA(5);
if ( (LA31_11==DOWN) ) {
alt31=1;
}
}
else if ( (LA31_9==ACTION||(LA31_9 >= ASSIGN && LA31_9 <= BLOCK)||LA31_9==CHAR_LITERAL||LA31_9==CLOSURE||LA31_9==DOT||LA31_9==EPSILON||LA31_9==FORCED_ACTION||LA31_9==GATED_SEMPRED||LA31_9==NOT||LA31_9==OPTIONAL||(LA31_9 >= PLUS_ASSIGN && LA31_9 <= POSITIVE_CLOSURE)||LA31_9==RANGE||LA31_9==ROOT||LA31_9==SEMPRED||(LA31_9 >= STRING_LITERAL && LA31_9 <= SYN_SEMPRED)||LA31_9==TOKEN_REF||LA31_9==TREE_BEGIN||LA31_9==WILDCARD) ) {
alt31=1;
}
}
}
}
break;
case RULE_REF:
{
int LA31_3 = input.LA(2);
if ( (LA31_3==DOWN) ) {
alt31=1;
}
}
break;
case ACTION:
case BACKTRACK_SEMPRED:
case BANG:
case BLOCK:
case CHAR_LITERAL:
case CLOSURE:
case DOT:
case EPSILON:
case FORCED_ACTION:
case GATED_SEMPRED:
case NOT:
case OPTIONAL:
case POSITIVE_CLOSURE:
case RANGE:
case ROOT:
case SEMPRED:
case STRING_LITERAL:
case SYNPRED:
case SYN_SEMPRED:
case TOKEN_REF:
case TREE_BEGIN:
case WILDCARD:
{
alt31=1;
}
break;
}
switch (alt31) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:197:96: {...}? 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_prefix966);
element();
state._fsp--;
if (state.failed) return;
}
break;
default :
if ( cnt31 >= 1 ) break loop31;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(31, input);
throw eee;
}
cnt31++;
}
pushFollow(FOLLOW_recurse_in_prefix970);
recurse();
state._fsp--;
if (state.failed) return;
match(input,EOA,FOLLOW_EOA_in_prefix972); if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "prefix"
// $ANTLR start "suffix"
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:199:1: suffix : ^( ALT ( ^( BACKTRACK_SEMPRED ( . )* ) )? recurseNoLabel ( element )+ EOA ) ;
public final void suffix() throws RecognitionException {
try {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:199:8: ( ^( ALT ( ^( BACKTRACK_SEMPRED ( . )* ) )? recurseNoLabel ( element )+ EOA ) )
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:199:10: ^( ALT ( ^( BACKTRACK_SEMPRED ( . )* ) )? recurseNoLabel ( element )+ EOA )
{
match(input,ALT,FOLLOW_ALT_in_suffix985); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:199:17: ( ^( BACKTRACK_SEMPRED ( . )* ) )?
int alt33=2;
int LA33_0 = input.LA(1);
if ( (LA33_0==BACKTRACK_SEMPRED) ) {
alt33=1;
}
switch (alt33) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:199:18: ^( BACKTRACK_SEMPRED ( . )* )
{
match(input,BACKTRACK_SEMPRED,FOLLOW_BACKTRACK_SEMPRED_in_suffix989); if (state.failed) return;
if ( input.LA(1)==Token.DOWN ) {
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:199:38: ( . )*
loop32:
while (true) {
int alt32=2;
int LA32_0 = input.LA(1);
if ( ((LA32_0 >= ACTION && LA32_0 <= XDIGIT)) ) {
alt32=1;
}
else if ( (LA32_0==UP) ) {
alt32=2;
}
switch (alt32) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:199:38: .
{
matchAny(input); if (state.failed) return;
}
break;
default :
break loop32;
}
}
match(input, Token.UP, null); if (state.failed) return;
}
}
break;
}
pushFollow(FOLLOW_recurseNoLabel_in_suffix997);
recurseNoLabel();
state._fsp--;
if (state.failed) return;
if ( state.backtracking==0 ) {setTokenPrec((GrammarAST)input.LT(1), outerAlt);}
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:199:110: ( element )+
int cnt34=0;
loop34:
while (true) {
int alt34=2;
int LA34_0 = input.LA(1);
if ( (LA34_0==ACTION||(LA34_0 >= ASSIGN && LA34_0 <= BLOCK)||LA34_0==CHAR_LITERAL||LA34_0==CLOSURE||LA34_0==DOT||LA34_0==EPSILON||LA34_0==FORCED_ACTION||LA34_0==GATED_SEMPRED||LA34_0==NOT||LA34_0==OPTIONAL||(LA34_0 >= PLUS_ASSIGN && LA34_0 <= POSITIVE_CLOSURE)||LA34_0==RANGE||LA34_0==ROOT||LA34_0==RULE_REF||LA34_0==SEMPRED||(LA34_0 >= STRING_LITERAL && LA34_0 <= SYN_SEMPRED)||LA34_0==TOKEN_REF||LA34_0==TREE_BEGIN||LA34_0==WILDCARD) ) {
alt34=1;
}
switch (alt34) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:199:110: element
{
pushFollow(FOLLOW_element_in_suffix1001);
element();
state._fsp--;
if (state.failed) return;
}
break;
default :
if ( cnt34 >= 1 ) break loop34;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(34, input);
throw eee;
}
cnt34++;
}
match(input,EOA,FOLLOW_EOA_in_suffix1005); if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "suffix"
// $ANTLR start "recurse"
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:201:1: recurse : ( ^( ASSIGN ID recurseNoLabel ) | ^( PLUS_ASSIGN ID recurseNoLabel ) | recurseNoLabel );
public final void recurse() throws RecognitionException {
try {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:202:2: ( ^( ASSIGN ID recurseNoLabel ) | ^( PLUS_ASSIGN ID recurseNoLabel ) | recurseNoLabel )
int alt35=3;
switch ( input.LA(1) ) {
case ASSIGN:
{
alt35=1;
}
break;
case PLUS_ASSIGN:
{
alt35=2;
}
break;
case RULE_REF:
{
alt35=3;
}
break;
default:
if (state.backtracking>0) {state.failed=true; return;}
NoViableAltException nvae =
new NoViableAltException("", 35, 0, input);
throw nvae;
}
switch (alt35) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:202:4: ^( ASSIGN ID recurseNoLabel )
{
match(input,ASSIGN,FOLLOW_ASSIGN_in_recurse1018); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
match(input,ID,FOLLOW_ID_in_recurse1020); if (state.failed) return;
pushFollow(FOLLOW_recurseNoLabel_in_recurse1022);
recurseNoLabel();
state._fsp--;
if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
case 2 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:203:4: ^( PLUS_ASSIGN ID recurseNoLabel )
{
match(input,PLUS_ASSIGN,FOLLOW_PLUS_ASSIGN_in_recurse1029); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
match(input,ID,FOLLOW_ID_in_recurse1031); if (state.failed) return;
pushFollow(FOLLOW_recurseNoLabel_in_recurse1033);
recurseNoLabel();
state._fsp--;
if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
case 3 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:204:4: recurseNoLabel
{
pushFollow(FOLLOW_recurseNoLabel_in_recurse1039);
recurseNoLabel();
state._fsp--;
if (state.failed) return;
}
break;
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "recurse"
// $ANTLR start "recurseNoLabel"
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:207:1: recurseNoLabel :{...}? RULE_REF ;
public final void recurseNoLabel() throws RecognitionException {
try {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:207:16: ({...}? RULE_REF )
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:207: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_recurseNoLabel1051); if (state.failed) return;
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "recurseNoLabel"
// $ANTLR start "token"
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:216:1: token returns [GrammarAST t=null] : ( ^( ASSIGN ID s= token ) | ^( PLUS_ASSIGN ID s= token ) | ^( ROOT s= token ) | ^( BANG s= token ) |a= CHAR_LITERAL |b= STRING_LITERAL |c= TOKEN_REF );
public final GrammarAST token() throws RecognitionException {
GrammarAST t = null;
GrammarAST a=null;
GrammarAST b=null;
GrammarAST c=null;
GrammarAST s =null;
try {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:217:2: ( ^( ASSIGN ID s= token ) | ^( PLUS_ASSIGN ID s= token ) | ^( ROOT s= token ) | ^( BANG s= token ) |a= CHAR_LITERAL |b= STRING_LITERAL |c= TOKEN_REF )
int alt36=7;
switch ( input.LA(1) ) {
case ASSIGN:
{
alt36=1;
}
break;
case PLUS_ASSIGN:
{
alt36=2;
}
break;
case ROOT:
{
alt36=3;
}
break;
case BANG:
{
alt36=4;
}
break;
case CHAR_LITERAL:
{
alt36=5;
}
break;
case STRING_LITERAL:
{
alt36=6;
}
break;
case TOKEN_REF:
{
alt36=7;
}
break;
default:
if (state.backtracking>0) {state.failed=true; return t;}
NoViableAltException nvae =
new NoViableAltException("", 36, 0, input);
throw nvae;
}
switch (alt36) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:217:4: ^( ASSIGN ID s= token )
{
match(input,ASSIGN,FOLLOW_ASSIGN_in_token1068); if (state.failed) return t;
match(input, Token.DOWN, null); if (state.failed) return t;
match(input,ID,FOLLOW_ID_in_token1070); if (state.failed) return t;
pushFollow(FOLLOW_token_in_token1074);
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\\grammar\\v3\\LeftRecursiveRuleWalker.g:218:4: ^( PLUS_ASSIGN ID s= token )
{
match(input,PLUS_ASSIGN,FOLLOW_PLUS_ASSIGN_in_token1083); if (state.failed) return t;
match(input, Token.DOWN, null); if (state.failed) return t;
match(input,ID,FOLLOW_ID_in_token1085); if (state.failed) return t;
pushFollow(FOLLOW_token_in_token1089);
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\\grammar\\v3\\LeftRecursiveRuleWalker.g:219:4: ^( ROOT s= token )
{
match(input,ROOT,FOLLOW_ROOT_in_token1098); if (state.failed) return t;
match(input, Token.DOWN, null); if (state.failed) return t;
pushFollow(FOLLOW_token_in_token1102);
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 4 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:220:4: ^( BANG s= token )
{
match(input,BANG,FOLLOW_BANG_in_token1111); if (state.failed) return t;
match(input, Token.DOWN, null); if (state.failed) return t;
pushFollow(FOLLOW_token_in_token1115);
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 5 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:221:4: a= CHAR_LITERAL
{
a=(GrammarAST)match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_token1125); if (state.failed) return t;
if ( state.backtracking==0 ) {t = a;}
}
break;
case 6 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:222:4: b= STRING_LITERAL
{
b=(GrammarAST)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_token1139); if (state.failed) return t;
if ( state.backtracking==0 ) {t = b;}
}
break;
case 7 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:223:4: c= TOKEN_REF
{
c=(GrammarAST)match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_token1151); if (state.failed) return t;
if ( state.backtracking==0 ) {t = c;}
}
break;
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
return t;
}
// $ANTLR end "token"
// $ANTLR start "exceptionGroup"
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:226:1: exceptionGroup : ( ( exceptionHandler )+ ( finallyClause )? | finallyClause );
public final void exceptionGroup() throws RecognitionException {
try {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:227:2: ( ( exceptionHandler )+ ( finallyClause )? | finallyClause )
int alt39=2;
int LA39_0 = input.LA(1);
if ( (LA39_0==CATCH) ) {
alt39=1;
}
else if ( (LA39_0==FINALLY) ) {
alt39=2;
}
else {
if (state.backtracking>0) {state.failed=true; return;}
NoViableAltException nvae =
new NoViableAltException("", 39, 0, input);
throw nvae;
}
switch (alt39) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:227:4: ( exceptionHandler )+ ( finallyClause )?
{
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:227:4: ( exceptionHandler )+
int cnt37=0;
loop37:
while (true) {
int alt37=2;
int LA37_0 = input.LA(1);
if ( (LA37_0==CATCH) ) {
alt37=1;
}
switch (alt37) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:227:4: exceptionHandler
{
pushFollow(FOLLOW_exceptionHandler_in_exceptionGroup1172);
exceptionHandler();
state._fsp--;
if (state.failed) return;
}
break;
default :
if ( cnt37 >= 1 ) break loop37;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(37, input);
throw eee;
}
cnt37++;
}
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:227:22: ( finallyClause )?
int alt38=2;
int LA38_0 = input.LA(1);
if ( (LA38_0==FINALLY) ) {
alt38=1;
}
switch (alt38) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:227:22: finallyClause
{
pushFollow(FOLLOW_finallyClause_in_exceptionGroup1175);
finallyClause();
state._fsp--;
if (state.failed) return;
}
break;
}
}
break;
case 2 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:228:4: finallyClause
{
pushFollow(FOLLOW_finallyClause_in_exceptionGroup1181);
finallyClause();
state._fsp--;
if (state.failed) return;
}
break;
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "exceptionGroup"
// $ANTLR start "exceptionHandler"
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:231:1: exceptionHandler : ^( 'catch' ARG_ACTION ACTION ) ;
public final void exceptionHandler() throws RecognitionException {
try {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:232:2: ( ^( 'catch' ARG_ACTION ACTION ) )
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:232:4: ^( 'catch' ARG_ACTION ACTION )
{
match(input,CATCH,FOLLOW_CATCH_in_exceptionHandler1196); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_exceptionHandler1198); if (state.failed) return;
match(input,ACTION,FOLLOW_ACTION_in_exceptionHandler1200); if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "exceptionHandler"
// $ANTLR start "finallyClause"
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:235:1: finallyClause : ^( 'finally' ACTION ) ;
public final void finallyClause() throws RecognitionException {
try {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:236:2: ( ^( 'finally' ACTION ) )
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:236:4: ^( 'finally' ACTION )
{
match(input,FINALLY,FOLLOW_FINALLY_in_finallyClause1213); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
match(input,ACTION,FOLLOW_ACTION_in_finallyClause1215); if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "finallyClause"
// $ANTLR start "rewrite"
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:239:1: rewrite : ^( REWRITES ( ^( REWRITE ( SEMPRED )? ( ^( ALT ( . )* ) | ^( TEMPLATE ( . )* ) | ACTION | ETC ) ) )* ) ;
public final void rewrite() throws RecognitionException {
try {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:240:2: ( ^( REWRITES ( ^( REWRITE ( SEMPRED )? ( ^( ALT ( . )* ) | ^( TEMPLATE ( . )* ) | ACTION | ETC ) ) )* ) )
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:240:4: ^( REWRITES ( ^( REWRITE ( SEMPRED )? ( ^( ALT ( . )* ) | ^( TEMPLATE ( . )* ) | ACTION | ETC ) ) )* )
{
match(input,REWRITES,FOLLOW_REWRITES_in_rewrite1228); if (state.failed) return;
if ( input.LA(1)==Token.DOWN ) {
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:240:15: ( ^( REWRITE ( SEMPRED )? ( ^( ALT ( . )* ) | ^( TEMPLATE ( . )* ) | ACTION | ETC ) ) )*
loop44:
while (true) {
int alt44=2;
int LA44_0 = input.LA(1);
if ( (LA44_0==REWRITE) ) {
alt44=1;
}
switch (alt44) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:240:17: ^( REWRITE ( SEMPRED )? ( ^( ALT ( . )* ) | ^( TEMPLATE ( . )* ) | ACTION | ETC ) )
{
match(input,REWRITE,FOLLOW_REWRITE_in_rewrite1234); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:240:28: ( SEMPRED )?
int alt40=2;
int LA40_0 = input.LA(1);
if ( (LA40_0==SEMPRED) ) {
alt40=1;
}
switch (alt40) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:240:28: SEMPRED
{
match(input,SEMPRED,FOLLOW_SEMPRED_in_rewrite1236); if (state.failed) return;
}
break;
}
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:240:37: ( ^( ALT ( . )* ) | ^( TEMPLATE ( . )* ) | ACTION | ETC )
int alt43=4;
switch ( input.LA(1) ) {
case ALT:
{
alt43=1;
}
break;
case TEMPLATE:
{
alt43=2;
}
break;
case ACTION:
{
alt43=3;
}
break;
case ETC:
{
alt43=4;
}
break;
default:
if (state.backtracking>0) {state.failed=true; return;}
NoViableAltException nvae =
new NoViableAltException("", 43, 0, input);
throw nvae;
}
switch (alt43) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:240:38: ^( ALT ( . )* )
{
match(input,ALT,FOLLOW_ALT_in_rewrite1241); if (state.failed) return;
if ( input.LA(1)==Token.DOWN ) {
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:240:44: ( . )*
loop41:
while (true) {
int alt41=2;
int LA41_0 = input.LA(1);
if ( ((LA41_0 >= ACTION && LA41_0 <= XDIGIT)) ) {
alt41=1;
}
else if ( (LA41_0==UP) ) {
alt41=2;
}
switch (alt41) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:240:44: .
{
matchAny(input); if (state.failed) return;
}
break;
default :
break loop41;
}
}
match(input, Token.UP, null); if (state.failed) return;
}
}
break;
case 2 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:240:48: ^( TEMPLATE ( . )* )
{
match(input,TEMPLATE,FOLLOW_TEMPLATE_in_rewrite1248); if (state.failed) return;
if ( input.LA(1)==Token.DOWN ) {
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:240:59: ( . )*
loop42:
while (true) {
int alt42=2;
int LA42_0 = input.LA(1);
if ( ((LA42_0 >= ACTION && LA42_0 <= XDIGIT)) ) {
alt42=1;
}
else if ( (LA42_0==UP) ) {
alt42=2;
}
switch (alt42) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:240:59: .
{
matchAny(input); if (state.failed) return;
}
break;
default :
break loop42;
}
}
match(input, Token.UP, null); if (state.failed) return;
}
}
break;
case 3 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:240:63: ACTION
{
match(input,ACTION,FOLLOW_ACTION_in_rewrite1254); if (state.failed) return;
}
break;
case 4 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:240:70: ETC
{
match(input,ETC,FOLLOW_ETC_in_rewrite1256); if (state.failed) return;
}
break;
}
match(input, Token.UP, null); if (state.failed) return;
}
break;
default :
break loop44;
}
}
match(input, Token.UP, null); if (state.failed) return;
}
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "rewrite"
// $ANTLR start "element"
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:243:1: element : ( ^( ROOT element ) | ^( BANG element ) | atom | ^( NOT element ) | ^( RANGE atom atom ) | ^( ASSIGN ID element ) | ^( PLUS_ASSIGN ID element ) | ebnf | tree_ | ^( SYNPRED block ) | FORCED_ACTION | ACTION | SEMPRED | SYN_SEMPRED | BACKTRACK_SEMPRED | GATED_SEMPRED | EPSILON );
public final void element() throws RecognitionException {
try {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:244:2: ( ^( ROOT element ) | ^( BANG element ) | atom | ^( NOT element ) | ^( RANGE atom atom ) | ^( ASSIGN ID element ) | ^( PLUS_ASSIGN ID element ) | ebnf | tree_ | ^( SYNPRED block ) | FORCED_ACTION | ACTION | SEMPRED | SYN_SEMPRED | BACKTRACK_SEMPRED | GATED_SEMPRED | EPSILON )
int alt45=17;
switch ( input.LA(1) ) {
case ROOT:
{
alt45=1;
}
break;
case BANG:
{
alt45=2;
}
break;
case CHAR_LITERAL:
case DOT:
case RULE_REF:
case STRING_LITERAL:
case TOKEN_REF:
case WILDCARD:
{
alt45=3;
}
break;
case NOT:
{
alt45=4;
}
break;
case RANGE:
{
alt45=5;
}
break;
case ASSIGN:
{
alt45=6;
}
break;
case PLUS_ASSIGN:
{
alt45=7;
}
break;
case BLOCK:
case CLOSURE:
case OPTIONAL:
case POSITIVE_CLOSURE:
{
alt45=8;
}
break;
case TREE_BEGIN:
{
alt45=9;
}
break;
case SYNPRED:
{
alt45=10;
}
break;
case FORCED_ACTION:
{
alt45=11;
}
break;
case ACTION:
{
alt45=12;
}
break;
case SEMPRED:
{
alt45=13;
}
break;
case SYN_SEMPRED:
{
alt45=14;
}
break;
case BACKTRACK_SEMPRED:
{
alt45=15;
}
break;
case GATED_SEMPRED:
{
alt45=16;
}
break;
case EPSILON:
{
alt45=17;
}
break;
default:
if (state.backtracking>0) {state.failed=true; return;}
NoViableAltException nvae =
new NoViableAltException("", 45, 0, input);
throw nvae;
}
switch (alt45) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:244:4: ^( ROOT element )
{
match(input,ROOT,FOLLOW_ROOT_in_element1276); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
pushFollow(FOLLOW_element_in_element1278);
element();
state._fsp--;
if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
case 2 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:245:4: ^( BANG element )
{
match(input,BANG,FOLLOW_BANG_in_element1285); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
pushFollow(FOLLOW_element_in_element1287);
element();
state._fsp--;
if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
case 3 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:246:4: atom
{
pushFollow(FOLLOW_atom_in_element1293);
atom();
state._fsp--;
if (state.failed) return;
}
break;
case 4 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:247:4: ^( NOT element )
{
match(input,NOT,FOLLOW_NOT_in_element1299); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
pushFollow(FOLLOW_element_in_element1301);
element();
state._fsp--;
if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
case 5 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:248:4: ^( RANGE atom atom )
{
match(input,RANGE,FOLLOW_RANGE_in_element1308); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
pushFollow(FOLLOW_atom_in_element1310);
atom();
state._fsp--;
if (state.failed) return;
pushFollow(FOLLOW_atom_in_element1312);
atom();
state._fsp--;
if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
case 6 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:249:4: ^( ASSIGN ID element )
{
match(input,ASSIGN,FOLLOW_ASSIGN_in_element1319); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
match(input,ID,FOLLOW_ID_in_element1321); if (state.failed) return;
pushFollow(FOLLOW_element_in_element1323);
element();
state._fsp--;
if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
case 7 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:250:4: ^( PLUS_ASSIGN ID element )
{
match(input,PLUS_ASSIGN,FOLLOW_PLUS_ASSIGN_in_element1330); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
match(input,ID,FOLLOW_ID_in_element1332); if (state.failed) return;
pushFollow(FOLLOW_element_in_element1334);
element();
state._fsp--;
if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
case 8 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:251:4: ebnf
{
pushFollow(FOLLOW_ebnf_in_element1340);
ebnf();
state._fsp--;
if (state.failed) return;
}
break;
case 9 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:252:4: tree_
{
pushFollow(FOLLOW_tree__in_element1345);
tree_();
state._fsp--;
if (state.failed) return;
}
break;
case 10 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:253:4: ^( SYNPRED block )
{
match(input,SYNPRED,FOLLOW_SYNPRED_in_element1351); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
pushFollow(FOLLOW_block_in_element1353);
block();
state._fsp--;
if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
case 11 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:254:4: FORCED_ACTION
{
match(input,FORCED_ACTION,FOLLOW_FORCED_ACTION_in_element1360); if (state.failed) return;
}
break;
case 12 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:255:4: ACTION
{
match(input,ACTION,FOLLOW_ACTION_in_element1365); if (state.failed) return;
}
break;
case 13 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:256:4: SEMPRED
{
match(input,SEMPRED,FOLLOW_SEMPRED_in_element1370); if (state.failed) return;
}
break;
case 14 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:257:4: SYN_SEMPRED
{
match(input,SYN_SEMPRED,FOLLOW_SYN_SEMPRED_in_element1375); if (state.failed) return;
}
break;
case 15 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:258:4: BACKTRACK_SEMPRED
{
match(input,BACKTRACK_SEMPRED,FOLLOW_BACKTRACK_SEMPRED_in_element1380); if (state.failed) return;
}
break;
case 16 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:259:4: GATED_SEMPRED
{
match(input,GATED_SEMPRED,FOLLOW_GATED_SEMPRED_in_element1385); if (state.failed) return;
}
break;
case 17 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:260:4: EPSILON
{
match(input,EPSILON,FOLLOW_EPSILON_in_element1390); if (state.failed) return;
}
break;
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "element"
// $ANTLR start "ebnf"
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:263:1: ebnf : ( block | ^( OPTIONAL block ) | ^( CLOSURE block ) | ^( POSITIVE_CLOSURE block ) );
public final void ebnf() throws RecognitionException {
try {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:263:5: ( block | ^( OPTIONAL block ) | ^( CLOSURE block ) | ^( POSITIVE_CLOSURE block ) )
int alt46=4;
switch ( input.LA(1) ) {
case BLOCK:
{
alt46=1;
}
break;
case OPTIONAL:
{
alt46=2;
}
break;
case CLOSURE:
{
alt46=3;
}
break;
case POSITIVE_CLOSURE:
{
alt46=4;
}
break;
default:
if (state.backtracking>0) {state.failed=true; return;}
NoViableAltException nvae =
new NoViableAltException("", 46, 0, input);
throw nvae;
}
switch (alt46) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:263:9: block
{
pushFollow(FOLLOW_block_in_ebnf1402);
block();
state._fsp--;
if (state.failed) return;
}
break;
case 2 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:264:9: ^( OPTIONAL block )
{
match(input,OPTIONAL,FOLLOW_OPTIONAL_in_ebnf1414); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
pushFollow(FOLLOW_block_in_ebnf1416);
block();
state._fsp--;
if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
case 3 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:265:9: ^( CLOSURE block )
{
match(input,CLOSURE,FOLLOW_CLOSURE_in_ebnf1431); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
pushFollow(FOLLOW_block_in_ebnf1433);
block();
state._fsp--;
if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
case 4 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:266:9: ^( POSITIVE_CLOSURE block )
{
match(input,POSITIVE_CLOSURE,FOLLOW_POSITIVE_CLOSURE_in_ebnf1449); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
pushFollow(FOLLOW_block_in_ebnf1451);
block();
state._fsp--;
if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "ebnf"
// $ANTLR start "tree_"
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:269:1: tree_ : ^( TREE_BEGIN ( element )+ ) ;
public final void tree_() throws RecognitionException {
try {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:270:2: ( ^( TREE_BEGIN ( element )+ ) )
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:270:4: ^( TREE_BEGIN ( element )+ )
{
match(input,TREE_BEGIN,FOLLOW_TREE_BEGIN_in_tree_1469); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:270:17: ( element )+
int cnt47=0;
loop47:
while (true) {
int alt47=2;
int LA47_0 = input.LA(1);
if ( (LA47_0==ACTION||(LA47_0 >= ASSIGN && LA47_0 <= BLOCK)||LA47_0==CHAR_LITERAL||LA47_0==CLOSURE||LA47_0==DOT||LA47_0==EPSILON||LA47_0==FORCED_ACTION||LA47_0==GATED_SEMPRED||LA47_0==NOT||LA47_0==OPTIONAL||(LA47_0 >= PLUS_ASSIGN && LA47_0 <= POSITIVE_CLOSURE)||LA47_0==RANGE||LA47_0==ROOT||LA47_0==RULE_REF||LA47_0==SEMPRED||(LA47_0 >= STRING_LITERAL && LA47_0 <= SYN_SEMPRED)||LA47_0==TOKEN_REF||LA47_0==TREE_BEGIN||LA47_0==WILDCARD) ) {
alt47=1;
}
switch (alt47) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:270:17: element
{
pushFollow(FOLLOW_element_in_tree_1471);
element();
state._fsp--;
if (state.failed) return;
}
break;
default :
if ( cnt47 >= 1 ) break loop47;
if (state.backtracking>0) {state.failed=true; return;}
EarlyExitException eee = new EarlyExitException(47, input);
throw eee;
}
cnt47++;
}
match(input, Token.UP, null); if (state.failed) return;
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "tree_"
// $ANTLR start "atom"
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:273:1: atom : ( ^( RULE_REF ( ARG_ACTION )? ) | ^( TOKEN_REF ( ARG_ACTION )? ) | CHAR_LITERAL | STRING_LITERAL | WILDCARD | ^( DOT ID atom ) );
public final void atom() throws RecognitionException {
try {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:274:2: ( ^( RULE_REF ( ARG_ACTION )? ) | ^( TOKEN_REF ( ARG_ACTION )? ) | CHAR_LITERAL | STRING_LITERAL | WILDCARD | ^( DOT ID atom ) )
int alt50=6;
switch ( input.LA(1) ) {
case RULE_REF:
{
alt50=1;
}
break;
case TOKEN_REF:
{
alt50=2;
}
break;
case CHAR_LITERAL:
{
alt50=3;
}
break;
case STRING_LITERAL:
{
alt50=4;
}
break;
case WILDCARD:
{
alt50=5;
}
break;
case DOT:
{
alt50=6;
}
break;
default:
if (state.backtracking>0) {state.failed=true; return;}
NoViableAltException nvae =
new NoViableAltException("", 50, 0, input);
throw nvae;
}
switch (alt50) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:274:4: ^( RULE_REF ( ARG_ACTION )? )
{
match(input,RULE_REF,FOLLOW_RULE_REF_in_atom1485); if (state.failed) return;
if ( input.LA(1)==Token.DOWN ) {
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:274:15: ( ARG_ACTION )?
int alt48=2;
int LA48_0 = input.LA(1);
if ( (LA48_0==ARG_ACTION) ) {
alt48=1;
}
switch (alt48) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:274:15: ARG_ACTION
{
match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_atom1487); if (state.failed) return;
}
break;
}
match(input, Token.UP, null); if (state.failed) return;
}
}
break;
case 2 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:275:4: ^( TOKEN_REF ( ARG_ACTION )? )
{
match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_atom1495); if (state.failed) return;
if ( input.LA(1)==Token.DOWN ) {
match(input, Token.DOWN, null); if (state.failed) return;
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:275:16: ( ARG_ACTION )?
int alt49=2;
int LA49_0 = input.LA(1);
if ( (LA49_0==ARG_ACTION) ) {
alt49=1;
}
switch (alt49) {
case 1 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:275:16: ARG_ACTION
{
match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_atom1497); if (state.failed) return;
}
break;
}
match(input, Token.UP, null); if (state.failed) return;
}
}
break;
case 3 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:276:4: CHAR_LITERAL
{
match(input,CHAR_LITERAL,FOLLOW_CHAR_LITERAL_in_atom1504); if (state.failed) return;
}
break;
case 4 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:277:4: STRING_LITERAL
{
match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_atom1509); if (state.failed) return;
}
break;
case 5 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:278:4: WILDCARD
{
match(input,WILDCARD,FOLLOW_WILDCARD_in_atom1514); if (state.failed) return;
}
break;
case 6 :
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:279:4: ^( DOT ID atom )
{
match(input,DOT,FOLLOW_DOT_in_atom1520); if (state.failed) return;
match(input, Token.DOWN, null); if (state.failed) return;
match(input,ID,FOLLOW_ID_in_atom1522); if (state.failed) return;
pushFollow(FOLLOW_atom_in_atom1524);
atom();
state._fsp--;
if (state.failed) return;
match(input, Token.UP, null); if (state.failed) return;
}
break;
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "atom"
// $ANTLR start "ast_suffix"
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:282:1: ast_suffix : ( ROOT | BANG );
public final void ast_suffix() throws RecognitionException {
try {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:283:2: ( ROOT | BANG )
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:
{
if ( input.LA(1)==BANG||input.LA(1)==ROOT ) {
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;
}
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
}
// $ANTLR end "ast_suffix"
// $ANTLR start synpred1_LeftRecursiveRuleWalker
public final void synpred1_LeftRecursiveRuleWalker_fragment() throws RecognitionException {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:171:9: ( binaryMultipleOp )
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:171:10: binaryMultipleOp
{
pushFollow(FOLLOW_binaryMultipleOp_in_synpred1_LeftRecursiveRuleWalker484);
binaryMultipleOp();
state._fsp--;
if (state.failed) return;
}
}
// $ANTLR end synpred1_LeftRecursiveRuleWalker
// $ANTLR start synpred2_LeftRecursiveRuleWalker
public final void synpred2_LeftRecursiveRuleWalker_fragment() throws RecognitionException {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:173:9: ( binary )
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:173:10: binary
{
pushFollow(FOLLOW_binary_in_synpred2_LeftRecursiveRuleWalker530);
binary();
state._fsp--;
if (state.failed) return;
}
}
// $ANTLR end synpred2_LeftRecursiveRuleWalker
// $ANTLR start synpred3_LeftRecursiveRuleWalker
public final void synpred3_LeftRecursiveRuleWalker_fragment() throws RecognitionException {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:175:9: ( ternary )
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:175:10: ternary
{
pushFollow(FOLLOW_ternary_in_synpred3_LeftRecursiveRuleWalker593);
ternary();
state._fsp--;
if (state.failed) return;
}
}
// $ANTLR end synpred3_LeftRecursiveRuleWalker
// $ANTLR start synpred4_LeftRecursiveRuleWalker
public final void synpred4_LeftRecursiveRuleWalker_fragment() throws RecognitionException {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:177:9: ( prefix )
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:177:10: prefix
{
pushFollow(FOLLOW_prefix_in_synpred4_LeftRecursiveRuleWalker648);
prefix();
state._fsp--;
if (state.failed) return;
}
}
// $ANTLR end synpred4_LeftRecursiveRuleWalker
// $ANTLR start synpred5_LeftRecursiveRuleWalker
public final void synpred5_LeftRecursiveRuleWalker_fragment() throws RecognitionException {
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:179:9: ( suffix )
// org\\antlr\\grammar\\v3\\LeftRecursiveRuleWalker.g:179:10: suffix
{
pushFollow(FOLLOW_suffix_in_synpred5_LeftRecursiveRuleWalker704);
suffix();
state._fsp--;
if (state.failed) return;
}
}
// $ANTLR end synpred5_LeftRecursiveRuleWalker
// Delegated rules
public final boolean synpred5_LeftRecursiveRuleWalker() {
state.backtracking++;
int start = input.mark();
try {
synpred5_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 synpred4_LeftRecursiveRuleWalker() {
state.backtracking++;
int start = input.mark();
try {
synpred4_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 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_OPTIONS_in_optionsSpec57 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_option_in_optionsSpec59 = new BitSet(new long[]{0x0000000000002008L});
public static final BitSet FOLLOW_ASSIGN_in_option73 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ID_in_option75 = new BitSet(new long[]{0x0000880000040000L,0x0000000001000000L});
public static final BitSet FOLLOW_optionValue_in_option77 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_CHAR_LITERAL_in_charSetElement115 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_OR_in_charSetElement121 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_CHAR_LITERAL_in_charSetElement123 = new BitSet(new long[]{0x0000000000040000L});
public static final BitSet FOLLOW_CHAR_LITERAL_in_charSetElement125 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_RANGE_in_charSetElement132 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_CHAR_LITERAL_in_charSetElement134 = new BitSet(new long[]{0x0000000000040000L});
public static final BitSet FOLLOW_CHAR_LITERAL_in_charSetElement136 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_RULE_in_rec_rule164 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ID_in_rec_rule168 = new BitSet(new long[]{0x0000010000000400L,0x000000000000001CL});
public static final BitSet FOLLOW_modifier_in_rec_rule175 = new BitSet(new long[]{0x0000000000000400L});
public static final BitSet FOLLOW_ARG_in_rec_rule182 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ARG_ACTION_in_rec_rule184 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_RET_in_rec_rule192 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ARG_ACTION_in_rec_rule194 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_optionsSpec_in_rec_rule201 = new BitSet(new long[]{0x0000000000010200L,0x0000000000020000L});
public static final BitSet FOLLOW_ruleScopeSpec_in_rec_rule207 = new BitSet(new long[]{0x0000000000010200L});
public static final BitSet FOLLOW_AMPERSAND_in_rec_rule215 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ruleBlock_in_rec_rule226 = new BitSet(new long[]{0x0000004400020000L});
public static final BitSet FOLLOW_exceptionGroup_in_rec_rule233 = new BitSet(new long[]{0x0000000400000000L});
public static final BitSet FOLLOW_EOR_in_rec_rule239 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_SCOPE_in_ruleScopeSpec286 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ACTION_in_ruleScopeSpec288 = new BitSet(new long[]{0x0000080000000008L});
public static final BitSet FOLLOW_ID_in_ruleScopeSpec291 = new BitSet(new long[]{0x0000080000000008L});
public static final BitSet FOLLOW_BLOCK_in_ruleBlock315 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_optionsSpec_in_ruleBlock320 = new BitSet(new long[]{0x0000000000000100L});
public static final BitSet FOLLOW_outerAlternative_in_ruleBlock328 = new BitSet(new long[]{0x0000000200000100L,0x0000000000001000L});
public static final BitSet FOLLOW_rewrite_in_ruleBlock340 = new BitSet(new long[]{0x0000000200000100L});
public static final BitSet FOLLOW_EOB_in_ruleBlock358 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_BLOCK_in_block381 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_optionsSpec_in_block395 = new BitSet(new long[]{0x0000000000000100L});
public static final BitSet FOLLOW_ALT_in_block413 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_element_in_block415 = new BitSet(new long[]{0x828002892025E010L,0x0000000547092041L});
public static final BitSet FOLLOW_EOA_in_block418 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_rewrite_in_block421 = new BitSet(new long[]{0x0000000200000100L});
public static final BitSet FOLLOW_EOB_in_block439 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_binaryMultipleOp_in_outerAlternative488 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_binary_in_outerAlternative544 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_ternary_in_outerAlternative606 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_prefix_in_outerAlternative662 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_suffix_in_outerAlternative718 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_ALT_in_outerAlternative760 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_element_in_outerAlternative762 = new BitSet(new long[]{0x828002892025E010L,0x0000000547092041L});
public static final BitSet FOLLOW_EOA_in_outerAlternative765 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_ALT_in_binary814 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_BACKTRACK_SEMPRED_in_binary818 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_recurseNoLabel_in_binary826 = new BitSet(new long[]{0x800000000004A000L,0x0000000041002000L});
public static final BitSet FOLLOW_token_in_binary830 = new BitSet(new long[]{0x8000000000002000L,0x0000000000010000L});
public static final BitSet FOLLOW_recurse_in_binary832 = new BitSet(new long[]{0x0000000100000000L});
public static final BitSet FOLLOW_EOA_in_binary834 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_ALT_in_binaryMultipleOp851 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_BACKTRACK_SEMPRED_in_binaryMultipleOp855 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_recurseNoLabel_in_binaryMultipleOp863 = new BitSet(new long[]{0x0000000000010000L});
public static final BitSet FOLLOW_BLOCK_in_binaryMultipleOp867 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ALT_in_binaryMultipleOp873 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_token_in_binaryMultipleOp877 = new BitSet(new long[]{0x0000000100000000L});
public static final BitSet FOLLOW_EOA_in_binaryMultipleOp879 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_EOB_in_binaryMultipleOp888 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_recurse_in_binaryMultipleOp892 = new BitSet(new long[]{0x0000000100000000L});
public static final BitSet FOLLOW_EOA_in_binaryMultipleOp894 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_ALT_in_ternary909 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_BACKTRACK_SEMPRED_in_ternary913 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_recurseNoLabel_in_ternary921 = new BitSet(new long[]{0x800000000004A000L,0x0000000041002000L});
public static final BitSet FOLLOW_token_in_ternary925 = new BitSet(new long[]{0x8000000000002000L,0x0000000000010000L});
public static final BitSet FOLLOW_recurse_in_ternary927 = new BitSet(new long[]{0x800000000004A000L,0x0000000041002000L});
public static final BitSet FOLLOW_token_in_ternary929 = new BitSet(new long[]{0x8000000000002000L,0x0000000000010000L});
public static final BitSet FOLLOW_recurse_in_ternary931 = new BitSet(new long[]{0x0000000100000000L});
public static final BitSet FOLLOW_EOA_in_ternary933 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_ALT_in_prefix949 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_BACKTRACK_SEMPRED_in_prefix953 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_element_in_prefix966 = new BitSet(new long[]{0x828002882025E010L,0x0000000547092041L});
public static final BitSet FOLLOW_recurse_in_prefix970 = new BitSet(new long[]{0x0000000100000000L});
public static final BitSet FOLLOW_EOA_in_prefix972 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_ALT_in_suffix985 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_BACKTRACK_SEMPRED_in_suffix989 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_recurseNoLabel_in_suffix997 = new BitSet(new long[]{0x828002882025E010L,0x0000000547092041L});
public static final BitSet FOLLOW_element_in_suffix1001 = new BitSet(new long[]{0x828002892025E010L,0x0000000547092041L});
public static final BitSet FOLLOW_EOA_in_suffix1005 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_ASSIGN_in_recurse1018 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ID_in_recurse1020 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L});
public static final BitSet FOLLOW_recurseNoLabel_in_recurse1022 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_PLUS_ASSIGN_in_recurse1029 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ID_in_recurse1031 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L});
public static final BitSet FOLLOW_recurseNoLabel_in_recurse1033 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_recurseNoLabel_in_recurse1039 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_RULE_REF_in_recurseNoLabel1051 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_ASSIGN_in_token1068 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ID_in_token1070 = new BitSet(new long[]{0x800000000004A000L,0x0000000041002000L});
public static final BitSet FOLLOW_token_in_token1074 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_PLUS_ASSIGN_in_token1083 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ID_in_token1085 = new BitSet(new long[]{0x800000000004A000L,0x0000000041002000L});
public static final BitSet FOLLOW_token_in_token1089 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_ROOT_in_token1098 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_token_in_token1102 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_BANG_in_token1111 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_token_in_token1115 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_CHAR_LITERAL_in_token1125 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_STRING_LITERAL_in_token1139 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_TOKEN_REF_in_token1151 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_exceptionHandler_in_exceptionGroup1172 = new BitSet(new long[]{0x0000004000020002L});
public static final BitSet FOLLOW_finallyClause_in_exceptionGroup1175 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_finallyClause_in_exceptionGroup1181 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_CATCH_in_exceptionHandler1196 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ARG_ACTION_in_exceptionHandler1198 = new BitSet(new long[]{0x0000000000000010L});
public static final BitSet FOLLOW_ACTION_in_exceptionHandler1200 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_FINALLY_in_finallyClause1213 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ACTION_in_finallyClause1215 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_REWRITES_in_rewrite1228 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_REWRITE_in_rewrite1234 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_SEMPRED_in_rewrite1236 = new BitSet(new long[]{0x0000002000000110L,0x0000000008000000L});
public static final BitSet FOLLOW_ALT_in_rewrite1241 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_TEMPLATE_in_rewrite1248 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ACTION_in_rewrite1254 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_ETC_in_rewrite1256 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_ROOT_in_element1276 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_element_in_element1278 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_BANG_in_element1285 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_element_in_element1287 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_atom_in_element1293 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_NOT_in_element1299 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_element_in_element1301 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_RANGE_in_element1308 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_atom_in_element1310 = new BitSet(new long[]{0x0000000020040000L,0x0000000441010000L});
public static final BitSet FOLLOW_atom_in_element1312 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_ASSIGN_in_element1319 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ID_in_element1321 = new BitSet(new long[]{0x828002882025E010L,0x0000000547092041L});
public static final BitSet FOLLOW_element_in_element1323 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_PLUS_ASSIGN_in_element1330 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ID_in_element1332 = new BitSet(new long[]{0x828002882025E010L,0x0000000547092041L});
public static final BitSet FOLLOW_element_in_element1334 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_ebnf_in_element1340 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_tree__in_element1345 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_SYNPRED_in_element1351 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_block_in_element1353 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_FORCED_ACTION_in_element1360 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_ACTION_in_element1365 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_SEMPRED_in_element1370 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_SYN_SEMPRED_in_element1375 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_BACKTRACK_SEMPRED_in_element1380 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_GATED_SEMPRED_in_element1385 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_EPSILON_in_element1390 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_block_in_ebnf1402 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_OPTIONAL_in_ebnf1414 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_block_in_ebnf1416 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_CLOSURE_in_ebnf1431 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_block_in_ebnf1433 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_POSITIVE_CLOSURE_in_ebnf1449 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_block_in_ebnf1451 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_TREE_BEGIN_in_tree_1469 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_element_in_tree_1471 = new BitSet(new long[]{0x828002882025E018L,0x0000000547092041L});
public static final BitSet FOLLOW_RULE_REF_in_atom1485 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ARG_ACTION_in_atom1487 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_TOKEN_REF_in_atom1495 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ARG_ACTION_in_atom1497 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_CHAR_LITERAL_in_atom1504 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_STRING_LITERAL_in_atom1509 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_WILDCARD_in_atom1514 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_DOT_in_atom1520 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ID_in_atom1522 = new BitSet(new long[]{0x0000000020040000L,0x0000000441010000L});
public static final BitSet FOLLOW_atom_in_atom1524 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_binaryMultipleOp_in_synpred1_LeftRecursiveRuleWalker484 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_binary_in_synpred2_LeftRecursiveRuleWalker530 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_ternary_in_synpred3_LeftRecursiveRuleWalker593 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_prefix_in_synpred4_LeftRecursiveRuleWalker648 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_suffix_in_synpred5_LeftRecursiveRuleWalker704 = new BitSet(new long[]{0x0000000000000002L});
}