org.antlr.v4.parse.BlockSetTransformer Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of antlr4 Show documentation
Show all versions of antlr4 Show documentation
The ANTLR 4 grammar compiler.
// $ANTLR 3.5 org\\antlr\\v4\\parse\\BlockSetTransformer.g 2014-02-08 10:59:30
package org.antlr.v4.parse;
import org.antlr.v4.misc.Utils;
import org.antlr.v4.misc.*;
import org.antlr.v4.tool.*;
import org.antlr.v4.tool.ast.*;
import java.util.List;
import java.util.Set;
import java.util.HashSet;
import java.util.ArrayList;
import org.antlr.v4.runtime.misc.IntervalSet;
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;
@SuppressWarnings("all")
public class BlockSetTransformer extends TreeRewriter {
public static final String[] tokenNames = new String[] {
"", "", "", "", "ACTION", "ACTION_CHAR_LITERAL",
"ACTION_ESC", "ACTION_STRING_LITERAL", "ARG_ACTION", "ARG_OR_CHARSET",
"ASSIGN", "AT", "CATCH", "COLON", "COLONCOLON", "COMMA", "COMMENT", "DOC_COMMENT",
"DOLLAR", "DOT", "ERRCHAR", "ESC_SEQ", "FINALLY", "FRAGMENT", "GRAMMAR",
"GT", "HEX_DIGIT", "ID", "IMPORT", "INT", "LEXER", "LEXER_CHAR_SET", "LOCALS",
"LPAREN", "LT", "MODE", "NESTED_ACTION", "NLCHARS", "NOT", "NameChar",
"NameStartChar", "OPTIONS", "OR", "PARSER", "PLUS", "PLUS_ASSIGN", "POUND",
"PRIVATE", "PROTECTED", "PUBLIC", "QUESTION", "RANGE", "RARROW", "RBRACE",
"RETURNS", "RPAREN", "RULE_REF", "SEMI", "SEMPRED", "SRC", "STAR", "STRING_LITERAL",
"SYNPRED", "THROWS", "TOKENS_SPEC", "TOKEN_REF", "TREE_GRAMMAR", "UNICODE_ESC",
"UnicodeBOM", "WS", "WSCHARS", "WSNLCHARS", "ALT", "ALTLIST", "ARG", "ARGLIST",
"BLOCK", "CHAR_RANGE", "CLOSURE", "COMBINED", "ELEMENT_OPTIONS", "EPSILON",
"INITACTION", "LABEL", "LEXER_ACTION_CALL", "LEXER_ALT_ACTION", "LIST",
"OPTIONAL", "POSITIVE_CLOSURE", "PREC_RULE", "RESULT", "RET", "RULE",
"RULEACTIONS", "RULEMODIFIERS", "RULES", "SET", "TEMPLATE", "WILDCARD"
};
public static final int EOF=-1;
public static final int ACTION=4;
public static final int ACTION_CHAR_LITERAL=5;
public static final int ACTION_ESC=6;
public static final int ACTION_STRING_LITERAL=7;
public static final int ARG_ACTION=8;
public static final int ARG_OR_CHARSET=9;
public static final int ASSIGN=10;
public static final int AT=11;
public static final int CATCH=12;
public static final int COLON=13;
public static final int COLONCOLON=14;
public static final int COMMA=15;
public static final int COMMENT=16;
public static final int DOC_COMMENT=17;
public static final int DOLLAR=18;
public static final int DOT=19;
public static final int ERRCHAR=20;
public static final int ESC_SEQ=21;
public static final int FINALLY=22;
public static final int FRAGMENT=23;
public static final int GRAMMAR=24;
public static final int GT=25;
public static final int HEX_DIGIT=26;
public static final int ID=27;
public static final int IMPORT=28;
public static final int INT=29;
public static final int LEXER=30;
public static final int LEXER_CHAR_SET=31;
public static final int LOCALS=32;
public static final int LPAREN=33;
public static final int LT=34;
public static final int MODE=35;
public static final int NESTED_ACTION=36;
public static final int NLCHARS=37;
public static final int NOT=38;
public static final int NameChar=39;
public static final int NameStartChar=40;
public static final int OPTIONS=41;
public static final int OR=42;
public static final int PARSER=43;
public static final int PLUS=44;
public static final int PLUS_ASSIGN=45;
public static final int POUND=46;
public static final int PRIVATE=47;
public static final int PROTECTED=48;
public static final int PUBLIC=49;
public static final int QUESTION=50;
public static final int RANGE=51;
public static final int RARROW=52;
public static final int RBRACE=53;
public static final int RETURNS=54;
public static final int RPAREN=55;
public static final int RULE_REF=56;
public static final int SEMI=57;
public static final int SEMPRED=58;
public static final int SRC=59;
public static final int STAR=60;
public static final int STRING_LITERAL=61;
public static final int SYNPRED=62;
public static final int THROWS=63;
public static final int TOKENS_SPEC=64;
public static final int TOKEN_REF=65;
public static final int TREE_GRAMMAR=66;
public static final int UNICODE_ESC=67;
public static final int UnicodeBOM=68;
public static final int WS=69;
public static final int WSCHARS=70;
public static final int WSNLCHARS=71;
public static final int ALT=72;
public static final int ALTLIST=73;
public static final int ARG=74;
public static final int ARGLIST=75;
public static final int BLOCK=76;
public static final int CHAR_RANGE=77;
public static final int CLOSURE=78;
public static final int COMBINED=79;
public static final int ELEMENT_OPTIONS=80;
public static final int EPSILON=81;
public static final int INITACTION=82;
public static final int LABEL=83;
public static final int LEXER_ACTION_CALL=84;
public static final int LEXER_ALT_ACTION=85;
public static final int LIST=86;
public static final int OPTIONAL=87;
public static final int POSITIVE_CLOSURE=88;
public static final int PREC_RULE=89;
public static final int RESULT=90;
public static final int RET=91;
public static final int RULE=92;
public static final int RULEACTIONS=93;
public static final int RULEMODIFIERS=94;
public static final int RULES=95;
public static final int SET=96;
public static final int TEMPLATE=97;
public static final int WILDCARD=98;
// delegates
public TreeRewriter[] getDelegates() {
return new TreeRewriter[] {};
}
// delegators
public BlockSetTransformer(TreeNodeStream input) {
this(input, new RecognizerSharedState());
}
public BlockSetTransformer(TreeNodeStream input, RecognizerSharedState state) {
super(input, state);
}
protected TreeAdaptor adaptor = new CommonTreeAdaptor();
public void setTreeAdaptor(TreeAdaptor adaptor) {
this.adaptor = adaptor;
}
public TreeAdaptor getTreeAdaptor() {
return adaptor;
}
@Override public String[] getTokenNames() { return BlockSetTransformer.tokenNames; }
@Override public String getGrammarFileName() { return "org\\antlr\\v4\\parse\\BlockSetTransformer.g"; }
public String currentRuleName;
public GrammarAST currentAlt;
public Grammar g;
public BlockSetTransformer(TreeNodeStream input, Grammar g) {
this(input, new RecognizerSharedState());
this.g = g;
}
public static class topdown_return extends TreeRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "topdown"
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:63:1: topdown : ( ^( RULE (id= TOKEN_REF |id= RULE_REF ) ( . )+ ) | setAlt | ebnfBlockSet | blockSet );
@Override
public final BlockSetTransformer.topdown_return topdown() throws RecognitionException {
BlockSetTransformer.topdown_return retval = new BlockSetTransformer.topdown_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
GrammarAST _first_0 = null;
GrammarAST _last = null;
GrammarAST id=null;
GrammarAST RULE1=null;
GrammarAST wildcard2=null;
TreeRuleReturnScope setAlt3 =null;
TreeRuleReturnScope ebnfBlockSet4 =null;
TreeRuleReturnScope blockSet5 =null;
GrammarAST id_tree=null;
GrammarAST RULE1_tree=null;
GrammarAST wildcard2_tree=null;
try {
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:64:5: ( ^( RULE (id= TOKEN_REF |id= RULE_REF ) ( . )+ ) | setAlt | ebnfBlockSet | blockSet )
int alt3=4;
switch ( input.LA(1) ) {
case RULE:
{
alt3=1;
}
break;
case ALT:
{
alt3=2;
}
break;
case CLOSURE:
case OPTIONAL:
case POSITIVE_CLOSURE:
{
alt3=3;
}
break;
case BLOCK:
{
alt3=4;
}
break;
default:
if (state.backtracking>0) {state.failed=true; return retval;}
NoViableAltException nvae =
new NoViableAltException("", 3, 0, input);
throw nvae;
}
switch (alt3) {
case 1 :
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:64:7: ^( RULE (id= TOKEN_REF |id= RULE_REF ) ( . )+ )
{
_last = (GrammarAST)input.LT(1);
{
GrammarAST _save_last_1 = _last;
GrammarAST _first_1 = null;
_last = (GrammarAST)input.LT(1);
RULE1=(GrammarAST)match(input,RULE,FOLLOW_RULE_in_topdown86); if (state.failed) return retval;
if ( state.backtracking==1 )
if ( _first_0==null ) _first_0 = RULE1;
match(input, Token.DOWN, null); if (state.failed) return retval;
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:64:14: (id= TOKEN_REF |id= RULE_REF )
int alt1=2;
int LA1_0 = input.LA(1);
if ( (LA1_0==TOKEN_REF) ) {
alt1=1;
}
else if ( (LA1_0==RULE_REF) ) {
alt1=2;
}
else {
if (state.backtracking>0) {state.failed=true; return retval;}
NoViableAltException nvae =
new NoViableAltException("", 1, 0, input);
throw nvae;
}
switch (alt1) {
case 1 :
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:64:15: id= TOKEN_REF
{
_last = (GrammarAST)input.LT(1);
id=(GrammarAST)match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_topdown91); if (state.failed) return retval;
if ( state.backtracking==1 )
if ( _first_1==null ) _first_1 = id;
if ( state.backtracking==1 ) {
retval.tree = _first_0;
if ( adaptor.getParent(retval.tree)!=null && adaptor.isNil( adaptor.getParent(retval.tree) ) )
retval.tree = (GrammarAST)adaptor.getParent(retval.tree);
}
}
break;
case 2 :
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:64:28: id= RULE_REF
{
_last = (GrammarAST)input.LT(1);
id=(GrammarAST)match(input,RULE_REF,FOLLOW_RULE_REF_in_topdown95); if (state.failed) return retval;
if ( state.backtracking==1 )
if ( _first_1==null ) _first_1 = id;
if ( state.backtracking==1 ) {
retval.tree = _first_0;
if ( adaptor.getParent(retval.tree)!=null && adaptor.isNil( adaptor.getParent(retval.tree) ) )
retval.tree = (GrammarAST)adaptor.getParent(retval.tree);
}
}
break;
}
if ( state.backtracking==1 ) {currentRuleName=(id!=null?id.getText():null);}
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:64:69: ( . )+
int cnt2=0;
loop2:
while (true) {
int alt2=2;
int LA2_0 = input.LA(1);
if ( ((LA2_0 >= ACTION && LA2_0 <= WILDCARD)) ) {
alt2=1;
}
else if ( (LA2_0==UP) ) {
alt2=2;
}
switch (alt2) {
case 1 :
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:64:69: .
{
_last = (GrammarAST)input.LT(1);
wildcard2=(GrammarAST)input.LT(1);
matchAny(input); if (state.failed) return retval;
if ( state.backtracking==1 )
if ( _first_1==null ) _first_1 = wildcard2;
if ( state.backtracking==1 ) {
retval.tree = _first_0;
if ( adaptor.getParent(retval.tree)!=null && adaptor.isNil( adaptor.getParent(retval.tree) ) )
retval.tree = (GrammarAST)adaptor.getParent(retval.tree);
}
}
break;
default :
if ( cnt2 >= 1 ) break loop2;
if (state.backtracking>0) {state.failed=true; return retval;}
EarlyExitException eee = new EarlyExitException(2, input);
throw eee;
}
cnt2++;
}
match(input, Token.UP, null); if (state.failed) return retval;
_last = _save_last_1;
}
if ( state.backtracking==1 ) {
retval.tree = _first_0;
if ( adaptor.getParent(retval.tree)!=null && adaptor.isNil( adaptor.getParent(retval.tree) ) )
retval.tree = (GrammarAST)adaptor.getParent(retval.tree);
}
}
break;
case 2 :
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:65:7: setAlt
{
_last = (GrammarAST)input.LT(1);
pushFollow(FOLLOW_setAlt_in_topdown110);
setAlt3=setAlt();
state._fsp--;
if (state.failed) return retval;
if ( state.backtracking==1 )
if ( _first_0==null ) _first_0 = (GrammarAST)setAlt3.getTree();
if ( state.backtracking==1 ) {
retval.tree = _first_0;
if ( adaptor.getParent(retval.tree)!=null && adaptor.isNil( adaptor.getParent(retval.tree) ) )
retval.tree = (GrammarAST)adaptor.getParent(retval.tree);
}
}
break;
case 3 :
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:66:7: ebnfBlockSet
{
_last = (GrammarAST)input.LT(1);
pushFollow(FOLLOW_ebnfBlockSet_in_topdown118);
ebnfBlockSet4=ebnfBlockSet();
state._fsp--;
if (state.failed) return retval;
if ( state.backtracking==1 )
if ( _first_0==null ) _first_0 = (GrammarAST)ebnfBlockSet4.getTree();
if ( state.backtracking==1 ) {
retval.tree = _first_0;
if ( adaptor.getParent(retval.tree)!=null && adaptor.isNil( adaptor.getParent(retval.tree) ) )
retval.tree = (GrammarAST)adaptor.getParent(retval.tree);
}
}
break;
case 4 :
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:67:7: blockSet
{
_last = (GrammarAST)input.LT(1);
pushFollow(FOLLOW_blockSet_in_topdown126);
blockSet5=blockSet();
state._fsp--;
if (state.failed) return retval;
if ( state.backtracking==1 )
if ( _first_0==null ) _first_0 = (GrammarAST)blockSet5.getTree();
if ( state.backtracking==1 ) {
retval.tree = _first_0;
if ( adaptor.getParent(retval.tree)!=null && adaptor.isNil( adaptor.getParent(retval.tree) ) )
retval.tree = (GrammarAST)adaptor.getParent(retval.tree);
}
}
break;
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "topdown"
public static class setAlt_return extends TreeRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "setAlt"
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:70:1: setAlt :{...}? ALT ;
public final BlockSetTransformer.setAlt_return setAlt() throws RecognitionException {
BlockSetTransformer.setAlt_return retval = new BlockSetTransformer.setAlt_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
GrammarAST _first_0 = null;
GrammarAST _last = null;
GrammarAST ALT6=null;
GrammarAST ALT6_tree=null;
try {
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:71:2: ({...}? ALT )
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:71:4: {...}? ALT
{
if ( !((inContext("RULE BLOCK"))) ) {
if (state.backtracking>0) {state.failed=true; return retval;}
throw new FailedPredicateException(input, "setAlt", "inContext(\"RULE BLOCK\")");
}
_last = (GrammarAST)input.LT(1);
ALT6=(GrammarAST)match(input,ALT,FOLLOW_ALT_in_setAlt141); if (state.failed) return retval;
if ( state.backtracking==1 )
if ( _first_0==null ) _first_0 = ALT6;
if ( state.backtracking==1 ) {currentAlt = ((GrammarAST)retval.start);}
if ( state.backtracking==1 ) {
retval.tree = _first_0;
if ( adaptor.getParent(retval.tree)!=null && adaptor.isNil( adaptor.getParent(retval.tree) ) )
retval.tree = (GrammarAST)adaptor.getParent(retval.tree);
}
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "setAlt"
public static class ebnfBlockSet_return extends TreeRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "ebnfBlockSet"
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:76:1: ebnfBlockSet : ^( ebnfSuffix blockSet ) -> ^( ebnfSuffix ^( BLOCK ^( ALT blockSet ) ) ) ;
public final BlockSetTransformer.ebnfBlockSet_return ebnfBlockSet() throws RecognitionException {
BlockSetTransformer.ebnfBlockSet_return retval = new BlockSetTransformer.ebnfBlockSet_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
GrammarAST _first_0 = null;
GrammarAST _last = null;
TreeRuleReturnScope ebnfSuffix7 =null;
TreeRuleReturnScope blockSet8 =null;
RewriteRuleSubtreeStream stream_ebnfSuffix=new RewriteRuleSubtreeStream(adaptor,"rule ebnfSuffix");
RewriteRuleSubtreeStream stream_blockSet=new RewriteRuleSubtreeStream(adaptor,"rule blockSet");
try {
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:80:2: ( ^( ebnfSuffix blockSet ) -> ^( ebnfSuffix ^( BLOCK ^( ALT blockSet ) ) ) )
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:80:4: ^( ebnfSuffix blockSet )
{
_last = (GrammarAST)input.LT(1);
{
GrammarAST _save_last_1 = _last;
GrammarAST _first_1 = null;
_last = (GrammarAST)input.LT(1);
pushFollow(FOLLOW_ebnfSuffix_in_ebnfBlockSet161);
ebnfSuffix7=ebnfSuffix();
state._fsp--;
if (state.failed) return retval;
if ( state.backtracking==1 ) stream_ebnfSuffix.add(ebnfSuffix7.getTree());
if ( state.backtracking==1 )
if ( _first_0==null ) _first_0 = (GrammarAST)ebnfSuffix7.getTree();
match(input, Token.DOWN, null); if (state.failed) return retval;
_last = (GrammarAST)input.LT(1);
pushFollow(FOLLOW_blockSet_in_ebnfBlockSet163);
blockSet8=blockSet();
state._fsp--;
if (state.failed) return retval;
if ( state.backtracking==1 ) stream_blockSet.add(blockSet8.getTree());
match(input, Token.UP, null); if (state.failed) return retval;
_last = _save_last_1;
}
// AST REWRITE
// elements: blockSet, ebnfSuffix
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if ( state.backtracking==1 ) {
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 80:27: -> ^( ebnfSuffix ^( BLOCK ^( ALT blockSet ) ) )
{
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:80:30: ^( ebnfSuffix ^( BLOCK ^( ALT blockSet ) ) )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot(stream_ebnfSuffix.nextNode(), root_1);
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:80:43: ^( BLOCK ^( ALT blockSet ) )
{
GrammarAST root_2 = (GrammarAST)adaptor.nil();
root_2 = (GrammarAST)adaptor.becomeRoot(new BlockAST(BLOCK), root_2);
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:80:61: ^( ALT blockSet )
{
GrammarAST root_3 = (GrammarAST)adaptor.nil();
root_3 = (GrammarAST)adaptor.becomeRoot(new AltAST(ALT), root_3);
adaptor.addChild(root_3, stream_blockSet.nextTree());
adaptor.addChild(root_2, root_3);
}
adaptor.addChild(root_1, root_2);
}
adaptor.addChild(root_0, root_1);
}
}
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
input.replaceChildren(adaptor.getParent(retval.start),
adaptor.getChildIndex(retval.start),
adaptor.getChildIndex(_last),
retval.tree);
}
}
if ( state.backtracking==1 ) {
GrammarTransformPipeline.setGrammarPtr(g, retval.tree);
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "ebnfBlockSet"
public static class ebnfSuffix_return extends TreeRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "ebnfSuffix"
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:83:1: ebnfSuffix : ( OPTIONAL | CLOSURE | POSITIVE_CLOSURE );
public final BlockSetTransformer.ebnfSuffix_return ebnfSuffix() throws RecognitionException {
BlockSetTransformer.ebnfSuffix_return retval = new BlockSetTransformer.ebnfSuffix_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
GrammarAST _first_0 = null;
GrammarAST _last = null;
GrammarAST set9=null;
GrammarAST set9_tree=null;
try {
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:85:2: ( OPTIONAL | CLOSURE | POSITIVE_CLOSURE )
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:
{
_last = (GrammarAST)input.LT(1);
set9=(GrammarAST)input.LT(1);
if ( input.LA(1)==CLOSURE||(input.LA(1) >= OPTIONAL && input.LA(1) <= POSITIVE_CLOSURE) ) {
input.consume();
state.errorRecovery=false;
state.failed=false;
}
else {
if (state.backtracking>0) {state.failed=true; return retval;}
MismatchedSetException mse = new MismatchedSetException(null,input);
throw mse;
}
if ( state.backtracking==1 ) {
retval.tree = _first_0;
if ( adaptor.getParent(retval.tree)!=null && adaptor.isNil( adaptor.getParent(retval.tree) ) )
retval.tree = (GrammarAST)adaptor.getParent(retval.tree);
}
}
if ( state.backtracking==1 ) {retval.tree = (GrammarAST)adaptor.dupNode(((GrammarAST)retval.start));}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "ebnfSuffix"
public static class blockSet_return extends TreeRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "blockSet"
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:90:1: blockSet : ({...}? ^( BLOCK ^(alt= ALT {...}? setElement[inLexer] ) ( ^( ALT setElement[inLexer] ) )+ ) -> ^( BLOCK[$BLOCK.token] ^( ALT[$BLOCK.token,\"ALT\"] ^( SET[$BLOCK.token, \"SET\"] ( setElement )+ ) ) ) |{...}? ^( BLOCK ^( ALT setElement[inLexer] ) ( ^( ALT setElement[inLexer] ) )+ ) -> ^( SET[$BLOCK.token, \"SET\"] ( setElement )+ ) );
public final BlockSetTransformer.blockSet_return blockSet() throws RecognitionException {
BlockSetTransformer.blockSet_return retval = new BlockSetTransformer.blockSet_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
GrammarAST _first_0 = null;
GrammarAST _last = null;
GrammarAST alt=null;
GrammarAST BLOCK10=null;
GrammarAST ALT12=null;
GrammarAST BLOCK14=null;
GrammarAST ALT15=null;
GrammarAST ALT17=null;
TreeRuleReturnScope setElement11 =null;
TreeRuleReturnScope setElement13 =null;
TreeRuleReturnScope setElement16 =null;
TreeRuleReturnScope setElement18 =null;
GrammarAST alt_tree=null;
GrammarAST BLOCK10_tree=null;
GrammarAST ALT12_tree=null;
GrammarAST BLOCK14_tree=null;
GrammarAST ALT15_tree=null;
GrammarAST ALT17_tree=null;
RewriteRuleNodeStream stream_ALT=new RewriteRuleNodeStream(adaptor,"token ALT");
RewriteRuleNodeStream stream_BLOCK=new RewriteRuleNodeStream(adaptor,"token BLOCK");
RewriteRuleSubtreeStream stream_setElement=new RewriteRuleSubtreeStream(adaptor,"rule setElement");
boolean inLexer = Grammar.isTokenName(currentRuleName);
try {
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:97:2: ({...}? ^( BLOCK ^(alt= ALT {...}? setElement[inLexer] ) ( ^( ALT setElement[inLexer] ) )+ ) -> ^( BLOCK[$BLOCK.token] ^( ALT[$BLOCK.token,\"ALT\"] ^( SET[$BLOCK.token, \"SET\"] ( setElement )+ ) ) ) |{...}? ^( BLOCK ^( ALT setElement[inLexer] ) ( ^( ALT setElement[inLexer] ) )+ ) -> ^( SET[$BLOCK.token, \"SET\"] ( setElement )+ ) )
int alt6=2;
alt6 = dfa6.predict(input);
switch (alt6) {
case 1 :
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:97:4: {...}? ^( BLOCK ^(alt= ALT {...}? setElement[inLexer] ) ( ^( ALT setElement[inLexer] ) )+ )
{
if ( !((inContext("RULE"))) ) {
if (state.backtracking>0) {state.failed=true; return retval;}
throw new FailedPredicateException(input, "blockSet", "inContext(\"RULE\")");
}
_last = (GrammarAST)input.LT(1);
{
GrammarAST _save_last_1 = _last;
GrammarAST _first_1 = null;
_last = (GrammarAST)input.LT(1);
BLOCK10=(GrammarAST)match(input,BLOCK,FOLLOW_BLOCK_in_blockSet244); if (state.failed) return retval;
if ( state.backtracking==1 ) stream_BLOCK.add(BLOCK10);
if ( state.backtracking==1 )
if ( _first_0==null ) _first_0 = BLOCK10;
match(input, Token.DOWN, null); if (state.failed) return retval;
_last = (GrammarAST)input.LT(1);
{
GrammarAST _save_last_2 = _last;
GrammarAST _first_2 = null;
_last = (GrammarAST)input.LT(1);
alt=(GrammarAST)match(input,ALT,FOLLOW_ALT_in_blockSet249); if (state.failed) return retval;
if ( state.backtracking==1 ) stream_ALT.add(alt);
if ( state.backtracking==1 )
if ( _first_1==null ) _first_1 = alt;
match(input, Token.DOWN, null); if (state.failed) return retval;
if ( !((((AltAST)alt).altLabel==null)) ) {
if (state.backtracking>0) {state.failed=true; return retval;}
throw new FailedPredicateException(input, "blockSet", "((AltAST)$alt).altLabel==null");
}
_last = (GrammarAST)input.LT(1);
pushFollow(FOLLOW_setElement_in_blockSet253);
setElement11=setElement(inLexer);
state._fsp--;
if (state.failed) return retval;
if ( state.backtracking==1 ) stream_setElement.add(setElement11.getTree());
match(input, Token.UP, null); if (state.failed) return retval;
_last = _save_last_2;
}
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:98:75: ( ^( ALT setElement[inLexer] ) )+
int cnt4=0;
loop4:
while (true) {
int alt4=2;
int LA4_0 = input.LA(1);
if ( (LA4_0==ALT) ) {
alt4=1;
}
switch (alt4) {
case 1 :
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:98:77: ^( ALT setElement[inLexer] )
{
_last = (GrammarAST)input.LT(1);
{
GrammarAST _save_last_2 = _last;
GrammarAST _first_2 = null;
_last = (GrammarAST)input.LT(1);
ALT12=(GrammarAST)match(input,ALT,FOLLOW_ALT_in_blockSet260); if (state.failed) return retval;
if ( state.backtracking==1 ) stream_ALT.add(ALT12);
if ( state.backtracking==1 )
if ( _first_1==null ) _first_1 = ALT12;
match(input, Token.DOWN, null); if (state.failed) return retval;
_last = (GrammarAST)input.LT(1);
pushFollow(FOLLOW_setElement_in_blockSet262);
setElement13=setElement(inLexer);
state._fsp--;
if (state.failed) return retval;
if ( state.backtracking==1 ) stream_setElement.add(setElement13.getTree());
match(input, Token.UP, null); if (state.failed) return retval;
_last = _save_last_2;
}
if ( state.backtracking==1 ) {
retval.tree = _first_0;
if ( adaptor.getParent(retval.tree)!=null && adaptor.isNil( adaptor.getParent(retval.tree) ) )
retval.tree = (GrammarAST)adaptor.getParent(retval.tree);
}
}
break;
default :
if ( cnt4 >= 1 ) break loop4;
if (state.backtracking>0) {state.failed=true; return retval;}
EarlyExitException eee = new EarlyExitException(4, input);
throw eee;
}
cnt4++;
}
match(input, Token.UP, null); if (state.failed) return retval;
_last = _save_last_1;
}
// AST REWRITE
// elements: BLOCK, setElement, ALT
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if ( state.backtracking==1 ) {
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 99:3: -> ^( BLOCK[$BLOCK.token] ^( ALT[$BLOCK.token,\"ALT\"] ^( SET[$BLOCK.token, \"SET\"] ( setElement )+ ) ) )
{
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:99:6: ^( BLOCK[$BLOCK.token] ^( ALT[$BLOCK.token,\"ALT\"] ^( SET[$BLOCK.token, \"SET\"] ( setElement )+ ) ) )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot(new BlockAST(BLOCK, BLOCK10.token), root_1);
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:99:38: ^( ALT[$BLOCK.token,\"ALT\"] ^( SET[$BLOCK.token, \"SET\"] ( setElement )+ ) )
{
GrammarAST root_2 = (GrammarAST)adaptor.nil();
root_2 = (GrammarAST)adaptor.becomeRoot(new AltAST(ALT, BLOCK10.token, "ALT"), root_2);
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:99:72: ^( SET[$BLOCK.token, \"SET\"] ( setElement )+ )
{
GrammarAST root_3 = (GrammarAST)adaptor.nil();
root_3 = (GrammarAST)adaptor.becomeRoot((GrammarAST)adaptor.create(SET, BLOCK10.token, "SET"), root_3);
if ( !(stream_setElement.hasNext()) ) {
throw new RewriteEarlyExitException();
}
while ( stream_setElement.hasNext() ) {
adaptor.addChild(root_3, stream_setElement.nextTree());
}
stream_setElement.reset();
adaptor.addChild(root_2, root_3);
}
adaptor.addChild(root_1, root_2);
}
adaptor.addChild(root_0, root_1);
}
}
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
input.replaceChildren(adaptor.getParent(retval.start),
adaptor.getChildIndex(retval.start),
adaptor.getChildIndex(_last),
retval.tree);
}
}
break;
case 2 :
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:100:4: {...}? ^( BLOCK ^( ALT setElement[inLexer] ) ( ^( ALT setElement[inLexer] ) )+ )
{
if ( !((!inContext("RULE"))) ) {
if (state.backtracking>0) {state.failed=true; return retval;}
throw new FailedPredicateException(input, "blockSet", "!inContext(\"RULE\")");
}
_last = (GrammarAST)input.LT(1);
{
GrammarAST _save_last_1 = _last;
GrammarAST _first_1 = null;
_last = (GrammarAST)input.LT(1);
BLOCK14=(GrammarAST)match(input,BLOCK,FOLLOW_BLOCK_in_blockSet307); if (state.failed) return retval;
if ( state.backtracking==1 ) stream_BLOCK.add(BLOCK14);
if ( state.backtracking==1 )
if ( _first_0==null ) _first_0 = BLOCK14;
match(input, Token.DOWN, null); if (state.failed) return retval;
_last = (GrammarAST)input.LT(1);
{
GrammarAST _save_last_2 = _last;
GrammarAST _first_2 = null;
_last = (GrammarAST)input.LT(1);
ALT15=(GrammarAST)match(input,ALT,FOLLOW_ALT_in_blockSet310); if (state.failed) return retval;
if ( state.backtracking==1 ) stream_ALT.add(ALT15);
if ( state.backtracking==1 )
if ( _first_1==null ) _first_1 = ALT15;
match(input, Token.DOWN, null); if (state.failed) return retval;
_last = (GrammarAST)input.LT(1);
pushFollow(FOLLOW_setElement_in_blockSet312);
setElement16=setElement(inLexer);
state._fsp--;
if (state.failed) return retval;
if ( state.backtracking==1 ) stream_setElement.add(setElement16.getTree());
match(input, Token.UP, null); if (state.failed) return retval;
_last = _save_last_2;
}
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:101:38: ( ^( ALT setElement[inLexer] ) )+
int cnt5=0;
loop5:
while (true) {
int alt5=2;
int LA5_0 = input.LA(1);
if ( (LA5_0==ALT) ) {
alt5=1;
}
switch (alt5) {
case 1 :
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:101:40: ^( ALT setElement[inLexer] )
{
_last = (GrammarAST)input.LT(1);
{
GrammarAST _save_last_2 = _last;
GrammarAST _first_2 = null;
_last = (GrammarAST)input.LT(1);
ALT17=(GrammarAST)match(input,ALT,FOLLOW_ALT_in_blockSet319); if (state.failed) return retval;
if ( state.backtracking==1 ) stream_ALT.add(ALT17);
if ( state.backtracking==1 )
if ( _first_1==null ) _first_1 = ALT17;
match(input, Token.DOWN, null); if (state.failed) return retval;
_last = (GrammarAST)input.LT(1);
pushFollow(FOLLOW_setElement_in_blockSet321);
setElement18=setElement(inLexer);
state._fsp--;
if (state.failed) return retval;
if ( state.backtracking==1 ) stream_setElement.add(setElement18.getTree());
match(input, Token.UP, null); if (state.failed) return retval;
_last = _save_last_2;
}
if ( state.backtracking==1 ) {
retval.tree = _first_0;
if ( adaptor.getParent(retval.tree)!=null && adaptor.isNil( adaptor.getParent(retval.tree) ) )
retval.tree = (GrammarAST)adaptor.getParent(retval.tree);
}
}
break;
default :
if ( cnt5 >= 1 ) break loop5;
if (state.backtracking>0) {state.failed=true; return retval;}
EarlyExitException eee = new EarlyExitException(5, input);
throw eee;
}
cnt5++;
}
match(input, Token.UP, null); if (state.failed) return retval;
_last = _save_last_1;
}
// AST REWRITE
// elements: setElement
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
if ( state.backtracking==1 ) {
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 102:3: -> ^( SET[$BLOCK.token, \"SET\"] ( setElement )+ )
{
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:102:6: ^( SET[$BLOCK.token, \"SET\"] ( setElement )+ )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot((GrammarAST)adaptor.create(SET, BLOCK14.token, "SET"), root_1);
if ( !(stream_setElement.hasNext()) ) {
throw new RewriteEarlyExitException();
}
while ( stream_setElement.hasNext() ) {
adaptor.addChild(root_1, stream_setElement.nextTree());
}
stream_setElement.reset();
adaptor.addChild(root_0, root_1);
}
}
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
input.replaceChildren(adaptor.getParent(retval.start),
adaptor.getChildIndex(retval.start),
adaptor.getChildIndex(_last),
retval.tree);
}
}
break;
}
if ( state.backtracking==1 ) {
GrammarTransformPipeline.setGrammarPtr(g, retval.tree);
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "blockSet"
public static class setElement_return extends TreeRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "setElement"
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:105:1: setElement[boolean inLexer] : (a= STRING_LITERAL {...}?|{...}? => TOKEN_REF |{...}? => ^( RANGE a= STRING_LITERAL b= STRING_LITERAL ) {...}?) ;
public final BlockSetTransformer.setElement_return setElement(boolean inLexer) throws RecognitionException {
BlockSetTransformer.setElement_return retval = new BlockSetTransformer.setElement_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
GrammarAST _first_0 = null;
GrammarAST _last = null;
GrammarAST a=null;
GrammarAST b=null;
GrammarAST TOKEN_REF19=null;
GrammarAST RANGE20=null;
GrammarAST a_tree=null;
GrammarAST b_tree=null;
GrammarAST TOKEN_REF19_tree=null;
GrammarAST RANGE20_tree=null;
try {
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:109:2: ( (a= STRING_LITERAL {...}?|{...}? => TOKEN_REF |{...}? => ^( RANGE a= STRING_LITERAL b= STRING_LITERAL ) {...}?) )
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:109:4: (a= STRING_LITERAL {...}?|{...}? => TOKEN_REF |{...}? => ^( RANGE a= STRING_LITERAL b= STRING_LITERAL ) {...}?)
{
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:109:4: (a= STRING_LITERAL {...}?|{...}? => TOKEN_REF |{...}? => ^( RANGE a= STRING_LITERAL b= STRING_LITERAL ) {...}?)
int alt7=3;
int LA7_0 = input.LA(1);
if ( (LA7_0==STRING_LITERAL) ) {
alt7=1;
}
else if ( (LA7_0==TOKEN_REF) && ((!inLexer))) {
alt7=2;
}
else if ( (LA7_0==RANGE) && ((inLexer))) {
alt7=3;
}
switch (alt7) {
case 1 :
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:109:6: a= STRING_LITERAL {...}?
{
_last = (GrammarAST)input.LT(1);
a=(GrammarAST)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_setElement360); if (state.failed) return retval;
if ( state.backtracking==1 )
if ( _first_0==null ) _first_0 = a;
if ( !((!inLexer || CharSupport.getCharValueFromGrammarCharLiteral(a.getText())!=-1)) ) {
if (state.backtracking>0) {state.failed=true; return retval;}
throw new FailedPredicateException(input, "setElement", "!inLexer || CharSupport.getCharValueFromGrammarCharLiteral($a.getText())!=-1");
}
if ( state.backtracking==1 ) {
retval.tree = _first_0;
if ( adaptor.getParent(retval.tree)!=null && adaptor.isNil( adaptor.getParent(retval.tree) ) )
retval.tree = (GrammarAST)adaptor.getParent(retval.tree);
}
}
break;
case 2 :
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:110:5: {...}? => TOKEN_REF
{
if ( !((!inLexer)) ) {
if (state.backtracking>0) {state.failed=true; return retval;}
throw new FailedPredicateException(input, "setElement", "!inLexer");
}
_last = (GrammarAST)input.LT(1);
TOKEN_REF19=(GrammarAST)match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_setElement371); if (state.failed) return retval;
if ( state.backtracking==1 )
if ( _first_0==null ) _first_0 = TOKEN_REF19;
if ( state.backtracking==1 ) {
retval.tree = _first_0;
if ( adaptor.getParent(retval.tree)!=null && adaptor.isNil( adaptor.getParent(retval.tree) ) )
retval.tree = (GrammarAST)adaptor.getParent(retval.tree);
}
}
break;
case 3 :
// org\\antlr\\v4\\parse\\BlockSetTransformer.g:111:5: {...}? => ^( RANGE a= STRING_LITERAL b= STRING_LITERAL ) {...}?
{
if ( !((inLexer)) ) {
if (state.backtracking>0) {state.failed=true; return retval;}
throw new FailedPredicateException(input, "setElement", "inLexer");
}
_last = (GrammarAST)input.LT(1);
{
GrammarAST _save_last_1 = _last;
GrammarAST _first_1 = null;
_last = (GrammarAST)input.LT(1);
RANGE20=(GrammarAST)match(input,RANGE,FOLLOW_RANGE_in_setElement382); if (state.failed) return retval;
if ( state.backtracking==1 )
if ( _first_0==null ) _first_0 = RANGE20;
match(input, Token.DOWN, null); if (state.failed) return retval;
_last = (GrammarAST)input.LT(1);
a=(GrammarAST)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_setElement386); if (state.failed) return retval;
if ( state.backtracking==1 )
if ( _first_1==null ) _first_1 = a;
_last = (GrammarAST)input.LT(1);
b=(GrammarAST)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_setElement390); if (state.failed) return retval;
if ( state.backtracking==1 )
if ( _first_1==null ) _first_1 = b;
match(input, Token.UP, null); if (state.failed) return retval;
_last = _save_last_1;
}
if ( !((CharSupport.getCharValueFromGrammarCharLiteral(a.getText())!=-1 &&
CharSupport.getCharValueFromGrammarCharLiteral(b.getText())!=-1)) ) {
if (state.backtracking>0) {state.failed=true; return retval;}
throw new FailedPredicateException(input, "setElement", "CharSupport.getCharValueFromGrammarCharLiteral($a.getText())!=-1 &&\r\n\t\t\t CharSupport.getCharValueFromGrammarCharLiteral($b.getText())!=-1");
}
if ( state.backtracking==1 ) {
retval.tree = _first_0;
if ( adaptor.getParent(retval.tree)!=null && adaptor.isNil( adaptor.getParent(retval.tree) ) )
retval.tree = (GrammarAST)adaptor.getParent(retval.tree);
}
}
break;
}
if ( state.backtracking==1 ) {
retval.tree = _first_0;
if ( adaptor.getParent(retval.tree)!=null && adaptor.isNil( adaptor.getParent(retval.tree) ) )
retval.tree = (GrammarAST)adaptor.getParent(retval.tree);
}
}
if ( state.backtracking==1 ) {
GrammarTransformPipeline.setGrammarPtr(g, retval.tree);
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "setElement"
// Delegated rules
protected DFA6 dfa6 = new DFA6(this);
static final String DFA6_eotS =
"\32\uffff";
static final String DFA6_eofS =
"\32\uffff";
static final String DFA6_minS =
"\1\114\1\2\1\110\1\2\1\63\2\3\1\2\1\110\1\75\1\2\1\75\1\63\3\3\1\2\2\3"+
"\1\75\1\0\1\75\2\uffff\2\3";
static final String DFA6_maxS =
"\1\114\1\2\1\110\1\2\1\101\2\3\1\2\1\110\1\75\1\2\1\75\1\101\3\3\1\2\1"+
"\3\1\110\1\75\1\0\1\75\2\uffff\2\3";
static final String DFA6_acceptS =
"\26\uffff\1\1\1\2\2\uffff";
static final String DFA6_specialS =
"\24\uffff\1\0\5\uffff}>";
static final String[] DFA6_transitionS = {
"\1\1",
"\1\2",
"\1\3",
"\1\4",
"\1\7\11\uffff\1\5\3\uffff\1\6",
"\1\10",
"\1\10",
"\1\11",
"\1\12",
"\1\13",
"\1\14",
"\1\15",
"\1\20\11\uffff\1\16\3\uffff\1\17",
"\1\21",
"\1\22",
"\1\22",
"\1\23",
"\1\10",
"\1\24\104\uffff\1\12",
"\1\25",
"\1\uffff",
"\1\30",
"",
"",
"\1\31",
"\1\22"
};
static final short[] DFA6_eot = DFA.unpackEncodedString(DFA6_eotS);
static final short[] DFA6_eof = DFA.unpackEncodedString(DFA6_eofS);
static final char[] DFA6_min = DFA.unpackEncodedStringToUnsignedChars(DFA6_minS);
static final char[] DFA6_max = DFA.unpackEncodedStringToUnsignedChars(DFA6_maxS);
static final short[] DFA6_accept = DFA.unpackEncodedString(DFA6_acceptS);
static final short[] DFA6_special = DFA.unpackEncodedString(DFA6_specialS);
static final short[][] DFA6_transition;
static {
int numStates = DFA6_transitionS.length;
DFA6_transition = new short[numStates][];
for (int i=0; i ^( BLOCK[$BLOCK.token] ^( ALT[$BLOCK.token,\"ALT\"] ^( SET[$BLOCK.token, \"SET\"] ( setElement )+ ) ) ) |{...}? ^( BLOCK ^( ALT setElement[inLexer] ) ( ^( ALT setElement[inLexer] ) )+ ) -> ^( SET[$BLOCK.token, \"SET\"] ( setElement )+ ) );";
}
@Override
public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
TreeNodeStream input = (TreeNodeStream)_input;
int _s = s;
switch ( s ) {
case 0 :
int LA6_20 = input.LA(1);
int index6_20 = input.index();
input.rewind();
s = -1;
if ( ((inContext("RULE"))) ) {s = 22;}
else if ( ((!inContext("RULE"))) ) {s = 23;}
input.seek(index6_20);
if ( s>=0 ) return s;
break;
}
if (state.backtracking>0) {state.failed=true; return -1;}
NoViableAltException nvae =
new NoViableAltException(getDescription(), 6, _s, input);
error(nvae);
throw nvae;
}
}
public static final BitSet FOLLOW_RULE_in_topdown86 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_TOKEN_REF_in_topdown91 = new BitSet(new long[]{0xFFFFFFFFFFFFFFF0L,0x00000007FFFFFFFFL});
public static final BitSet FOLLOW_RULE_REF_in_topdown95 = new BitSet(new long[]{0xFFFFFFFFFFFFFFF0L,0x00000007FFFFFFFFL});
public static final BitSet FOLLOW_setAlt_in_topdown110 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_ebnfBlockSet_in_topdown118 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_blockSet_in_topdown126 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_ALT_in_setAlt141 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_ebnfSuffix_in_ebnfBlockSet161 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_blockSet_in_ebnfBlockSet163 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_BLOCK_in_blockSet244 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ALT_in_blockSet249 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_setElement_in_blockSet253 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_ALT_in_blockSet260 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_setElement_in_blockSet262 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_BLOCK_in_blockSet307 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_ALT_in_blockSet310 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_setElement_in_blockSet312 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_ALT_in_blockSet319 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_setElement_in_blockSet321 = new BitSet(new long[]{0x0000000000000008L});
public static final BitSet FOLLOW_STRING_LITERAL_in_setElement360 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_TOKEN_REF_in_setElement371 = new BitSet(new long[]{0x0000000000000002L});
public static final BitSet FOLLOW_RANGE_in_setElement382 = new BitSet(new long[]{0x0000000000000004L});
public static final BitSet FOLLOW_STRING_LITERAL_in_setElement386 = new BitSet(new long[]{0x2000000000000000L});
public static final BitSet FOLLOW_STRING_LITERAL_in_setElement390 = new BitSet(new long[]{0x0000000000000008L});
}