org.antlr.v4.parse.ANTLRParser Maven / Gradle / Ivy
// $ANTLR 3.5.2 org\\antlr\\v4\\parse\\ANTLRParser.g 2022-12-10 21:59:32
/*
* Copyright (c) 2012 The ANTLR Project. All rights reserved.
* Use of this file is governed by the BSD-3-Clause license that
* can be found in the LICENSE.txt file in the project root.
*/
package org.antlr.v4.parse;
import org.antlr.v4.tool.*;
import org.antlr.v4.tool.ast.*;
import java.util.ArrayDeque;
import java.util.Deque;
import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
import org.antlr.runtime.tree.*;
/** The definitive ANTLR v3 grammar to parse ANTLR v4 grammars.
* The grammar builds ASTs that are sniffed by subsequent stages.
*/
@SuppressWarnings("all")
public class ANTLRParser extends Parser {
public static final String[] tokenNames = new String[] {
"", "", "", "", "ACTION", "ACTION_CHAR_LITERAL",
"ACTION_ESC", "ACTION_STRING_LITERAL", "ARG_ACTION", "ARG_OR_CHARSET",
"ASSIGN", "AT", "CATCH", "CHANNELS", "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",
"UNICODE_EXTENDED_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 CHANNELS=13;
public static final int COLON=14;
public static final int COLONCOLON=15;
public static final int COMMA=16;
public static final int COMMENT=17;
public static final int DOC_COMMENT=18;
public static final int DOLLAR=19;
public static final int DOT=20;
public static final int ERRCHAR=21;
public static final int ESC_SEQ=22;
public static final int FINALLY=23;
public static final int FRAGMENT=24;
public static final int GRAMMAR=25;
public static final int GT=26;
public static final int HEX_DIGIT=27;
public static final int ID=28;
public static final int IMPORT=29;
public static final int INT=30;
public static final int LEXER=31;
public static final int LEXER_CHAR_SET=32;
public static final int LOCALS=33;
public static final int LPAREN=34;
public static final int LT=35;
public static final int MODE=36;
public static final int NESTED_ACTION=37;
public static final int NLCHARS=38;
public static final int NOT=39;
public static final int NameChar=40;
public static final int NameStartChar=41;
public static final int OPTIONS=42;
public static final int OR=43;
public static final int PARSER=44;
public static final int PLUS=45;
public static final int PLUS_ASSIGN=46;
public static final int POUND=47;
public static final int PRIVATE=48;
public static final int PROTECTED=49;
public static final int PUBLIC=50;
public static final int QUESTION=51;
public static final int RANGE=52;
public static final int RARROW=53;
public static final int RBRACE=54;
public static final int RETURNS=55;
public static final int RPAREN=56;
public static final int RULE_REF=57;
public static final int SEMI=58;
public static final int SEMPRED=59;
public static final int SRC=60;
public static final int STAR=61;
public static final int STRING_LITERAL=62;
public static final int SYNPRED=63;
public static final int THROWS=64;
public static final int TOKENS_SPEC=65;
public static final int TOKEN_REF=66;
public static final int TREE_GRAMMAR=67;
public static final int UNICODE_ESC=68;
public static final int UNICODE_EXTENDED_ESC=69;
public static final int UnicodeBOM=70;
public static final int WS=71;
public static final int WSCHARS=72;
public static final int WSNLCHARS=73;
public static final int ALT=74;
public static final int ALTLIST=75;
public static final int ARG=76;
public static final int ARGLIST=77;
public static final int BLOCK=78;
public static final int CHAR_RANGE=79;
public static final int CLOSURE=80;
public static final int COMBINED=81;
public static final int ELEMENT_OPTIONS=82;
public static final int EPSILON=83;
public static final int INITACTION=84;
public static final int LABEL=85;
public static final int LEXER_ACTION_CALL=86;
public static final int LEXER_ALT_ACTION=87;
public static final int LIST=88;
public static final int OPTIONAL=89;
public static final int POSITIVE_CLOSURE=90;
public static final int PREC_RULE=91;
public static final int RESULT=92;
public static final int RET=93;
public static final int RULE=94;
public static final int RULEACTIONS=95;
public static final int RULEMODIFIERS=96;
public static final int RULES=97;
public static final int SET=98;
public static final int TEMPLATE=99;
public static final int WILDCARD=100;
// delegates
public Parser[] getDelegates() {
return new Parser[] {};
}
// delegators
public ANTLRParser(TokenStream input) {
this(input, new RecognizerSharedState());
}
public ANTLRParser(TokenStream 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 ANTLRParser.tokenNames; }
@Override public String getGrammarFileName() { return "org\\antlr\\v4\\parse\\ANTLRParser.g"; }
Deque paraphrases = new ArrayDeque();
public void grammarError(ErrorType etype, org.antlr.runtime.Token token, Object... args) { }
public static class grammarSpec_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "grammarSpec"
// org\\antlr\\v4\\parse\\ANTLRParser.g:100:1: grammarSpec : grammarType id SEMI sync ( prequelConstruct sync )* rules ( modeSpec )* EOF -> ^( grammarType id ( prequelConstruct )* rules ( modeSpec )* ) ;
public final ANTLRParser.grammarSpec_return grammarSpec() throws RecognitionException {
ANTLRParser.grammarSpec_return retval = new ANTLRParser.grammarSpec_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token SEMI3=null;
Token EOF9=null;
ParserRuleReturnScope grammarType1 =null;
ParserRuleReturnScope id2 =null;
ParserRuleReturnScope sync4 =null;
ParserRuleReturnScope prequelConstruct5 =null;
ParserRuleReturnScope sync6 =null;
ParserRuleReturnScope rules7 =null;
ParserRuleReturnScope modeSpec8 =null;
GrammarAST SEMI3_tree=null;
GrammarAST EOF9_tree=null;
RewriteRuleTokenStream stream_SEMI=new RewriteRuleTokenStream(adaptor,"token SEMI");
RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
RewriteRuleSubtreeStream stream_modeSpec=new RewriteRuleSubtreeStream(adaptor,"rule modeSpec");
RewriteRuleSubtreeStream stream_grammarType=new RewriteRuleSubtreeStream(adaptor,"rule grammarType");
RewriteRuleSubtreeStream stream_rules=new RewriteRuleSubtreeStream(adaptor,"rule rules");
RewriteRuleSubtreeStream stream_id=new RewriteRuleSubtreeStream(adaptor,"rule id");
RewriteRuleSubtreeStream stream_prequelConstruct=new RewriteRuleSubtreeStream(adaptor,"rule prequelConstruct");
RewriteRuleSubtreeStream stream_sync=new RewriteRuleSubtreeStream(adaptor,"rule sync");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:107:5: ( grammarType id SEMI sync ( prequelConstruct sync )* rules ( modeSpec )* EOF -> ^( grammarType id ( prequelConstruct )* rules ( modeSpec )* ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:110:7: grammarType id SEMI sync ( prequelConstruct sync )* rules ( modeSpec )* EOF
{
pushFollow(FOLLOW_grammarType_in_grammarSpec396);
grammarType1=grammarType();
state._fsp--;
stream_grammarType.add(grammarType1.getTree());
pushFollow(FOLLOW_id_in_grammarSpec398);
id2=id();
state._fsp--;
stream_id.add(id2.getTree());
SEMI3=(Token)match(input,SEMI,FOLLOW_SEMI_in_grammarSpec400);
stream_SEMI.add(SEMI3);
pushFollow(FOLLOW_sync_in_grammarSpec438);
sync4=sync();
state._fsp--;
stream_sync.add(sync4.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:123:12: ( prequelConstruct sync )*
loop1:
while (true) {
int alt1=2;
int LA1_0 = input.LA(1);
if ( (LA1_0==AT||LA1_0==CHANNELS||LA1_0==IMPORT||LA1_0==OPTIONS||LA1_0==TOKENS_SPEC) ) {
alt1=1;
}
switch (alt1) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:123:14: prequelConstruct sync
{
pushFollow(FOLLOW_prequelConstruct_in_grammarSpec442);
prequelConstruct5=prequelConstruct();
state._fsp--;
stream_prequelConstruct.add(prequelConstruct5.getTree());
pushFollow(FOLLOW_sync_in_grammarSpec444);
sync6=sync();
state._fsp--;
stream_sync.add(sync6.getTree());
}
break;
default :
break loop1;
}
}
pushFollow(FOLLOW_rules_in_grammarSpec469);
rules7=rules();
state._fsp--;
stream_rules.add(rules7.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:131:4: ( modeSpec )*
loop2:
while (true) {
int alt2=2;
int LA2_0 = input.LA(1);
if ( (LA2_0==MODE) ) {
alt2=1;
}
switch (alt2) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:131:4: modeSpec
{
pushFollow(FOLLOW_modeSpec_in_grammarSpec475);
modeSpec8=modeSpec();
state._fsp--;
stream_modeSpec.add(modeSpec8.getTree());
}
break;
default :
break loop2;
}
}
EOF9=(Token)match(input,EOF,FOLLOW_EOF_in_grammarSpec513);
stream_EOF.add(EOF9);
// AST REWRITE
// elements: id, grammarType, prequelConstruct, modeSpec, rules
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 144:7: -> ^( grammarType id ( prequelConstruct )* rules ( modeSpec )* )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:144:10: ^( grammarType id ( prequelConstruct )* rules ( modeSpec )* )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot(stream_grammarType.nextNode(), root_1);
adaptor.addChild(root_1, stream_id.nextTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:146:14: ( prequelConstruct )*
while ( stream_prequelConstruct.hasNext() ) {
adaptor.addChild(root_1, stream_prequelConstruct.nextTree());
}
stream_prequelConstruct.reset();
adaptor.addChild(root_1, stream_rules.nextTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:148:14: ( modeSpec )*
while ( stream_modeSpec.hasNext() ) {
adaptor.addChild(root_1, stream_modeSpec.nextTree());
}
stream_modeSpec.reset();
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
GrammarAST options = (GrammarAST)retval.tree.getFirstChildWithType(ANTLRParser.OPTIONS);
if ( options!=null ) {
Grammar.setNodeOptions(retval.tree, options);
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "grammarSpec"
public static class grammarType_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "grammarType"
// org\\antlr\\v4\\parse\\ANTLRParser.g:152:1: grammarType : (t= LEXER g= GRAMMAR -> GRAMMAR[$g, \"LEXER_GRAMMAR\", getTokenStream()] |t= PARSER g= GRAMMAR -> GRAMMAR[$g, \"PARSER_GRAMMAR\", getTokenStream()] |g= GRAMMAR -> GRAMMAR[$g, \"COMBINED_GRAMMAR\", getTokenStream()] |tg= TREE_GRAMMAR ) ;
public final ANTLRParser.grammarType_return grammarType() throws RecognitionException {
ANTLRParser.grammarType_return retval = new ANTLRParser.grammarType_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token t=null;
Token g=null;
Token tg=null;
GrammarAST t_tree=null;
GrammarAST g_tree=null;
GrammarAST tg_tree=null;
RewriteRuleTokenStream stream_PARSER=new RewriteRuleTokenStream(adaptor,"token PARSER");
RewriteRuleTokenStream stream_LEXER=new RewriteRuleTokenStream(adaptor,"token LEXER");
RewriteRuleTokenStream stream_GRAMMAR=new RewriteRuleTokenStream(adaptor,"token GRAMMAR");
RewriteRuleTokenStream stream_TREE_GRAMMAR=new RewriteRuleTokenStream(adaptor,"token TREE_GRAMMAR");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:158:5: ( (t= LEXER g= GRAMMAR -> GRAMMAR[$g, \"LEXER_GRAMMAR\", getTokenStream()] |t= PARSER g= GRAMMAR -> GRAMMAR[$g, \"PARSER_GRAMMAR\", getTokenStream()] |g= GRAMMAR -> GRAMMAR[$g, \"COMBINED_GRAMMAR\", getTokenStream()] |tg= TREE_GRAMMAR ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:158:7: (t= LEXER g= GRAMMAR -> GRAMMAR[$g, \"LEXER_GRAMMAR\", getTokenStream()] |t= PARSER g= GRAMMAR -> GRAMMAR[$g, \"PARSER_GRAMMAR\", getTokenStream()] |g= GRAMMAR -> GRAMMAR[$g, \"COMBINED_GRAMMAR\", getTokenStream()] |tg= TREE_GRAMMAR )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:158:7: (t= LEXER g= GRAMMAR -> GRAMMAR[$g, \"LEXER_GRAMMAR\", getTokenStream()] |t= PARSER g= GRAMMAR -> GRAMMAR[$g, \"PARSER_GRAMMAR\", getTokenStream()] |g= GRAMMAR -> GRAMMAR[$g, \"COMBINED_GRAMMAR\", getTokenStream()] |tg= TREE_GRAMMAR )
int alt3=4;
switch ( input.LA(1) ) {
case LEXER:
{
alt3=1;
}
break;
case PARSER:
{
alt3=2;
}
break;
case GRAMMAR:
{
alt3=3;
}
break;
case TREE_GRAMMAR:
{
alt3=4;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 3, 0, input);
throw nvae;
}
switch (alt3) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:158:9: t= LEXER g= GRAMMAR
{
t=(Token)match(input,LEXER,FOLLOW_LEXER_in_grammarType683);
stream_LEXER.add(t);
g=(Token)match(input,GRAMMAR,FOLLOW_GRAMMAR_in_grammarType687);
stream_GRAMMAR.add(g);
// AST REWRITE
// elements: GRAMMAR
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 158:28: -> GRAMMAR[$g, \"LEXER_GRAMMAR\", getTokenStream()]
{
adaptor.addChild(root_0, new GrammarRootAST(GRAMMAR, g, "LEXER_GRAMMAR", getTokenStream()));
}
retval.tree = root_0;
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:160:6: t= PARSER g= GRAMMAR
{
t=(Token)match(input,PARSER,FOLLOW_PARSER_in_grammarType710);
stream_PARSER.add(t);
g=(Token)match(input,GRAMMAR,FOLLOW_GRAMMAR_in_grammarType714);
stream_GRAMMAR.add(g);
// AST REWRITE
// elements: GRAMMAR
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 160:25: -> GRAMMAR[$g, \"PARSER_GRAMMAR\", getTokenStream()]
{
adaptor.addChild(root_0, new GrammarRootAST(GRAMMAR, g, "PARSER_GRAMMAR", getTokenStream()));
}
retval.tree = root_0;
}
break;
case 3 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:163:6: g= GRAMMAR
{
g=(Token)match(input,GRAMMAR,FOLLOW_GRAMMAR_in_grammarType735);
stream_GRAMMAR.add(g);
// AST REWRITE
// elements: GRAMMAR
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 163:25: -> GRAMMAR[$g, \"COMBINED_GRAMMAR\", getTokenStream()]
{
adaptor.addChild(root_0, new GrammarRootAST(GRAMMAR, g, "COMBINED_GRAMMAR", getTokenStream()));
}
retval.tree = root_0;
}
break;
case 4 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:164:7: tg= TREE_GRAMMAR
{
tg=(Token)match(input,TREE_GRAMMAR,FOLLOW_TREE_GRAMMAR_in_grammarType762);
stream_TREE_GRAMMAR.add(tg);
}
break;
}
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
if ( tg!=null ) throw new v3TreeGrammarException(tg);
if ( t!=null ) ((GrammarRootAST)retval.tree).grammarType = (t!=null?t.getType():0);
else ((GrammarRootAST)retval.tree).grammarType=COMBINED;
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "grammarType"
public static class prequelConstruct_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "prequelConstruct"
// org\\antlr\\v4\\parse\\ANTLRParser.g:172:1: prequelConstruct : ( optionsSpec | delegateGrammars | tokensSpec | channelsSpec | action );
public final ANTLRParser.prequelConstruct_return prequelConstruct() throws RecognitionException {
ANTLRParser.prequelConstruct_return retval = new ANTLRParser.prequelConstruct_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
ParserRuleReturnScope optionsSpec10 =null;
ParserRuleReturnScope delegateGrammars11 =null;
ParserRuleReturnScope tokensSpec12 =null;
ParserRuleReturnScope channelsSpec13 =null;
ParserRuleReturnScope action14 =null;
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:173:2: ( optionsSpec | delegateGrammars | tokensSpec | channelsSpec | action )
int alt4=5;
switch ( input.LA(1) ) {
case OPTIONS:
{
alt4=1;
}
break;
case IMPORT:
{
alt4=2;
}
break;
case TOKENS_SPEC:
{
alt4=3;
}
break;
case CHANNELS:
{
alt4=4;
}
break;
case AT:
{
alt4=5;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 4, 0, input);
throw nvae;
}
switch (alt4) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:174:4: optionsSpec
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_optionsSpec_in_prequelConstruct788);
optionsSpec10=optionsSpec();
state._fsp--;
adaptor.addChild(root_0, optionsSpec10.getTree());
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:178:7: delegateGrammars
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_delegateGrammars_in_prequelConstruct811);
delegateGrammars11=delegateGrammars();
state._fsp--;
adaptor.addChild(root_0, delegateGrammars11.getTree());
}
break;
case 3 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:185:7: tokensSpec
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_tokensSpec_in_prequelConstruct855);
tokensSpec12=tokensSpec();
state._fsp--;
adaptor.addChild(root_0, tokensSpec12.getTree());
}
break;
case 4 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:188:4: channelsSpec
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_channelsSpec_in_prequelConstruct865);
channelsSpec13=channelsSpec();
state._fsp--;
adaptor.addChild(root_0, channelsSpec13.getTree());
}
break;
case 5 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:194:7: action
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_action_in_prequelConstruct902);
action14=action();
state._fsp--;
adaptor.addChild(root_0, action14.getTree());
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "prequelConstruct"
public static class optionsSpec_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "optionsSpec"
// org\\antlr\\v4\\parse\\ANTLRParser.g:198:1: optionsSpec : OPTIONS ( option SEMI )* RBRACE -> ^( OPTIONS[$OPTIONS, \"OPTIONS\"] ( option )* ) ;
public final ANTLRParser.optionsSpec_return optionsSpec() throws RecognitionException {
ANTLRParser.optionsSpec_return retval = new ANTLRParser.optionsSpec_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token OPTIONS15=null;
Token SEMI17=null;
Token RBRACE18=null;
ParserRuleReturnScope option16 =null;
GrammarAST OPTIONS15_tree=null;
GrammarAST SEMI17_tree=null;
GrammarAST RBRACE18_tree=null;
RewriteRuleTokenStream stream_RBRACE=new RewriteRuleTokenStream(adaptor,"token RBRACE");
RewriteRuleTokenStream stream_SEMI=new RewriteRuleTokenStream(adaptor,"token SEMI");
RewriteRuleTokenStream stream_OPTIONS=new RewriteRuleTokenStream(adaptor,"token OPTIONS");
RewriteRuleSubtreeStream stream_option=new RewriteRuleSubtreeStream(adaptor,"rule option");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:199:2: ( OPTIONS ( option SEMI )* RBRACE -> ^( OPTIONS[$OPTIONS, \"OPTIONS\"] ( option )* ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:199:4: OPTIONS ( option SEMI )* RBRACE
{
OPTIONS15=(Token)match(input,OPTIONS,FOLLOW_OPTIONS_in_optionsSpec917);
stream_OPTIONS.add(OPTIONS15);
// org\\antlr\\v4\\parse\\ANTLRParser.g:199:12: ( option SEMI )*
loop5:
while (true) {
int alt5=2;
int LA5_0 = input.LA(1);
if ( (LA5_0==RULE_REF||LA5_0==TOKEN_REF) ) {
alt5=1;
}
switch (alt5) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:199:13: option SEMI
{
pushFollow(FOLLOW_option_in_optionsSpec920);
option16=option();
state._fsp--;
stream_option.add(option16.getTree());
SEMI17=(Token)match(input,SEMI,FOLLOW_SEMI_in_optionsSpec922);
stream_SEMI.add(SEMI17);
}
break;
default :
break loop5;
}
}
RBRACE18=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_optionsSpec926);
stream_RBRACE.add(RBRACE18);
// AST REWRITE
// elements: OPTIONS, option
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 199:34: -> ^( OPTIONS[$OPTIONS, \"OPTIONS\"] ( option )* )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:199:37: ^( OPTIONS[$OPTIONS, \"OPTIONS\"] ( option )* )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot((GrammarAST)adaptor.create(OPTIONS, OPTIONS15, "OPTIONS"), root_1);
// org\\antlr\\v4\\parse\\ANTLRParser.g:199:68: ( option )*
while ( stream_option.hasNext() ) {
adaptor.addChild(root_1, stream_option.nextTree());
}
stream_option.reset();
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "optionsSpec"
public static class option_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "option"
// org\\antlr\\v4\\parse\\ANTLRParser.g:202:1: option : id ASSIGN ^ optionValue ;
public final ANTLRParser.option_return option() throws RecognitionException {
ANTLRParser.option_return retval = new ANTLRParser.option_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token ASSIGN20=null;
ParserRuleReturnScope id19 =null;
ParserRuleReturnScope optionValue21 =null;
GrammarAST ASSIGN20_tree=null;
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:203:5: ( id ASSIGN ^ optionValue )
// org\\antlr\\v4\\parse\\ANTLRParser.g:203:9: id ASSIGN ^ optionValue
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_id_in_option955);
id19=id();
state._fsp--;
adaptor.addChild(root_0, id19.getTree());
ASSIGN20=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_option957);
ASSIGN20_tree = (GrammarAST)adaptor.create(ASSIGN20);
root_0 = (GrammarAST)adaptor.becomeRoot(ASSIGN20_tree, root_0);
pushFollow(FOLLOW_optionValue_in_option960);
optionValue21=optionValue();
state._fsp--;
adaptor.addChild(root_0, optionValue21.getTree());
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "option"
public static class optionValue_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "optionValue"
// org\\antlr\\v4\\parse\\ANTLRParser.g:211:1: optionValue : ( qid | STRING_LITERAL | ACTION | INT );
public final ANTLRParser.optionValue_return optionValue() throws RecognitionException {
ANTLRParser.optionValue_return retval = new ANTLRParser.optionValue_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token STRING_LITERAL23=null;
Token ACTION24=null;
Token INT25=null;
ParserRuleReturnScope qid22 =null;
GrammarAST STRING_LITERAL23_tree=null;
GrammarAST ACTION24_tree=null;
GrammarAST INT25_tree=null;
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:212:5: ( qid | STRING_LITERAL | ACTION | INT )
int alt6=4;
switch ( input.LA(1) ) {
case RULE_REF:
case TOKEN_REF:
{
alt6=1;
}
break;
case STRING_LITERAL:
{
alt6=2;
}
break;
case ACTION:
{
alt6=3;
}
break;
case INT:
{
alt6=4;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 6, 0, input);
throw nvae;
}
switch (alt6) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:215:7: qid
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_qid_in_optionValue1003);
qid22=qid();
state._fsp--;
adaptor.addChild(root_0, qid22.getTree());
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:216:7: STRING_LITERAL
{
root_0 = (GrammarAST)adaptor.nil();
STRING_LITERAL23=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_optionValue1011);
STRING_LITERAL23_tree = (GrammarAST)adaptor.create(STRING_LITERAL23);
adaptor.addChild(root_0, STRING_LITERAL23_tree);
}
break;
case 3 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:217:4: ACTION
{
root_0 = (GrammarAST)adaptor.nil();
ACTION24=(Token)match(input,ACTION,FOLLOW_ACTION_in_optionValue1016);
ACTION24_tree = new ActionAST(ACTION24) ;
adaptor.addChild(root_0, ACTION24_tree);
}
break;
case 4 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:218:7: INT
{
root_0 = (GrammarAST)adaptor.nil();
INT25=(Token)match(input,INT,FOLLOW_INT_in_optionValue1027);
INT25_tree = (GrammarAST)adaptor.create(INT25);
adaptor.addChild(root_0, INT25_tree);
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "optionValue"
public static class delegateGrammars_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "delegateGrammars"
// org\\antlr\\v4\\parse\\ANTLRParser.g:223:1: delegateGrammars : IMPORT delegateGrammar ( COMMA delegateGrammar )* SEMI -> ^( IMPORT ( delegateGrammar )+ ) ;
public final ANTLRParser.delegateGrammars_return delegateGrammars() throws RecognitionException {
ANTLRParser.delegateGrammars_return retval = new ANTLRParser.delegateGrammars_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token IMPORT26=null;
Token COMMA28=null;
Token SEMI30=null;
ParserRuleReturnScope delegateGrammar27 =null;
ParserRuleReturnScope delegateGrammar29 =null;
GrammarAST IMPORT26_tree=null;
GrammarAST COMMA28_tree=null;
GrammarAST SEMI30_tree=null;
RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
RewriteRuleTokenStream stream_IMPORT=new RewriteRuleTokenStream(adaptor,"token IMPORT");
RewriteRuleTokenStream stream_SEMI=new RewriteRuleTokenStream(adaptor,"token SEMI");
RewriteRuleSubtreeStream stream_delegateGrammar=new RewriteRuleSubtreeStream(adaptor,"rule delegateGrammar");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:224:2: ( IMPORT delegateGrammar ( COMMA delegateGrammar )* SEMI -> ^( IMPORT ( delegateGrammar )+ ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:224:4: IMPORT delegateGrammar ( COMMA delegateGrammar )* SEMI
{
IMPORT26=(Token)match(input,IMPORT,FOLLOW_IMPORT_in_delegateGrammars1043);
stream_IMPORT.add(IMPORT26);
pushFollow(FOLLOW_delegateGrammar_in_delegateGrammars1045);
delegateGrammar27=delegateGrammar();
state._fsp--;
stream_delegateGrammar.add(delegateGrammar27.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:224:27: ( COMMA delegateGrammar )*
loop7:
while (true) {
int alt7=2;
int LA7_0 = input.LA(1);
if ( (LA7_0==COMMA) ) {
alt7=1;
}
switch (alt7) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:224:28: COMMA delegateGrammar
{
COMMA28=(Token)match(input,COMMA,FOLLOW_COMMA_in_delegateGrammars1048);
stream_COMMA.add(COMMA28);
pushFollow(FOLLOW_delegateGrammar_in_delegateGrammars1050);
delegateGrammar29=delegateGrammar();
state._fsp--;
stream_delegateGrammar.add(delegateGrammar29.getTree());
}
break;
default :
break loop7;
}
}
SEMI30=(Token)match(input,SEMI,FOLLOW_SEMI_in_delegateGrammars1054);
stream_SEMI.add(SEMI30);
// AST REWRITE
// elements: IMPORT, delegateGrammar
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 224:57: -> ^( IMPORT ( delegateGrammar )+ )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:224:60: ^( IMPORT ( delegateGrammar )+ )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot(stream_IMPORT.nextNode(), root_1);
if ( !(stream_delegateGrammar.hasNext()) ) {
throw new RewriteEarlyExitException();
}
while ( stream_delegateGrammar.hasNext() ) {
adaptor.addChild(root_1, stream_delegateGrammar.nextTree());
}
stream_delegateGrammar.reset();
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "delegateGrammars"
public static class delegateGrammar_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "delegateGrammar"
// org\\antlr\\v4\\parse\\ANTLRParser.g:229:1: delegateGrammar : ( id ASSIGN ^ id | id );
public final ANTLRParser.delegateGrammar_return delegateGrammar() throws RecognitionException {
ANTLRParser.delegateGrammar_return retval = new ANTLRParser.delegateGrammar_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token ASSIGN32=null;
ParserRuleReturnScope id31 =null;
ParserRuleReturnScope id33 =null;
ParserRuleReturnScope id34 =null;
GrammarAST ASSIGN32_tree=null;
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:230:5: ( id ASSIGN ^ id | id )
int alt8=2;
int LA8_0 = input.LA(1);
if ( (LA8_0==RULE_REF) ) {
int LA8_1 = input.LA(2);
if ( (LA8_1==ASSIGN) ) {
alt8=1;
}
else if ( (LA8_1==COMMA||LA8_1==SEMI) ) {
alt8=2;
}
else {
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 8, 1, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
else if ( (LA8_0==TOKEN_REF) ) {
int LA8_2 = input.LA(2);
if ( (LA8_2==ASSIGN) ) {
alt8=1;
}
else if ( (LA8_2==COMMA||LA8_2==SEMI) ) {
alt8=2;
}
else {
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 8, 2, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
else {
NoViableAltException nvae =
new NoViableAltException("", 8, 0, input);
throw nvae;
}
switch (alt8) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:230:9: id ASSIGN ^ id
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_id_in_delegateGrammar1081);
id31=id();
state._fsp--;
adaptor.addChild(root_0, id31.getTree());
ASSIGN32=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_delegateGrammar1083);
ASSIGN32_tree = (GrammarAST)adaptor.create(ASSIGN32);
root_0 = (GrammarAST)adaptor.becomeRoot(ASSIGN32_tree, root_0);
pushFollow(FOLLOW_id_in_delegateGrammar1086);
id33=id();
state._fsp--;
adaptor.addChild(root_0, id33.getTree());
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:231:9: id
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_id_in_delegateGrammar1096);
id34=id();
state._fsp--;
adaptor.addChild(root_0, id34.getTree());
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "delegateGrammar"
public static class tokensSpec_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "tokensSpec"
// org\\antlr\\v4\\parse\\ANTLRParser.g:234:1: tokensSpec : ( TOKENS_SPEC id ( COMMA id )* ( COMMA )? RBRACE -> ^( TOKENS_SPEC ( id )+ ) | TOKENS_SPEC RBRACE ->| TOKENS_SPEC ^ ( v3tokenSpec )+ RBRACE !);
public final ANTLRParser.tokensSpec_return tokensSpec() throws RecognitionException {
ANTLRParser.tokensSpec_return retval = new ANTLRParser.tokensSpec_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token TOKENS_SPEC35=null;
Token COMMA37=null;
Token COMMA39=null;
Token RBRACE40=null;
Token TOKENS_SPEC41=null;
Token RBRACE42=null;
Token TOKENS_SPEC43=null;
Token RBRACE45=null;
ParserRuleReturnScope id36 =null;
ParserRuleReturnScope id38 =null;
ParserRuleReturnScope v3tokenSpec44 =null;
GrammarAST TOKENS_SPEC35_tree=null;
GrammarAST COMMA37_tree=null;
GrammarAST COMMA39_tree=null;
GrammarAST RBRACE40_tree=null;
GrammarAST TOKENS_SPEC41_tree=null;
GrammarAST RBRACE42_tree=null;
GrammarAST TOKENS_SPEC43_tree=null;
GrammarAST RBRACE45_tree=null;
RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
RewriteRuleTokenStream stream_RBRACE=new RewriteRuleTokenStream(adaptor,"token RBRACE");
RewriteRuleTokenStream stream_TOKENS_SPEC=new RewriteRuleTokenStream(adaptor,"token TOKENS_SPEC");
RewriteRuleSubtreeStream stream_id=new RewriteRuleSubtreeStream(adaptor,"rule id");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:235:2: ( TOKENS_SPEC id ( COMMA id )* ( COMMA )? RBRACE -> ^( TOKENS_SPEC ( id )+ ) | TOKENS_SPEC RBRACE ->| TOKENS_SPEC ^ ( v3tokenSpec )+ RBRACE !)
int alt12=3;
int LA12_0 = input.LA(1);
if ( (LA12_0==TOKENS_SPEC) ) {
switch ( input.LA(2) ) {
case RBRACE:
{
alt12=2;
}
break;
case RULE_REF:
{
int LA12_3 = input.LA(3);
if ( (LA12_3==COMMA||LA12_3==RBRACE) ) {
alt12=1;
}
else if ( (LA12_3==ASSIGN||LA12_3==SEMI) ) {
alt12=3;
}
else {
int nvaeMark = input.mark();
try {
for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) {
input.consume();
}
NoViableAltException nvae =
new NoViableAltException("", 12, 3, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case TOKEN_REF:
{
int LA12_4 = input.LA(3);
if ( (LA12_4==COMMA||LA12_4==RBRACE) ) {
alt12=1;
}
else if ( (LA12_4==ASSIGN||LA12_4==SEMI) ) {
alt12=3;
}
else {
int nvaeMark = input.mark();
try {
for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) {
input.consume();
}
NoViableAltException nvae =
new NoViableAltException("", 12, 4, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
default:
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 12, 1, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
else {
NoViableAltException nvae =
new NoViableAltException("", 12, 0, input);
throw nvae;
}
switch (alt12) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:235:4: TOKENS_SPEC id ( COMMA id )* ( COMMA )? RBRACE
{
TOKENS_SPEC35=(Token)match(input,TOKENS_SPEC,FOLLOW_TOKENS_SPEC_in_tokensSpec1110);
stream_TOKENS_SPEC.add(TOKENS_SPEC35);
pushFollow(FOLLOW_id_in_tokensSpec1112);
id36=id();
state._fsp--;
stream_id.add(id36.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:235:19: ( COMMA id )*
loop9:
while (true) {
int alt9=2;
int LA9_0 = input.LA(1);
if ( (LA9_0==COMMA) ) {
int LA9_1 = input.LA(2);
if ( (LA9_1==RULE_REF||LA9_1==TOKEN_REF) ) {
alt9=1;
}
}
switch (alt9) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:235:20: COMMA id
{
COMMA37=(Token)match(input,COMMA,FOLLOW_COMMA_in_tokensSpec1115);
stream_COMMA.add(COMMA37);
pushFollow(FOLLOW_id_in_tokensSpec1117);
id38=id();
state._fsp--;
stream_id.add(id38.getTree());
}
break;
default :
break loop9;
}
}
// org\\antlr\\v4\\parse\\ANTLRParser.g:235:31: ( COMMA )?
int alt10=2;
int LA10_0 = input.LA(1);
if ( (LA10_0==COMMA) ) {
alt10=1;
}
switch (alt10) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:235:31: COMMA
{
COMMA39=(Token)match(input,COMMA,FOLLOW_COMMA_in_tokensSpec1121);
stream_COMMA.add(COMMA39);
}
break;
}
RBRACE40=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_tokensSpec1124);
stream_RBRACE.add(RBRACE40);
// AST REWRITE
// elements: TOKENS_SPEC, id
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 235:45: -> ^( TOKENS_SPEC ( id )+ )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:235:48: ^( TOKENS_SPEC ( id )+ )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot(stream_TOKENS_SPEC.nextNode(), root_1);
if ( !(stream_id.hasNext()) ) {
throw new RewriteEarlyExitException();
}
while ( stream_id.hasNext() ) {
adaptor.addChild(root_1, stream_id.nextTree());
}
stream_id.reset();
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:236:7: TOKENS_SPEC RBRACE
{
TOKENS_SPEC41=(Token)match(input,TOKENS_SPEC,FOLLOW_TOKENS_SPEC_in_tokensSpec1141);
stream_TOKENS_SPEC.add(TOKENS_SPEC41);
RBRACE42=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_tokensSpec1143);
stream_RBRACE.add(RBRACE42);
// AST REWRITE
// elements:
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 236:26: ->
{
root_0 = null;
}
retval.tree = root_0;
}
break;
case 3 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:237:7: TOKENS_SPEC ^ ( v3tokenSpec )+ RBRACE !
{
root_0 = (GrammarAST)adaptor.nil();
TOKENS_SPEC43=(Token)match(input,TOKENS_SPEC,FOLLOW_TOKENS_SPEC_in_tokensSpec1153);
TOKENS_SPEC43_tree = (GrammarAST)adaptor.create(TOKENS_SPEC43);
root_0 = (GrammarAST)adaptor.becomeRoot(TOKENS_SPEC43_tree, root_0);
// org\\antlr\\v4\\parse\\ANTLRParser.g:237:20: ( v3tokenSpec )+
int cnt11=0;
loop11:
while (true) {
int alt11=2;
int LA11_0 = input.LA(1);
if ( (LA11_0==RULE_REF||LA11_0==TOKEN_REF) ) {
alt11=1;
}
switch (alt11) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:237:20: v3tokenSpec
{
pushFollow(FOLLOW_v3tokenSpec_in_tokensSpec1156);
v3tokenSpec44=v3tokenSpec();
state._fsp--;
adaptor.addChild(root_0, v3tokenSpec44.getTree());
}
break;
default :
if ( cnt11 >= 1 ) break loop11;
EarlyExitException eee = new EarlyExitException(11, input);
throw eee;
}
cnt11++;
}
RBRACE45=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_tokensSpec1159);
grammarError(ErrorType.V3_TOKENS_SYNTAX, TOKENS_SPEC43);
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "tokensSpec"
public static class v3tokenSpec_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "v3tokenSpec"
// org\\antlr\\v4\\parse\\ANTLRParser.g:241:1: v3tokenSpec : id ( ASSIGN lit= STRING_LITERAL -> id | -> id ) SEMI ;
public final ANTLRParser.v3tokenSpec_return v3tokenSpec() throws RecognitionException {
ANTLRParser.v3tokenSpec_return retval = new ANTLRParser.v3tokenSpec_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token lit=null;
Token ASSIGN47=null;
Token SEMI48=null;
ParserRuleReturnScope id46 =null;
GrammarAST lit_tree=null;
GrammarAST ASSIGN47_tree=null;
GrammarAST SEMI48_tree=null;
RewriteRuleTokenStream stream_SEMI=new RewriteRuleTokenStream(adaptor,"token SEMI");
RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL");
RewriteRuleTokenStream stream_ASSIGN=new RewriteRuleTokenStream(adaptor,"token ASSIGN");
RewriteRuleSubtreeStream stream_id=new RewriteRuleSubtreeStream(adaptor,"rule id");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:242:2: ( id ( ASSIGN lit= STRING_LITERAL -> id | -> id ) SEMI )
// org\\antlr\\v4\\parse\\ANTLRParser.g:242:4: id ( ASSIGN lit= STRING_LITERAL -> id | -> id ) SEMI
{
pushFollow(FOLLOW_id_in_v3tokenSpec1179);
id46=id();
state._fsp--;
stream_id.add(id46.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:243:3: ( ASSIGN lit= STRING_LITERAL -> id | -> id )
int alt13=2;
int LA13_0 = input.LA(1);
if ( (LA13_0==ASSIGN) ) {
alt13=1;
}
else if ( (LA13_0==SEMI) ) {
alt13=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 13, 0, input);
throw nvae;
}
switch (alt13) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:243:5: ASSIGN lit= STRING_LITERAL
{
ASSIGN47=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_v3tokenSpec1185);
stream_ASSIGN.add(ASSIGN47);
lit=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_v3tokenSpec1189);
stream_STRING_LITERAL.add(lit);
grammarError(ErrorType.V3_ASSIGN_IN_TOKENS, (id46!=null?(id46.start):null),
(id46!=null?input.toString(id46.start,id46.stop):null), lit.getText());
// AST REWRITE
// elements: id
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 248:20: -> id
{
adaptor.addChild(root_0, stream_id.nextTree());
}
retval.tree = root_0;
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:249:12:
{
// AST REWRITE
// elements: id
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 249:12: -> id
{
adaptor.addChild(root_0, stream_id.nextTree());
}
retval.tree = root_0;
}
break;
}
SEMI48=(Token)match(input,SEMI,FOLLOW_SEMI_in_v3tokenSpec1250);
stream_SEMI.add(SEMI48);
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "v3tokenSpec"
public static class channelsSpec_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "channelsSpec"
// org\\antlr\\v4\\parse\\ANTLRParser.g:254:1: channelsSpec : CHANNELS ^ ( id ( COMMA ! id )* ( COMMA )? )? RBRACE !;
public final ANTLRParser.channelsSpec_return channelsSpec() throws RecognitionException {
ANTLRParser.channelsSpec_return retval = new ANTLRParser.channelsSpec_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token CHANNELS49=null;
Token COMMA51=null;
Token COMMA53=null;
Token RBRACE54=null;
ParserRuleReturnScope id50 =null;
ParserRuleReturnScope id52 =null;
GrammarAST CHANNELS49_tree=null;
GrammarAST COMMA51_tree=null;
GrammarAST COMMA53_tree=null;
GrammarAST RBRACE54_tree=null;
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:255:2: ( CHANNELS ^ ( id ( COMMA ! id )* ( COMMA )? )? RBRACE !)
// org\\antlr\\v4\\parse\\ANTLRParser.g:255:4: CHANNELS ^ ( id ( COMMA ! id )* ( COMMA )? )? RBRACE !
{
root_0 = (GrammarAST)adaptor.nil();
CHANNELS49=(Token)match(input,CHANNELS,FOLLOW_CHANNELS_in_channelsSpec1261);
CHANNELS49_tree = (GrammarAST)adaptor.create(CHANNELS49);
root_0 = (GrammarAST)adaptor.becomeRoot(CHANNELS49_tree, root_0);
// org\\antlr\\v4\\parse\\ANTLRParser.g:255:14: ( id ( COMMA ! id )* ( COMMA )? )?
int alt16=2;
int LA16_0 = input.LA(1);
if ( (LA16_0==RULE_REF||LA16_0==TOKEN_REF) ) {
alt16=1;
}
switch (alt16) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:255:15: id ( COMMA ! id )* ( COMMA )?
{
pushFollow(FOLLOW_id_in_channelsSpec1265);
id50=id();
state._fsp--;
adaptor.addChild(root_0, id50.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:255:18: ( COMMA ! id )*
loop14:
while (true) {
int alt14=2;
int LA14_0 = input.LA(1);
if ( (LA14_0==COMMA) ) {
int LA14_1 = input.LA(2);
if ( (LA14_1==RULE_REF||LA14_1==TOKEN_REF) ) {
alt14=1;
}
}
switch (alt14) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:255:19: COMMA ! id
{
COMMA51=(Token)match(input,COMMA,FOLLOW_COMMA_in_channelsSpec1268);
pushFollow(FOLLOW_id_in_channelsSpec1271);
id52=id();
state._fsp--;
adaptor.addChild(root_0, id52.getTree());
}
break;
default :
break loop14;
}
}
// org\\antlr\\v4\\parse\\ANTLRParser.g:255:31: ( COMMA )?
int alt15=2;
int LA15_0 = input.LA(1);
if ( (LA15_0==COMMA) ) {
alt15=1;
}
switch (alt15) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:255:31: COMMA
{
COMMA53=(Token)match(input,COMMA,FOLLOW_COMMA_in_channelsSpec1275);
COMMA53_tree = (GrammarAST)adaptor.create(COMMA53);
adaptor.addChild(root_0, COMMA53_tree);
}
break;
}
}
break;
}
RBRACE54=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_channelsSpec1280);
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "channelsSpec"
public static class action_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "action"
// org\\antlr\\v4\\parse\\ANTLRParser.g:262:1: action : AT ( actionScopeName COLONCOLON )? id ACTION -> ^( AT ( actionScopeName )? id ACTION ) ;
public final ANTLRParser.action_return action() throws RecognitionException {
ANTLRParser.action_return retval = new ANTLRParser.action_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token AT55=null;
Token COLONCOLON57=null;
Token ACTION59=null;
ParserRuleReturnScope actionScopeName56 =null;
ParserRuleReturnScope id58 =null;
GrammarAST AT55_tree=null;
GrammarAST COLONCOLON57_tree=null;
GrammarAST ACTION59_tree=null;
RewriteRuleTokenStream stream_AT=new RewriteRuleTokenStream(adaptor,"token AT");
RewriteRuleTokenStream stream_ACTION=new RewriteRuleTokenStream(adaptor,"token ACTION");
RewriteRuleTokenStream stream_COLONCOLON=new RewriteRuleTokenStream(adaptor,"token COLONCOLON");
RewriteRuleSubtreeStream stream_id=new RewriteRuleSubtreeStream(adaptor,"rule id");
RewriteRuleSubtreeStream stream_actionScopeName=new RewriteRuleSubtreeStream(adaptor,"rule actionScopeName");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:263:2: ( AT ( actionScopeName COLONCOLON )? id ACTION -> ^( AT ( actionScopeName )? id ACTION ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:263:4: AT ( actionScopeName COLONCOLON )? id ACTION
{
AT55=(Token)match(input,AT,FOLLOW_AT_in_action1297);
stream_AT.add(AT55);
// org\\antlr\\v4\\parse\\ANTLRParser.g:263:7: ( actionScopeName COLONCOLON )?
int alt17=2;
switch ( input.LA(1) ) {
case RULE_REF:
{
int LA17_1 = input.LA(2);
if ( (LA17_1==COLONCOLON) ) {
alt17=1;
}
}
break;
case TOKEN_REF:
{
int LA17_2 = input.LA(2);
if ( (LA17_2==COLONCOLON) ) {
alt17=1;
}
}
break;
case LEXER:
case PARSER:
{
alt17=1;
}
break;
}
switch (alt17) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:263:8: actionScopeName COLONCOLON
{
pushFollow(FOLLOW_actionScopeName_in_action1300);
actionScopeName56=actionScopeName();
state._fsp--;
stream_actionScopeName.add(actionScopeName56.getTree());
COLONCOLON57=(Token)match(input,COLONCOLON,FOLLOW_COLONCOLON_in_action1302);
stream_COLONCOLON.add(COLONCOLON57);
}
break;
}
pushFollow(FOLLOW_id_in_action1306);
id58=id();
state._fsp--;
stream_id.add(id58.getTree());
ACTION59=(Token)match(input,ACTION,FOLLOW_ACTION_in_action1308);
stream_ACTION.add(ACTION59);
// AST REWRITE
// elements: actionScopeName, AT, id, ACTION
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 263:47: -> ^( AT ( actionScopeName )? id ACTION )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:263:50: ^( AT ( actionScopeName )? id ACTION )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot(stream_AT.nextNode(), root_1);
// org\\antlr\\v4\\parse\\ANTLRParser.g:263:55: ( actionScopeName )?
if ( stream_actionScopeName.hasNext() ) {
adaptor.addChild(root_1, stream_actionScopeName.nextTree());
}
stream_actionScopeName.reset();
adaptor.addChild(root_1, stream_id.nextTree());
adaptor.addChild(root_1, new ActionAST(stream_ACTION.nextToken()));
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "action"
public static class actionScopeName_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "actionScopeName"
// org\\antlr\\v4\\parse\\ANTLRParser.g:269:1: actionScopeName : ( id | LEXER -> ID[$LEXER] | PARSER -> ID[$PARSER] );
public final ANTLRParser.actionScopeName_return actionScopeName() throws RecognitionException {
ANTLRParser.actionScopeName_return retval = new ANTLRParser.actionScopeName_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token LEXER61=null;
Token PARSER62=null;
ParserRuleReturnScope id60 =null;
GrammarAST LEXER61_tree=null;
GrammarAST PARSER62_tree=null;
RewriteRuleTokenStream stream_PARSER=new RewriteRuleTokenStream(adaptor,"token PARSER");
RewriteRuleTokenStream stream_LEXER=new RewriteRuleTokenStream(adaptor,"token LEXER");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:270:2: ( id | LEXER -> ID[$LEXER] | PARSER -> ID[$PARSER] )
int alt18=3;
switch ( input.LA(1) ) {
case RULE_REF:
case TOKEN_REF:
{
alt18=1;
}
break;
case LEXER:
{
alt18=2;
}
break;
case PARSER:
{
alt18=3;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 18, 0, input);
throw nvae;
}
switch (alt18) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:270:4: id
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_id_in_actionScopeName1337);
id60=id();
state._fsp--;
adaptor.addChild(root_0, id60.getTree());
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:271:4: LEXER
{
LEXER61=(Token)match(input,LEXER,FOLLOW_LEXER_in_actionScopeName1342);
stream_LEXER.add(LEXER61);
// AST REWRITE
// elements:
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 271:10: -> ID[$LEXER]
{
adaptor.addChild(root_0, (GrammarAST)adaptor.create(ID, LEXER61));
}
retval.tree = root_0;
}
break;
case 3 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:272:9: PARSER
{
PARSER62=(Token)match(input,PARSER,FOLLOW_PARSER_in_actionScopeName1357);
stream_PARSER.add(PARSER62);
// AST REWRITE
// elements:
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 272:16: -> ID[$PARSER]
{
adaptor.addChild(root_0, (GrammarAST)adaptor.create(ID, PARSER62));
}
retval.tree = root_0;
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "actionScopeName"
public static class modeSpec_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "modeSpec"
// org\\antlr\\v4\\parse\\ANTLRParser.g:275:1: modeSpec : MODE id SEMI sync ( lexerRule sync )* -> ^( MODE id ( lexerRule )* ) ;
public final ANTLRParser.modeSpec_return modeSpec() throws RecognitionException {
ANTLRParser.modeSpec_return retval = new ANTLRParser.modeSpec_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token MODE63=null;
Token SEMI65=null;
ParserRuleReturnScope id64 =null;
ParserRuleReturnScope sync66 =null;
ParserRuleReturnScope lexerRule67 =null;
ParserRuleReturnScope sync68 =null;
GrammarAST MODE63_tree=null;
GrammarAST SEMI65_tree=null;
RewriteRuleTokenStream stream_MODE=new RewriteRuleTokenStream(adaptor,"token MODE");
RewriteRuleTokenStream stream_SEMI=new RewriteRuleTokenStream(adaptor,"token SEMI");
RewriteRuleSubtreeStream stream_lexerRule=new RewriteRuleSubtreeStream(adaptor,"rule lexerRule");
RewriteRuleSubtreeStream stream_id=new RewriteRuleSubtreeStream(adaptor,"rule id");
RewriteRuleSubtreeStream stream_sync=new RewriteRuleSubtreeStream(adaptor,"rule sync");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:276:5: ( MODE id SEMI sync ( lexerRule sync )* -> ^( MODE id ( lexerRule )* ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:276:7: MODE id SEMI sync ( lexerRule sync )*
{
MODE63=(Token)match(input,MODE,FOLLOW_MODE_in_modeSpec1376);
stream_MODE.add(MODE63);
pushFollow(FOLLOW_id_in_modeSpec1378);
id64=id();
state._fsp--;
stream_id.add(id64.getTree());
SEMI65=(Token)match(input,SEMI,FOLLOW_SEMI_in_modeSpec1380);
stream_SEMI.add(SEMI65);
pushFollow(FOLLOW_sync_in_modeSpec1382);
sync66=sync();
state._fsp--;
stream_sync.add(sync66.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:276:25: ( lexerRule sync )*
loop19:
while (true) {
int alt19=2;
int LA19_0 = input.LA(1);
if ( (LA19_0==FRAGMENT||LA19_0==TOKEN_REF) ) {
alt19=1;
}
switch (alt19) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:276:26: lexerRule sync
{
pushFollow(FOLLOW_lexerRule_in_modeSpec1385);
lexerRule67=lexerRule();
state._fsp--;
stream_lexerRule.add(lexerRule67.getTree());
pushFollow(FOLLOW_sync_in_modeSpec1387);
sync68=sync();
state._fsp--;
stream_sync.add(sync68.getTree());
}
break;
default :
break loop19;
}
}
// AST REWRITE
// elements: lexerRule, id, MODE
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 276:44: -> ^( MODE id ( lexerRule )* )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:276:47: ^( MODE id ( lexerRule )* )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot(stream_MODE.nextNode(), root_1);
adaptor.addChild(root_1, stream_id.nextTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:276:57: ( lexerRule )*
while ( stream_lexerRule.hasNext() ) {
adaptor.addChild(root_1, stream_lexerRule.nextTree());
}
stream_lexerRule.reset();
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "modeSpec"
public static class rules_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "rules"
// org\\antlr\\v4\\parse\\ANTLRParser.g:279:1: rules : sync ( rule sync )* -> ^( RULES ( rule )* ) ;
public final ANTLRParser.rules_return rules() throws RecognitionException {
ANTLRParser.rules_return retval = new ANTLRParser.rules_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
ParserRuleReturnScope sync69 =null;
ParserRuleReturnScope rule70 =null;
ParserRuleReturnScope sync71 =null;
RewriteRuleSubtreeStream stream_rule=new RewriteRuleSubtreeStream(adaptor,"rule rule");
RewriteRuleSubtreeStream stream_sync=new RewriteRuleSubtreeStream(adaptor,"rule sync");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:280:5: ( sync ( rule sync )* -> ^( RULES ( rule )* ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:280:7: sync ( rule sync )*
{
pushFollow(FOLLOW_sync_in_rules1418);
sync69=sync();
state._fsp--;
stream_sync.add(sync69.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:280:12: ( rule sync )*
loop20:
while (true) {
int alt20=2;
int LA20_0 = input.LA(1);
if ( (LA20_0==FRAGMENT||LA20_0==RULE_REF||LA20_0==TOKEN_REF) ) {
alt20=1;
}
switch (alt20) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:280:13: rule sync
{
pushFollow(FOLLOW_rule_in_rules1421);
rule70=rule();
state._fsp--;
stream_rule.add(rule70.getTree());
pushFollow(FOLLOW_sync_in_rules1423);
sync71=sync();
state._fsp--;
stream_sync.add(sync71.getTree());
}
break;
default :
break loop20;
}
}
// AST REWRITE
// elements: rule
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 284:7: -> ^( RULES ( rule )* )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:284:9: ^( RULES ( rule )* )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot((GrammarAST)adaptor.create(RULES, "RULES"), root_1);
// org\\antlr\\v4\\parse\\ANTLRParser.g:284:17: ( rule )*
while ( stream_rule.hasNext() ) {
adaptor.addChild(root_1, stream_rule.nextTree());
}
stream_rule.reset();
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "rules"
public static class sync_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "sync"
// org\\antlr\\v4\\parse\\ANTLRParser.g:287:1: sync :;
public final ANTLRParser.sync_return sync() throws RecognitionException {
ANTLRParser.sync_return retval = new ANTLRParser.sync_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
BitSet followSet = computeErrorRecoverySet();
if ( input.LA(1)!=Token.EOF && !followSet.member(input.LA(1)) ) {
reportError(new NoViableAltException("",0,0,input));
beginResync();
consumeUntil(input, followSet);
endResync();
}
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:296:3: ()
// org\\antlr\\v4\\parse\\ANTLRParser.g:297:2:
{
root_0 = (GrammarAST)adaptor.nil();
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "sync"
public static class rule_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "rule"
// org\\antlr\\v4\\parse\\ANTLRParser.g:299:1: rule : ( parserRule | lexerRule );
public final ANTLRParser.rule_return rule() throws RecognitionException {
ANTLRParser.rule_return retval = new ANTLRParser.rule_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
ParserRuleReturnScope parserRule72 =null;
ParserRuleReturnScope lexerRule73 =null;
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:299:5: ( parserRule | lexerRule )
int alt21=2;
int LA21_0 = input.LA(1);
if ( (LA21_0==RULE_REF) ) {
alt21=1;
}
else if ( (LA21_0==FRAGMENT||LA21_0==TOKEN_REF) ) {
alt21=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 21, 0, input);
throw nvae;
}
switch (alt21) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:299:7: parserRule
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_parserRule_in_rule1485);
parserRule72=parserRule();
state._fsp--;
adaptor.addChild(root_0, parserRule72.getTree());
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:300:4: lexerRule
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_lexerRule_in_rule1490);
lexerRule73=lexerRule();
state._fsp--;
adaptor.addChild(root_0, lexerRule73.getTree());
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "rule"
public static class parserRule_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "parserRule"
// org\\antlr\\v4\\parse\\ANTLRParser.g:312:1: parserRule : RULE_REF ( ARG_ACTION )? ( ruleReturns )? ( throwsSpec )? ( localsSpec )? rulePrequels COLON ruleBlock SEMI exceptionGroup -> ^( RULE RULE_REF ( ARG_ACTION )? ( ruleReturns )? ( throwsSpec )? ( localsSpec )? ( rulePrequels )? ruleBlock ( exceptionGroup )* ) ;
public final ANTLRParser.parserRule_return parserRule() throws RecognitionException {
ANTLRParser.parserRule_return retval = new ANTLRParser.parserRule_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token RULE_REF74=null;
Token ARG_ACTION75=null;
Token COLON80=null;
Token SEMI82=null;
ParserRuleReturnScope ruleReturns76 =null;
ParserRuleReturnScope throwsSpec77 =null;
ParserRuleReturnScope localsSpec78 =null;
ParserRuleReturnScope rulePrequels79 =null;
ParserRuleReturnScope ruleBlock81 =null;
ParserRuleReturnScope exceptionGroup83 =null;
GrammarAST RULE_REF74_tree=null;
GrammarAST ARG_ACTION75_tree=null;
GrammarAST COLON80_tree=null;
GrammarAST SEMI82_tree=null;
RewriteRuleTokenStream stream_ARG_ACTION=new RewriteRuleTokenStream(adaptor,"token ARG_ACTION");
RewriteRuleTokenStream stream_SEMI=new RewriteRuleTokenStream(adaptor,"token SEMI");
RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON");
RewriteRuleTokenStream stream_RULE_REF=new RewriteRuleTokenStream(adaptor,"token RULE_REF");
RewriteRuleSubtreeStream stream_throwsSpec=new RewriteRuleSubtreeStream(adaptor,"rule throwsSpec");
RewriteRuleSubtreeStream stream_localsSpec=new RewriteRuleSubtreeStream(adaptor,"rule localsSpec");
RewriteRuleSubtreeStream stream_ruleBlock=new RewriteRuleSubtreeStream(adaptor,"rule ruleBlock");
RewriteRuleSubtreeStream stream_ruleReturns=new RewriteRuleSubtreeStream(adaptor,"rule ruleReturns");
RewriteRuleSubtreeStream stream_rulePrequels=new RewriteRuleSubtreeStream(adaptor,"rule rulePrequels");
RewriteRuleSubtreeStream stream_exceptionGroup=new RewriteRuleSubtreeStream(adaptor,"rule exceptionGroup");
paraphrases.push("matching a rule");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:321:5: ( RULE_REF ( ARG_ACTION )? ( ruleReturns )? ( throwsSpec )? ( localsSpec )? rulePrequels COLON ruleBlock SEMI exceptionGroup -> ^( RULE RULE_REF ( ARG_ACTION )? ( ruleReturns )? ( throwsSpec )? ( localsSpec )? ( rulePrequels )? ruleBlock ( exceptionGroup )* ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:325:4: RULE_REF ( ARG_ACTION )? ( ruleReturns )? ( throwsSpec )? ( localsSpec )? rulePrequels COLON ruleBlock SEMI exceptionGroup
{
RULE_REF74=(Token)match(input,RULE_REF,FOLLOW_RULE_REF_in_parserRule1539);
stream_RULE_REF.add(RULE_REF74);
// org\\antlr\\v4\\parse\\ANTLRParser.g:333:4: ( ARG_ACTION )?
int alt22=2;
int LA22_0 = input.LA(1);
if ( (LA22_0==ARG_ACTION) ) {
alt22=1;
}
switch (alt22) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:333:4: ARG_ACTION
{
ARG_ACTION75=(Token)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_parserRule1569);
stream_ARG_ACTION.add(ARG_ACTION75);
}
break;
}
// org\\antlr\\v4\\parse\\ANTLRParser.g:335:4: ( ruleReturns )?
int alt23=2;
int LA23_0 = input.LA(1);
if ( (LA23_0==RETURNS) ) {
alt23=1;
}
switch (alt23) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:335:4: ruleReturns
{
pushFollow(FOLLOW_ruleReturns_in_parserRule1576);
ruleReturns76=ruleReturns();
state._fsp--;
stream_ruleReturns.add(ruleReturns76.getTree());
}
break;
}
// org\\antlr\\v4\\parse\\ANTLRParser.g:337:4: ( throwsSpec )?
int alt24=2;
int LA24_0 = input.LA(1);
if ( (LA24_0==THROWS) ) {
alt24=1;
}
switch (alt24) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:337:4: throwsSpec
{
pushFollow(FOLLOW_throwsSpec_in_parserRule1583);
throwsSpec77=throwsSpec();
state._fsp--;
stream_throwsSpec.add(throwsSpec77.getTree());
}
break;
}
// org\\antlr\\v4\\parse\\ANTLRParser.g:339:4: ( localsSpec )?
int alt25=2;
int LA25_0 = input.LA(1);
if ( (LA25_0==LOCALS) ) {
alt25=1;
}
switch (alt25) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:339:4: localsSpec
{
pushFollow(FOLLOW_localsSpec_in_parserRule1590);
localsSpec78=localsSpec();
state._fsp--;
stream_localsSpec.add(localsSpec78.getTree());
}
break;
}
pushFollow(FOLLOW_rulePrequels_in_parserRule1628);
rulePrequels79=rulePrequels();
state._fsp--;
stream_rulePrequels.add(rulePrequels79.getTree());
COLON80=(Token)match(input,COLON,FOLLOW_COLON_in_parserRule1637);
stream_COLON.add(COLON80);
pushFollow(FOLLOW_ruleBlock_in_parserRule1660);
ruleBlock81=ruleBlock();
state._fsp--;
stream_ruleBlock.add(ruleBlock81.getTree());
SEMI82=(Token)match(input,SEMI,FOLLOW_SEMI_in_parserRule1669);
stream_SEMI.add(SEMI82);
pushFollow(FOLLOW_exceptionGroup_in_parserRule1678);
exceptionGroup83=exceptionGroup();
state._fsp--;
stream_exceptionGroup.add(exceptionGroup83.getTree());
// AST REWRITE
// elements: RULE_REF, ruleBlock, ruleReturns, rulePrequels, throwsSpec, ARG_ACTION, localsSpec, exceptionGroup
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 366:7: -> ^( RULE RULE_REF ( ARG_ACTION )? ( ruleReturns )? ( throwsSpec )? ( localsSpec )? ( rulePrequels )? ruleBlock ( exceptionGroup )* )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:366:10: ^( RULE RULE_REF ( ARG_ACTION )? ( ruleReturns )? ( throwsSpec )? ( localsSpec )? ( rulePrequels )? ruleBlock ( exceptionGroup )* )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot(new RuleAST(RULE), root_1);
adaptor.addChild(root_1, stream_RULE_REF.nextNode());
// org\\antlr\\v4\\parse\\ANTLRParser.g:366:36: ( ARG_ACTION )?
if ( stream_ARG_ACTION.hasNext() ) {
adaptor.addChild(root_1, new ActionAST(stream_ARG_ACTION.nextToken()));
}
stream_ARG_ACTION.reset();
// org\\antlr\\v4\\parse\\ANTLRParser.g:367:9: ( ruleReturns )?
if ( stream_ruleReturns.hasNext() ) {
adaptor.addChild(root_1, stream_ruleReturns.nextTree());
}
stream_ruleReturns.reset();
// org\\antlr\\v4\\parse\\ANTLRParser.g:367:22: ( throwsSpec )?
if ( stream_throwsSpec.hasNext() ) {
adaptor.addChild(root_1, stream_throwsSpec.nextTree());
}
stream_throwsSpec.reset();
// org\\antlr\\v4\\parse\\ANTLRParser.g:367:34: ( localsSpec )?
if ( stream_localsSpec.hasNext() ) {
adaptor.addChild(root_1, stream_localsSpec.nextTree());
}
stream_localsSpec.reset();
// org\\antlr\\v4\\parse\\ANTLRParser.g:367:46: ( rulePrequels )?
if ( stream_rulePrequels.hasNext() ) {
adaptor.addChild(root_1, stream_rulePrequels.nextTree());
}
stream_rulePrequels.reset();
adaptor.addChild(root_1, stream_ruleBlock.nextTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:367:70: ( exceptionGroup )*
while ( stream_exceptionGroup.hasNext() ) {
adaptor.addChild(root_1, stream_exceptionGroup.nextTree());
}
stream_exceptionGroup.reset();
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
paraphrases.pop();
GrammarAST options = (GrammarAST)retval.tree.getFirstChildWithType(ANTLRParser.OPTIONS);
if ( options!=null ) {
Grammar.setNodeOptions(retval.tree, options);
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "parserRule"
public static class exceptionGroup_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "exceptionGroup"
// org\\antlr\\v4\\parse\\ANTLRParser.g:377:1: exceptionGroup : ( exceptionHandler )* ( finallyClause )? ;
public final ANTLRParser.exceptionGroup_return exceptionGroup() throws RecognitionException {
ANTLRParser.exceptionGroup_return retval = new ANTLRParser.exceptionGroup_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
ParserRuleReturnScope exceptionHandler84 =null;
ParserRuleReturnScope finallyClause85 =null;
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:378:5: ( ( exceptionHandler )* ( finallyClause )? )
// org\\antlr\\v4\\parse\\ANTLRParser.g:378:7: ( exceptionHandler )* ( finallyClause )?
{
root_0 = (GrammarAST)adaptor.nil();
// org\\antlr\\v4\\parse\\ANTLRParser.g:378:7: ( exceptionHandler )*
loop26:
while (true) {
int alt26=2;
int LA26_0 = input.LA(1);
if ( (LA26_0==CATCH) ) {
alt26=1;
}
switch (alt26) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:378:7: exceptionHandler
{
pushFollow(FOLLOW_exceptionHandler_in_exceptionGroup1761);
exceptionHandler84=exceptionHandler();
state._fsp--;
adaptor.addChild(root_0, exceptionHandler84.getTree());
}
break;
default :
break loop26;
}
}
// org\\antlr\\v4\\parse\\ANTLRParser.g:378:25: ( finallyClause )?
int alt27=2;
int LA27_0 = input.LA(1);
if ( (LA27_0==FINALLY) ) {
alt27=1;
}
switch (alt27) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:378:25: finallyClause
{
pushFollow(FOLLOW_finallyClause_in_exceptionGroup1764);
finallyClause85=finallyClause();
state._fsp--;
adaptor.addChild(root_0, finallyClause85.getTree());
}
break;
}
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "exceptionGroup"
public static class exceptionHandler_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "exceptionHandler"
// org\\antlr\\v4\\parse\\ANTLRParser.g:383:1: exceptionHandler : CATCH ARG_ACTION ACTION -> ^( CATCH ARG_ACTION ACTION ) ;
public final ANTLRParser.exceptionHandler_return exceptionHandler() throws RecognitionException {
ANTLRParser.exceptionHandler_return retval = new ANTLRParser.exceptionHandler_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token CATCH86=null;
Token ARG_ACTION87=null;
Token ACTION88=null;
GrammarAST CATCH86_tree=null;
GrammarAST ARG_ACTION87_tree=null;
GrammarAST ACTION88_tree=null;
RewriteRuleTokenStream stream_ACTION=new RewriteRuleTokenStream(adaptor,"token ACTION");
RewriteRuleTokenStream stream_CATCH=new RewriteRuleTokenStream(adaptor,"token CATCH");
RewriteRuleTokenStream stream_ARG_ACTION=new RewriteRuleTokenStream(adaptor,"token ARG_ACTION");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:384:2: ( CATCH ARG_ACTION ACTION -> ^( CATCH ARG_ACTION ACTION ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:384:4: CATCH ARG_ACTION ACTION
{
CATCH86=(Token)match(input,CATCH,FOLLOW_CATCH_in_exceptionHandler1781);
stream_CATCH.add(CATCH86);
ARG_ACTION87=(Token)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_exceptionHandler1783);
stream_ARG_ACTION.add(ARG_ACTION87);
ACTION88=(Token)match(input,ACTION,FOLLOW_ACTION_in_exceptionHandler1785);
stream_ACTION.add(ACTION88);
// AST REWRITE
// elements: ACTION, ARG_ACTION, CATCH
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 384:28: -> ^( CATCH ARG_ACTION ACTION )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:384:31: ^( CATCH ARG_ACTION ACTION )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot(stream_CATCH.nextNode(), root_1);
adaptor.addChild(root_1, new ActionAST(stream_ARG_ACTION.nextToken()));
adaptor.addChild(root_1, new ActionAST(stream_ACTION.nextToken()));
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "exceptionHandler"
public static class finallyClause_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "finallyClause"
// org\\antlr\\v4\\parse\\ANTLRParser.g:387:1: finallyClause : FINALLY ACTION -> ^( FINALLY ACTION ) ;
public final ANTLRParser.finallyClause_return finallyClause() throws RecognitionException {
ANTLRParser.finallyClause_return retval = new ANTLRParser.finallyClause_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token FINALLY89=null;
Token ACTION90=null;
GrammarAST FINALLY89_tree=null;
GrammarAST ACTION90_tree=null;
RewriteRuleTokenStream stream_ACTION=new RewriteRuleTokenStream(adaptor,"token ACTION");
RewriteRuleTokenStream stream_FINALLY=new RewriteRuleTokenStream(adaptor,"token FINALLY");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:388:2: ( FINALLY ACTION -> ^( FINALLY ACTION ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:388:4: FINALLY ACTION
{
FINALLY89=(Token)match(input,FINALLY,FOLLOW_FINALLY_in_finallyClause1812);
stream_FINALLY.add(FINALLY89);
ACTION90=(Token)match(input,ACTION,FOLLOW_ACTION_in_finallyClause1814);
stream_ACTION.add(ACTION90);
// AST REWRITE
// elements: FINALLY, ACTION
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 388:19: -> ^( FINALLY ACTION )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:388:22: ^( FINALLY ACTION )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot(stream_FINALLY.nextNode(), root_1);
adaptor.addChild(root_1, new ActionAST(stream_ACTION.nextToken()));
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "finallyClause"
public static class rulePrequels_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "rulePrequels"
// org\\antlr\\v4\\parse\\ANTLRParser.g:391:1: rulePrequels : sync ( rulePrequel sync )* -> ( rulePrequel )* ;
public final ANTLRParser.rulePrequels_return rulePrequels() throws RecognitionException {
ANTLRParser.rulePrequels_return retval = new ANTLRParser.rulePrequels_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
ParserRuleReturnScope sync91 =null;
ParserRuleReturnScope rulePrequel92 =null;
ParserRuleReturnScope sync93 =null;
RewriteRuleSubtreeStream stream_sync=new RewriteRuleSubtreeStream(adaptor,"rule sync");
RewriteRuleSubtreeStream stream_rulePrequel=new RewriteRuleSubtreeStream(adaptor,"rule rulePrequel");
paraphrases.push("matching rule preamble");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:394:2: ( sync ( rulePrequel sync )* -> ( rulePrequel )* )
// org\\antlr\\v4\\parse\\ANTLRParser.g:394:4: sync ( rulePrequel sync )*
{
pushFollow(FOLLOW_sync_in_rulePrequels1846);
sync91=sync();
state._fsp--;
stream_sync.add(sync91.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:394:9: ( rulePrequel sync )*
loop28:
while (true) {
int alt28=2;
int LA28_0 = input.LA(1);
if ( (LA28_0==AT||LA28_0==OPTIONS) ) {
alt28=1;
}
switch (alt28) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:394:10: rulePrequel sync
{
pushFollow(FOLLOW_rulePrequel_in_rulePrequels1849);
rulePrequel92=rulePrequel();
state._fsp--;
stream_rulePrequel.add(rulePrequel92.getTree());
pushFollow(FOLLOW_sync_in_rulePrequels1851);
sync93=sync();
state._fsp--;
stream_sync.add(sync93.getTree());
}
break;
default :
break loop28;
}
}
// AST REWRITE
// elements: rulePrequel
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 394:29: -> ( rulePrequel )*
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:394:32: ( rulePrequel )*
while ( stream_rulePrequel.hasNext() ) {
adaptor.addChild(root_0, stream_rulePrequel.nextTree());
}
stream_rulePrequel.reset();
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
paraphrases.pop();
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "rulePrequels"
public static class rulePrequel_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "rulePrequel"
// org\\antlr\\v4\\parse\\ANTLRParser.g:400:1: rulePrequel : ( optionsSpec | ruleAction );
public final ANTLRParser.rulePrequel_return rulePrequel() throws RecognitionException {
ANTLRParser.rulePrequel_return retval = new ANTLRParser.rulePrequel_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
ParserRuleReturnScope optionsSpec94 =null;
ParserRuleReturnScope ruleAction95 =null;
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:401:5: ( optionsSpec | ruleAction )
int alt29=2;
int LA29_0 = input.LA(1);
if ( (LA29_0==OPTIONS) ) {
alt29=1;
}
else if ( (LA29_0==AT) ) {
alt29=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 29, 0, input);
throw nvae;
}
switch (alt29) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:401:7: optionsSpec
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_optionsSpec_in_rulePrequel1875);
optionsSpec94=optionsSpec();
state._fsp--;
adaptor.addChild(root_0, optionsSpec94.getTree());
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:402:7: ruleAction
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_ruleAction_in_rulePrequel1883);
ruleAction95=ruleAction();
state._fsp--;
adaptor.addChild(root_0, ruleAction95.getTree());
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "rulePrequel"
public static class ruleReturns_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "ruleReturns"
// org\\antlr\\v4\\parse\\ANTLRParser.g:411:1: ruleReturns : RETURNS ^ ARG_ACTION ;
public final ANTLRParser.ruleReturns_return ruleReturns() throws RecognitionException {
ANTLRParser.ruleReturns_return retval = new ANTLRParser.ruleReturns_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token RETURNS96=null;
Token ARG_ACTION97=null;
GrammarAST RETURNS96_tree=null;
GrammarAST ARG_ACTION97_tree=null;
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:412:2: ( RETURNS ^ ARG_ACTION )
// org\\antlr\\v4\\parse\\ANTLRParser.g:412:4: RETURNS ^ ARG_ACTION
{
root_0 = (GrammarAST)adaptor.nil();
RETURNS96=(Token)match(input,RETURNS,FOLLOW_RETURNS_in_ruleReturns1903);
RETURNS96_tree = (GrammarAST)adaptor.create(RETURNS96);
root_0 = (GrammarAST)adaptor.becomeRoot(RETURNS96_tree, root_0);
ARG_ACTION97=(Token)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_ruleReturns1906);
ARG_ACTION97_tree = new ActionAST(ARG_ACTION97) ;
adaptor.addChild(root_0, ARG_ACTION97_tree);
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "ruleReturns"
public static class throwsSpec_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "throwsSpec"
// org\\antlr\\v4\\parse\\ANTLRParser.g:426:1: throwsSpec : THROWS qid ( COMMA qid )* -> ^( THROWS ( qid )+ ) ;
public final ANTLRParser.throwsSpec_return throwsSpec() throws RecognitionException {
ANTLRParser.throwsSpec_return retval = new ANTLRParser.throwsSpec_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token THROWS98=null;
Token COMMA100=null;
ParserRuleReturnScope qid99 =null;
ParserRuleReturnScope qid101 =null;
GrammarAST THROWS98_tree=null;
GrammarAST COMMA100_tree=null;
RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
RewriteRuleTokenStream stream_THROWS=new RewriteRuleTokenStream(adaptor,"token THROWS");
RewriteRuleSubtreeStream stream_qid=new RewriteRuleSubtreeStream(adaptor,"rule qid");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:427:5: ( THROWS qid ( COMMA qid )* -> ^( THROWS ( qid )+ ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:427:7: THROWS qid ( COMMA qid )*
{
THROWS98=(Token)match(input,THROWS,FOLLOW_THROWS_in_throwsSpec1934);
stream_THROWS.add(THROWS98);
pushFollow(FOLLOW_qid_in_throwsSpec1936);
qid99=qid();
state._fsp--;
stream_qid.add(qid99.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:427:18: ( COMMA qid )*
loop30:
while (true) {
int alt30=2;
int LA30_0 = input.LA(1);
if ( (LA30_0==COMMA) ) {
alt30=1;
}
switch (alt30) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:427:19: COMMA qid
{
COMMA100=(Token)match(input,COMMA,FOLLOW_COMMA_in_throwsSpec1939);
stream_COMMA.add(COMMA100);
pushFollow(FOLLOW_qid_in_throwsSpec1941);
qid101=qid();
state._fsp--;
stream_qid.add(qid101.getTree());
}
break;
default :
break loop30;
}
}
// AST REWRITE
// elements: THROWS, qid
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 427:31: -> ^( THROWS ( qid )+ )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:427:34: ^( THROWS ( qid )+ )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot(stream_THROWS.nextNode(), root_1);
if ( !(stream_qid.hasNext()) ) {
throw new RewriteEarlyExitException();
}
while ( stream_qid.hasNext() ) {
adaptor.addChild(root_1, stream_qid.nextTree());
}
stream_qid.reset();
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "throwsSpec"
public static class localsSpec_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "localsSpec"
// org\\antlr\\v4\\parse\\ANTLRParser.g:431:1: localsSpec : LOCALS ^ ARG_ACTION ;
public final ANTLRParser.localsSpec_return localsSpec() throws RecognitionException {
ANTLRParser.localsSpec_return retval = new ANTLRParser.localsSpec_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token LOCALS102=null;
Token ARG_ACTION103=null;
GrammarAST LOCALS102_tree=null;
GrammarAST ARG_ACTION103_tree=null;
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:431:12: ( LOCALS ^ ARG_ACTION )
// org\\antlr\\v4\\parse\\ANTLRParser.g:431:14: LOCALS ^ ARG_ACTION
{
root_0 = (GrammarAST)adaptor.nil();
LOCALS102=(Token)match(input,LOCALS,FOLLOW_LOCALS_in_localsSpec1966);
LOCALS102_tree = (GrammarAST)adaptor.create(LOCALS102);
root_0 = (GrammarAST)adaptor.becomeRoot(LOCALS102_tree, root_0);
ARG_ACTION103=(Token)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_localsSpec1969);
ARG_ACTION103_tree = new ActionAST(ARG_ACTION103) ;
adaptor.addChild(root_0, ARG_ACTION103_tree);
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "localsSpec"
public static class ruleAction_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "ruleAction"
// org\\antlr\\v4\\parse\\ANTLRParser.g:442:1: ruleAction : AT id ACTION -> ^( AT id ACTION ) ;
public final ANTLRParser.ruleAction_return ruleAction() throws RecognitionException {
ANTLRParser.ruleAction_return retval = new ANTLRParser.ruleAction_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token AT104=null;
Token ACTION106=null;
ParserRuleReturnScope id105 =null;
GrammarAST AT104_tree=null;
GrammarAST ACTION106_tree=null;
RewriteRuleTokenStream stream_AT=new RewriteRuleTokenStream(adaptor,"token AT");
RewriteRuleTokenStream stream_ACTION=new RewriteRuleTokenStream(adaptor,"token ACTION");
RewriteRuleSubtreeStream stream_id=new RewriteRuleSubtreeStream(adaptor,"rule id");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:443:2: ( AT id ACTION -> ^( AT id ACTION ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:443:4: AT id ACTION
{
AT104=(Token)match(input,AT,FOLLOW_AT_in_ruleAction1992);
stream_AT.add(AT104);
pushFollow(FOLLOW_id_in_ruleAction1994);
id105=id();
state._fsp--;
stream_id.add(id105.getTree());
ACTION106=(Token)match(input,ACTION,FOLLOW_ACTION_in_ruleAction1996);
stream_ACTION.add(ACTION106);
// AST REWRITE
// elements: AT, ACTION, id
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 443:17: -> ^( AT id ACTION )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:443:20: ^( AT id ACTION )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot(stream_AT.nextNode(), root_1);
adaptor.addChild(root_1, stream_id.nextTree());
adaptor.addChild(root_1, new ActionAST(stream_ACTION.nextToken()));
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "ruleAction"
public static class ruleBlock_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "ruleBlock"
// org\\antlr\\v4\\parse\\ANTLRParser.g:452:1: ruleBlock : ruleAltList -> ^( BLOCK[colon,\"BLOCK\"] ruleAltList ) ;
public final ANTLRParser.ruleBlock_return ruleBlock() throws RecognitionException {
ANTLRParser.ruleBlock_return retval = new ANTLRParser.ruleBlock_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
ParserRuleReturnScope ruleAltList107 =null;
RewriteRuleSubtreeStream stream_ruleAltList=new RewriteRuleSubtreeStream(adaptor,"rule ruleAltList");
Token colon = input.LT(-1);
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:454:5: ( ruleAltList -> ^( BLOCK[colon,\"BLOCK\"] ruleAltList ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:454:7: ruleAltList
{
pushFollow(FOLLOW_ruleAltList_in_ruleBlock2034);
ruleAltList107=ruleAltList();
state._fsp--;
stream_ruleAltList.add(ruleAltList107.getTree());
// AST REWRITE
// elements: ruleAltList
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 454:19: -> ^( BLOCK[colon,\"BLOCK\"] ruleAltList )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:454:22: ^( BLOCK[colon,\"BLOCK\"] ruleAltList )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot(new BlockAST(BLOCK, colon, "BLOCK"), root_1);
adaptor.addChild(root_1, stream_ruleAltList.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (ResyncToEndOfRuleBlock e) {
// just resyncing; ignore error
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), null);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "ruleBlock"
public static class ruleAltList_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "ruleAltList"
// org\\antlr\\v4\\parse\\ANTLRParser.g:461:1: ruleAltList : labeledAlt ( OR labeledAlt )* -> ( labeledAlt )+ ;
public final ANTLRParser.ruleAltList_return ruleAltList() throws RecognitionException {
ANTLRParser.ruleAltList_return retval = new ANTLRParser.ruleAltList_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token OR109=null;
ParserRuleReturnScope labeledAlt108 =null;
ParserRuleReturnScope labeledAlt110 =null;
GrammarAST OR109_tree=null;
RewriteRuleTokenStream stream_OR=new RewriteRuleTokenStream(adaptor,"token OR");
RewriteRuleSubtreeStream stream_labeledAlt=new RewriteRuleSubtreeStream(adaptor,"rule labeledAlt");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:462:2: ( labeledAlt ( OR labeledAlt )* -> ( labeledAlt )+ )
// org\\antlr\\v4\\parse\\ANTLRParser.g:462:4: labeledAlt ( OR labeledAlt )*
{
pushFollow(FOLLOW_labeledAlt_in_ruleAltList2070);
labeledAlt108=labeledAlt();
state._fsp--;
stream_labeledAlt.add(labeledAlt108.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:462:15: ( OR labeledAlt )*
loop31:
while (true) {
int alt31=2;
int LA31_0 = input.LA(1);
if ( (LA31_0==OR) ) {
alt31=1;
}
switch (alt31) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:462:16: OR labeledAlt
{
OR109=(Token)match(input,OR,FOLLOW_OR_in_ruleAltList2073);
stream_OR.add(OR109);
pushFollow(FOLLOW_labeledAlt_in_ruleAltList2075);
labeledAlt110=labeledAlt();
state._fsp--;
stream_labeledAlt.add(labeledAlt110.getTree());
}
break;
default :
break loop31;
}
}
// AST REWRITE
// elements: labeledAlt
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 462:32: -> ( labeledAlt )+
{
if ( !(stream_labeledAlt.hasNext()) ) {
throw new RewriteEarlyExitException();
}
while ( stream_labeledAlt.hasNext() ) {
adaptor.addChild(root_0, stream_labeledAlt.nextTree());
}
stream_labeledAlt.reset();
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "ruleAltList"
public static class labeledAlt_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "labeledAlt"
// org\\antlr\\v4\\parse\\ANTLRParser.g:465:1: labeledAlt : alternative ( POUND ! id !)? ;
public final ANTLRParser.labeledAlt_return labeledAlt() throws RecognitionException {
ANTLRParser.labeledAlt_return retval = new ANTLRParser.labeledAlt_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token POUND112=null;
ParserRuleReturnScope alternative111 =null;
ParserRuleReturnScope id113 =null;
GrammarAST POUND112_tree=null;
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:466:2: ( alternative ( POUND ! id !)? )
// org\\antlr\\v4\\parse\\ANTLRParser.g:466:4: alternative ( POUND ! id !)?
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_alternative_in_labeledAlt2093);
alternative111=alternative();
state._fsp--;
adaptor.addChild(root_0, alternative111.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:467:3: ( POUND ! id !)?
int alt32=2;
int LA32_0 = input.LA(1);
if ( (LA32_0==POUND) ) {
alt32=1;
}
switch (alt32) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:467:5: POUND ! id !
{
POUND112=(Token)match(input,POUND,FOLLOW_POUND_in_labeledAlt2099);
pushFollow(FOLLOW_id_in_labeledAlt2102);
id113=id();
state._fsp--;
((AltAST)(alternative111!=null?((GrammarAST)alternative111.getTree()):null)).altLabel=(id113!=null?((GrammarAST)id113.getTree()):null);
}
break;
}
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "labeledAlt"
public static class lexerRule_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "lexerRule"
// org\\antlr\\v4\\parse\\ANTLRParser.g:471:1: lexerRule : ( FRAGMENT )? TOKEN_REF COLON lexerRuleBlock SEMI -> ^( RULE TOKEN_REF ( ^( RULEMODIFIERS FRAGMENT ) )? lexerRuleBlock ) ;
public final ANTLRParser.lexerRule_return lexerRule() throws RecognitionException {
ANTLRParser.lexerRule_return retval = new ANTLRParser.lexerRule_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token FRAGMENT114=null;
Token TOKEN_REF115=null;
Token COLON116=null;
Token SEMI118=null;
ParserRuleReturnScope lexerRuleBlock117 =null;
GrammarAST FRAGMENT114_tree=null;
GrammarAST TOKEN_REF115_tree=null;
GrammarAST COLON116_tree=null;
GrammarAST SEMI118_tree=null;
RewriteRuleTokenStream stream_TOKEN_REF=new RewriteRuleTokenStream(adaptor,"token TOKEN_REF");
RewriteRuleTokenStream stream_FRAGMENT=new RewriteRuleTokenStream(adaptor,"token FRAGMENT");
RewriteRuleTokenStream stream_SEMI=new RewriteRuleTokenStream(adaptor,"token SEMI");
RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON");
RewriteRuleSubtreeStream stream_lexerRuleBlock=new RewriteRuleSubtreeStream(adaptor,"rule lexerRuleBlock");
paraphrases.push("matching a lexer rule");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:476:5: ( ( FRAGMENT )? TOKEN_REF COLON lexerRuleBlock SEMI -> ^( RULE TOKEN_REF ( ^( RULEMODIFIERS FRAGMENT ) )? lexerRuleBlock ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:476:7: ( FRAGMENT )? TOKEN_REF COLON lexerRuleBlock SEMI
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:476:7: ( FRAGMENT )?
int alt33=2;
int LA33_0 = input.LA(1);
if ( (LA33_0==FRAGMENT) ) {
alt33=1;
}
switch (alt33) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:476:7: FRAGMENT
{
FRAGMENT114=(Token)match(input,FRAGMENT,FOLLOW_FRAGMENT_in_lexerRule2134);
stream_FRAGMENT.add(FRAGMENT114);
}
break;
}
TOKEN_REF115=(Token)match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_lexerRule2140);
stream_TOKEN_REF.add(TOKEN_REF115);
COLON116=(Token)match(input,COLON,FOLLOW_COLON_in_lexerRule2142);
stream_COLON.add(COLON116);
pushFollow(FOLLOW_lexerRuleBlock_in_lexerRule2144);
lexerRuleBlock117=lexerRuleBlock();
state._fsp--;
stream_lexerRuleBlock.add(lexerRuleBlock117.getTree());
SEMI118=(Token)match(input,SEMI,FOLLOW_SEMI_in_lexerRule2146);
stream_SEMI.add(SEMI118);
// AST REWRITE
// elements: lexerRuleBlock, TOKEN_REF, FRAGMENT
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 478:7: -> ^( RULE TOKEN_REF ( ^( RULEMODIFIERS FRAGMENT ) )? lexerRuleBlock )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:478:10: ^( RULE TOKEN_REF ( ^( RULEMODIFIERS FRAGMENT ) )? lexerRuleBlock )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot(new RuleAST(RULE), root_1);
adaptor.addChild(root_1, stream_TOKEN_REF.nextNode());
// org\\antlr\\v4\\parse\\ANTLRParser.g:479:9: ( ^( RULEMODIFIERS FRAGMENT ) )?
if ( stream_FRAGMENT.hasNext() ) {
// org\\antlr\\v4\\parse\\ANTLRParser.g:479:9: ^( RULEMODIFIERS FRAGMENT )
{
GrammarAST root_2 = (GrammarAST)adaptor.nil();
root_2 = (GrammarAST)adaptor.becomeRoot((GrammarAST)adaptor.create(RULEMODIFIERS, "RULEMODIFIERS"), root_2);
adaptor.addChild(root_2, stream_FRAGMENT.nextNode());
adaptor.addChild(root_1, root_2);
}
}
stream_FRAGMENT.reset();
adaptor.addChild(root_1, stream_lexerRuleBlock.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
paraphrases.pop();
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "lexerRule"
public static class lexerRuleBlock_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "lexerRuleBlock"
// org\\antlr\\v4\\parse\\ANTLRParser.g:483:1: lexerRuleBlock : lexerAltList -> ^( BLOCK[colon,\"BLOCK\"] lexerAltList ) ;
public final ANTLRParser.lexerRuleBlock_return lexerRuleBlock() throws RecognitionException {
ANTLRParser.lexerRuleBlock_return retval = new ANTLRParser.lexerRuleBlock_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
ParserRuleReturnScope lexerAltList119 =null;
RewriteRuleSubtreeStream stream_lexerAltList=new RewriteRuleSubtreeStream(adaptor,"rule lexerAltList");
Token colon = input.LT(-1);
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:485:5: ( lexerAltList -> ^( BLOCK[colon,\"BLOCK\"] lexerAltList ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:485:7: lexerAltList
{
pushFollow(FOLLOW_lexerAltList_in_lexerRuleBlock2210);
lexerAltList119=lexerAltList();
state._fsp--;
stream_lexerAltList.add(lexerAltList119.getTree());
// AST REWRITE
// elements: lexerAltList
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 485:20: -> ^( BLOCK[colon,\"BLOCK\"] lexerAltList )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:485:23: ^( BLOCK[colon,\"BLOCK\"] lexerAltList )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot(new BlockAST(BLOCK, colon, "BLOCK"), root_1);
adaptor.addChild(root_1, stream_lexerAltList.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (ResyncToEndOfRuleBlock e) {
// just resyncing; ignore error
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), null);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "lexerRuleBlock"
public static class lexerAltList_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "lexerAltList"
// org\\antlr\\v4\\parse\\ANTLRParser.g:492:1: lexerAltList : lexerAlt ( OR lexerAlt )* -> ( lexerAlt )+ ;
public final ANTLRParser.lexerAltList_return lexerAltList() throws RecognitionException {
ANTLRParser.lexerAltList_return retval = new ANTLRParser.lexerAltList_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token OR121=null;
ParserRuleReturnScope lexerAlt120 =null;
ParserRuleReturnScope lexerAlt122 =null;
GrammarAST OR121_tree=null;
RewriteRuleTokenStream stream_OR=new RewriteRuleTokenStream(adaptor,"token OR");
RewriteRuleSubtreeStream stream_lexerAlt=new RewriteRuleSubtreeStream(adaptor,"rule lexerAlt");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:493:2: ( lexerAlt ( OR lexerAlt )* -> ( lexerAlt )+ )
// org\\antlr\\v4\\parse\\ANTLRParser.g:493:4: lexerAlt ( OR lexerAlt )*
{
pushFollow(FOLLOW_lexerAlt_in_lexerAltList2246);
lexerAlt120=lexerAlt();
state._fsp--;
stream_lexerAlt.add(lexerAlt120.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:493:13: ( OR lexerAlt )*
loop34:
while (true) {
int alt34=2;
int LA34_0 = input.LA(1);
if ( (LA34_0==OR) ) {
alt34=1;
}
switch (alt34) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:493:14: OR lexerAlt
{
OR121=(Token)match(input,OR,FOLLOW_OR_in_lexerAltList2249);
stream_OR.add(OR121);
pushFollow(FOLLOW_lexerAlt_in_lexerAltList2251);
lexerAlt122=lexerAlt();
state._fsp--;
stream_lexerAlt.add(lexerAlt122.getTree());
}
break;
default :
break loop34;
}
}
// AST REWRITE
// elements: lexerAlt
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 493:28: -> ( lexerAlt )+
{
if ( !(stream_lexerAlt.hasNext()) ) {
throw new RewriteEarlyExitException();
}
while ( stream_lexerAlt.hasNext() ) {
adaptor.addChild(root_0, stream_lexerAlt.nextTree());
}
stream_lexerAlt.reset();
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "lexerAltList"
public static class lexerAlt_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "lexerAlt"
// org\\antlr\\v4\\parse\\ANTLRParser.g:496:1: lexerAlt : lexerElements ( lexerCommands -> ^( LEXER_ALT_ACTION lexerElements lexerCommands ) | -> lexerElements ) ;
public final ANTLRParser.lexerAlt_return lexerAlt() throws RecognitionException {
ANTLRParser.lexerAlt_return retval = new ANTLRParser.lexerAlt_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
ParserRuleReturnScope lexerElements123 =null;
ParserRuleReturnScope lexerCommands124 =null;
RewriteRuleSubtreeStream stream_lexerCommands=new RewriteRuleSubtreeStream(adaptor,"rule lexerCommands");
RewriteRuleSubtreeStream stream_lexerElements=new RewriteRuleSubtreeStream(adaptor,"rule lexerElements");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:497:2: ( lexerElements ( lexerCommands -> ^( LEXER_ALT_ACTION lexerElements lexerCommands ) | -> lexerElements ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:497:4: lexerElements ( lexerCommands -> ^( LEXER_ALT_ACTION lexerElements lexerCommands ) | -> lexerElements )
{
pushFollow(FOLLOW_lexerElements_in_lexerAlt2269);
lexerElements123=lexerElements();
state._fsp--;
stream_lexerElements.add(lexerElements123.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:498:3: ( lexerCommands -> ^( LEXER_ALT_ACTION lexerElements lexerCommands ) | -> lexerElements )
int alt35=2;
int LA35_0 = input.LA(1);
if ( (LA35_0==RARROW) ) {
alt35=1;
}
else if ( (LA35_0==OR||LA35_0==RPAREN||LA35_0==SEMI) ) {
alt35=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 35, 0, input);
throw nvae;
}
switch (alt35) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:498:5: lexerCommands
{
pushFollow(FOLLOW_lexerCommands_in_lexerAlt2275);
lexerCommands124=lexerCommands();
state._fsp--;
stream_lexerCommands.add(lexerCommands124.getTree());
// AST REWRITE
// elements: lexerCommands, lexerElements
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 498:19: -> ^( LEXER_ALT_ACTION lexerElements lexerCommands )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:498:22: ^( LEXER_ALT_ACTION lexerElements lexerCommands )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot(new AltAST(LEXER_ALT_ACTION), root_1);
adaptor.addChild(root_1, stream_lexerElements.nextTree());
adaptor.addChild(root_1, stream_lexerCommands.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:499:9:
{
// AST REWRITE
// elements: lexerElements
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 499:9: -> lexerElements
{
adaptor.addChild(root_0, stream_lexerElements.nextTree());
}
retval.tree = root_0;
}
break;
}
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "lexerAlt"
public static class lexerElements_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "lexerElements"
// org\\antlr\\v4\\parse\\ANTLRParser.g:503:1: lexerElements : ( ( lexerElement )+ -> ^( ALT ( lexerElement )+ ) | -> ^( ALT EPSILON ) );
public final ANTLRParser.lexerElements_return lexerElements() throws RecognitionException {
ANTLRParser.lexerElements_return retval = new ANTLRParser.lexerElements_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
ParserRuleReturnScope lexerElement125 =null;
RewriteRuleSubtreeStream stream_lexerElement=new RewriteRuleSubtreeStream(adaptor,"rule lexerElement");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:504:5: ( ( lexerElement )+ -> ^( ALT ( lexerElement )+ ) | -> ^( ALT EPSILON ) )
int alt37=2;
int LA37_0 = input.LA(1);
if ( (LA37_0==ACTION||LA37_0==DOT||LA37_0==LEXER_CHAR_SET||LA37_0==LPAREN||LA37_0==NOT||LA37_0==RULE_REF||LA37_0==SEMPRED||LA37_0==STRING_LITERAL||LA37_0==TOKEN_REF) ) {
alt37=1;
}
else if ( (LA37_0==OR||LA37_0==RARROW||LA37_0==RPAREN||LA37_0==SEMI) ) {
alt37=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 37, 0, input);
throw nvae;
}
switch (alt37) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:504:7: ( lexerElement )+
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:504:7: ( lexerElement )+
int cnt36=0;
loop36:
while (true) {
int alt36=2;
int LA36_0 = input.LA(1);
if ( (LA36_0==ACTION||LA36_0==DOT||LA36_0==LEXER_CHAR_SET||LA36_0==LPAREN||LA36_0==NOT||LA36_0==RULE_REF||LA36_0==SEMPRED||LA36_0==STRING_LITERAL||LA36_0==TOKEN_REF) ) {
alt36=1;
}
switch (alt36) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:504:7: lexerElement
{
pushFollow(FOLLOW_lexerElement_in_lexerElements2318);
lexerElement125=lexerElement();
state._fsp--;
stream_lexerElement.add(lexerElement125.getTree());
}
break;
default :
if ( cnt36 >= 1 ) break loop36;
EarlyExitException eee = new EarlyExitException(36, input);
throw eee;
}
cnt36++;
}
// AST REWRITE
// elements: lexerElement
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 504:21: -> ^( ALT ( lexerElement )+ )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:504:24: ^( ALT ( lexerElement )+ )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot(new AltAST(ALT), root_1);
if ( !(stream_lexerElement.hasNext()) ) {
throw new RewriteEarlyExitException();
}
while ( stream_lexerElement.hasNext() ) {
adaptor.addChild(root_1, stream_lexerElement.nextTree());
}
stream_lexerElement.reset();
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:505:8:
{
// AST REWRITE
// elements:
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 505:8: -> ^( ALT EPSILON )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:505:11: ^( ALT EPSILON )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot(new AltAST(ALT), root_1);
adaptor.addChild(root_1, (GrammarAST)adaptor.create(EPSILON, "EPSILON"));
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "lexerElements"
public static class lexerElement_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "lexerElement"
// org\\antlr\\v4\\parse\\ANTLRParser.g:508:1: lexerElement : ( labeledLexerElement ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[$labeledLexerElement.start,\"BLOCK\"] ^( ALT labeledLexerElement ) ) ) | -> labeledLexerElement ) | lexerAtom ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[$lexerAtom.start,\"BLOCK\"] ^( ALT lexerAtom ) ) ) | -> lexerAtom ) | lexerBlock ( ebnfSuffix -> ^( ebnfSuffix lexerBlock ) | -> lexerBlock ) | actionElement );
public final ANTLRParser.lexerElement_return lexerElement() throws RecognitionException {
ANTLRParser.lexerElement_return retval = new ANTLRParser.lexerElement_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
ParserRuleReturnScope labeledLexerElement126 =null;
ParserRuleReturnScope ebnfSuffix127 =null;
ParserRuleReturnScope lexerAtom128 =null;
ParserRuleReturnScope ebnfSuffix129 =null;
ParserRuleReturnScope lexerBlock130 =null;
ParserRuleReturnScope ebnfSuffix131 =null;
ParserRuleReturnScope actionElement132 =null;
RewriteRuleSubtreeStream stream_labeledLexerElement=new RewriteRuleSubtreeStream(adaptor,"rule labeledLexerElement");
RewriteRuleSubtreeStream stream_lexerBlock=new RewriteRuleSubtreeStream(adaptor,"rule lexerBlock");
RewriteRuleSubtreeStream stream_ebnfSuffix=new RewriteRuleSubtreeStream(adaptor,"rule ebnfSuffix");
RewriteRuleSubtreeStream stream_lexerAtom=new RewriteRuleSubtreeStream(adaptor,"rule lexerAtom");
paraphrases.push("looking for lexer rule element");
int m = input.mark();
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:514:2: ( labeledLexerElement ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[$labeledLexerElement.start,\"BLOCK\"] ^( ALT labeledLexerElement ) ) ) | -> labeledLexerElement ) | lexerAtom ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[$lexerAtom.start,\"BLOCK\"] ^( ALT lexerAtom ) ) ) | -> lexerAtom ) | lexerBlock ( ebnfSuffix -> ^( ebnfSuffix lexerBlock ) | -> lexerBlock ) | actionElement )
int alt41=4;
switch ( input.LA(1) ) {
case RULE_REF:
{
int LA41_1 = input.LA(2);
if ( (LA41_1==ASSIGN||LA41_1==PLUS_ASSIGN) ) {
alt41=1;
}
else if ( (LA41_1==ACTION||LA41_1==DOT||LA41_1==LEXER_CHAR_SET||LA41_1==LPAREN||LA41_1==NOT||LA41_1==OR||LA41_1==PLUS||LA41_1==QUESTION||LA41_1==RARROW||(LA41_1 >= RPAREN && LA41_1 <= SEMPRED)||(LA41_1 >= STAR && LA41_1 <= STRING_LITERAL)||LA41_1==TOKEN_REF) ) {
alt41=2;
}
else {
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 41, 1, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case TOKEN_REF:
{
int LA41_2 = input.LA(2);
if ( (LA41_2==ASSIGN||LA41_2==PLUS_ASSIGN) ) {
alt41=1;
}
else if ( (LA41_2==ACTION||LA41_2==DOT||LA41_2==LEXER_CHAR_SET||(LA41_2 >= LPAREN && LA41_2 <= LT)||LA41_2==NOT||LA41_2==OR||LA41_2==PLUS||LA41_2==QUESTION||LA41_2==RARROW||(LA41_2 >= RPAREN && LA41_2 <= SEMPRED)||(LA41_2 >= STAR && LA41_2 <= STRING_LITERAL)||LA41_2==TOKEN_REF) ) {
alt41=2;
}
else {
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 41, 2, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case DOT:
case LEXER_CHAR_SET:
case NOT:
case STRING_LITERAL:
{
alt41=2;
}
break;
case LPAREN:
{
alt41=3;
}
break;
case ACTION:
case SEMPRED:
{
alt41=4;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 41, 0, input);
throw nvae;
}
switch (alt41) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:514:4: labeledLexerElement ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[$labeledLexerElement.start,\"BLOCK\"] ^( ALT labeledLexerElement ) ) ) | -> labeledLexerElement )
{
pushFollow(FOLLOW_labeledLexerElement_in_lexerElement2374);
labeledLexerElement126=labeledLexerElement();
state._fsp--;
stream_labeledLexerElement.add(labeledLexerElement126.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:515:3: ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[$labeledLexerElement.start,\"BLOCK\"] ^( ALT labeledLexerElement ) ) ) | -> labeledLexerElement )
int alt38=2;
int LA38_0 = input.LA(1);
if ( (LA38_0==PLUS||LA38_0==QUESTION||LA38_0==STAR) ) {
alt38=1;
}
else if ( (LA38_0==ACTION||LA38_0==DOT||LA38_0==LEXER_CHAR_SET||LA38_0==LPAREN||LA38_0==NOT||LA38_0==OR||LA38_0==RARROW||(LA38_0 >= RPAREN && LA38_0 <= SEMPRED)||LA38_0==STRING_LITERAL||LA38_0==TOKEN_REF) ) {
alt38=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 38, 0, input);
throw nvae;
}
switch (alt38) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:515:5: ebnfSuffix
{
pushFollow(FOLLOW_ebnfSuffix_in_lexerElement2380);
ebnfSuffix127=ebnfSuffix();
state._fsp--;
stream_ebnfSuffix.add(ebnfSuffix127.getTree());
// AST REWRITE
// elements: labeledLexerElement, ebnfSuffix
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 515:16: -> ^( ebnfSuffix ^( BLOCK[$labeledLexerElement.start,\"BLOCK\"] ^( ALT labeledLexerElement ) ) )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:515:19: ^( ebnfSuffix ^( BLOCK[$labeledLexerElement.start,\"BLOCK\"] ^( ALT labeledLexerElement ) ) )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot(stream_ebnfSuffix.nextNode(), root_1);
// org\\antlr\\v4\\parse\\ANTLRParser.g:515:33: ^( BLOCK[$labeledLexerElement.start,\"BLOCK\"] ^( ALT labeledLexerElement ) )
{
GrammarAST root_2 = (GrammarAST)adaptor.nil();
root_2 = (GrammarAST)adaptor.becomeRoot(new BlockAST(BLOCK, (labeledLexerElement126!=null?(labeledLexerElement126.start):null), "BLOCK"), root_2);
// org\\antlr\\v4\\parse\\ANTLRParser.g:515:87: ^( ALT labeledLexerElement )
{
GrammarAST root_3 = (GrammarAST)adaptor.nil();
root_3 = (GrammarAST)adaptor.becomeRoot(new AltAST(ALT), root_3);
adaptor.addChild(root_3, stream_labeledLexerElement.nextTree());
adaptor.addChild(root_2, root_3);
}
adaptor.addChild(root_1, root_2);
}
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:516:8:
{
// AST REWRITE
// elements: labeledLexerElement
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 516:8: -> labeledLexerElement
{
adaptor.addChild(root_0, stream_labeledLexerElement.nextTree());
}
retval.tree = root_0;
}
break;
}
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:518:4: lexerAtom ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[$lexerAtom.start,\"BLOCK\"] ^( ALT lexerAtom ) ) ) | -> lexerAtom )
{
pushFollow(FOLLOW_lexerAtom_in_lexerElement2426);
lexerAtom128=lexerAtom();
state._fsp--;
stream_lexerAtom.add(lexerAtom128.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:519:3: ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[$lexerAtom.start,\"BLOCK\"] ^( ALT lexerAtom ) ) ) | -> lexerAtom )
int alt39=2;
int LA39_0 = input.LA(1);
if ( (LA39_0==PLUS||LA39_0==QUESTION||LA39_0==STAR) ) {
alt39=1;
}
else if ( (LA39_0==ACTION||LA39_0==DOT||LA39_0==LEXER_CHAR_SET||LA39_0==LPAREN||LA39_0==NOT||LA39_0==OR||LA39_0==RARROW||(LA39_0 >= RPAREN && LA39_0 <= SEMPRED)||LA39_0==STRING_LITERAL||LA39_0==TOKEN_REF) ) {
alt39=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 39, 0, input);
throw nvae;
}
switch (alt39) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:519:5: ebnfSuffix
{
pushFollow(FOLLOW_ebnfSuffix_in_lexerElement2432);
ebnfSuffix129=ebnfSuffix();
state._fsp--;
stream_ebnfSuffix.add(ebnfSuffix129.getTree());
// AST REWRITE
// elements: ebnfSuffix, lexerAtom
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 519:16: -> ^( ebnfSuffix ^( BLOCK[$lexerAtom.start,\"BLOCK\"] ^( ALT lexerAtom ) ) )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:519:19: ^( ebnfSuffix ^( BLOCK[$lexerAtom.start,\"BLOCK\"] ^( ALT lexerAtom ) ) )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot(stream_ebnfSuffix.nextNode(), root_1);
// org\\antlr\\v4\\parse\\ANTLRParser.g:519:33: ^( BLOCK[$lexerAtom.start,\"BLOCK\"] ^( ALT lexerAtom ) )
{
GrammarAST root_2 = (GrammarAST)adaptor.nil();
root_2 = (GrammarAST)adaptor.becomeRoot(new BlockAST(BLOCK, (lexerAtom128!=null?(lexerAtom128.start):null), "BLOCK"), root_2);
// org\\antlr\\v4\\parse\\ANTLRParser.g:519:77: ^( ALT lexerAtom )
{
GrammarAST root_3 = (GrammarAST)adaptor.nil();
root_3 = (GrammarAST)adaptor.becomeRoot(new AltAST(ALT), root_3);
adaptor.addChild(root_3, stream_lexerAtom.nextTree());
adaptor.addChild(root_2, root_3);
}
adaptor.addChild(root_1, root_2);
}
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:520:8:
{
// AST REWRITE
// elements: lexerAtom
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 520:8: -> lexerAtom
{
adaptor.addChild(root_0, stream_lexerAtom.nextTree());
}
retval.tree = root_0;
}
break;
}
}
break;
case 3 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:522:4: lexerBlock ( ebnfSuffix -> ^( ebnfSuffix lexerBlock ) | -> lexerBlock )
{
pushFollow(FOLLOW_lexerBlock_in_lexerElement2478);
lexerBlock130=lexerBlock();
state._fsp--;
stream_lexerBlock.add(lexerBlock130.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:523:3: ( ebnfSuffix -> ^( ebnfSuffix lexerBlock ) | -> lexerBlock )
int alt40=2;
int LA40_0 = input.LA(1);
if ( (LA40_0==PLUS||LA40_0==QUESTION||LA40_0==STAR) ) {
alt40=1;
}
else if ( (LA40_0==ACTION||LA40_0==DOT||LA40_0==LEXER_CHAR_SET||LA40_0==LPAREN||LA40_0==NOT||LA40_0==OR||LA40_0==RARROW||(LA40_0 >= RPAREN && LA40_0 <= SEMPRED)||LA40_0==STRING_LITERAL||LA40_0==TOKEN_REF) ) {
alt40=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 40, 0, input);
throw nvae;
}
switch (alt40) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:523:5: ebnfSuffix
{
pushFollow(FOLLOW_ebnfSuffix_in_lexerElement2484);
ebnfSuffix131=ebnfSuffix();
state._fsp--;
stream_ebnfSuffix.add(ebnfSuffix131.getTree());
// AST REWRITE
// elements: lexerBlock, ebnfSuffix
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 523:16: -> ^( ebnfSuffix lexerBlock )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:523:19: ^( ebnfSuffix lexerBlock )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot(stream_ebnfSuffix.nextNode(), root_1);
adaptor.addChild(root_1, stream_lexerBlock.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:524:8:
{
// AST REWRITE
// elements: lexerBlock
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 524:8: -> lexerBlock
{
adaptor.addChild(root_0, stream_lexerBlock.nextTree());
}
retval.tree = root_0;
}
break;
}
}
break;
case 4 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:526:4: actionElement
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_actionElement_in_lexerElement2512);
actionElement132=actionElement();
state._fsp--;
adaptor.addChild(root_0, actionElement132.getTree());
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
paraphrases.pop();
}
catch (RecognitionException re) {
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
int ttype = input.get(input.range()).getType(); // seems to be next token
// look for anything that really belongs at the start of the rule minus the initial ID
if ( ttype==COLON || ttype==RETURNS || ttype==CATCH || ttype==FINALLY || ttype==AT || ttype==EOF ) {
RecognitionException missingSemi =
new v4ParserException("unterminated rule (missing ';') detected at '"+
input.LT(1).getText()+" "+input.LT(2).getText()+"'", input);
reportError(missingSemi);
if ( ttype==EOF ) {
input.seek(input.index()+1);
}
else if ( ttype==CATCH || ttype==FINALLY ) {
input.seek(input.range()); // ignore what's before rule trailer stuff
}
else if ( ttype==RETURNS || ttype==AT ) { // scan back looking for ID of rule header
int p = input.index();
Token t = input.get(p);
while ( t.getType()!=RULE_REF && t.getType()!=TOKEN_REF ) {
p--;
t = input.get(p);
}
input.seek(p);
}
throw new ResyncToEndOfRuleBlock(); // make sure it goes back to rule block level to recover
}
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "lexerElement"
public static class labeledLexerElement_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "labeledLexerElement"
// org\\antlr\\v4\\parse\\ANTLRParser.g:559:1: labeledLexerElement : id (ass= ASSIGN |ass= PLUS_ASSIGN ) ( lexerAtom -> ^( $ass id lexerAtom ) | lexerBlock -> ^( $ass id lexerBlock ) ) ;
public final ANTLRParser.labeledLexerElement_return labeledLexerElement() throws RecognitionException {
ANTLRParser.labeledLexerElement_return retval = new ANTLRParser.labeledLexerElement_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token ass=null;
ParserRuleReturnScope id133 =null;
ParserRuleReturnScope lexerAtom134 =null;
ParserRuleReturnScope lexerBlock135 =null;
GrammarAST ass_tree=null;
RewriteRuleTokenStream stream_PLUS_ASSIGN=new RewriteRuleTokenStream(adaptor,"token PLUS_ASSIGN");
RewriteRuleTokenStream stream_ASSIGN=new RewriteRuleTokenStream(adaptor,"token ASSIGN");
RewriteRuleSubtreeStream stream_lexerBlock=new RewriteRuleSubtreeStream(adaptor,"rule lexerBlock");
RewriteRuleSubtreeStream stream_id=new RewriteRuleSubtreeStream(adaptor,"rule id");
RewriteRuleSubtreeStream stream_lexerAtom=new RewriteRuleSubtreeStream(adaptor,"rule lexerAtom");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:560:2: ( id (ass= ASSIGN |ass= PLUS_ASSIGN ) ( lexerAtom -> ^( $ass id lexerAtom ) | lexerBlock -> ^( $ass id lexerBlock ) ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:560:4: id (ass= ASSIGN |ass= PLUS_ASSIGN ) ( lexerAtom -> ^( $ass id lexerAtom ) | lexerBlock -> ^( $ass id lexerBlock ) )
{
pushFollow(FOLLOW_id_in_labeledLexerElement2542);
id133=id();
state._fsp--;
stream_id.add(id133.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:560:7: (ass= ASSIGN |ass= PLUS_ASSIGN )
int alt42=2;
int LA42_0 = input.LA(1);
if ( (LA42_0==ASSIGN) ) {
alt42=1;
}
else if ( (LA42_0==PLUS_ASSIGN) ) {
alt42=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 42, 0, input);
throw nvae;
}
switch (alt42) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:560:8: ass= ASSIGN
{
ass=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_labeledLexerElement2547);
stream_ASSIGN.add(ass);
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:560:19: ass= PLUS_ASSIGN
{
ass=(Token)match(input,PLUS_ASSIGN,FOLLOW_PLUS_ASSIGN_in_labeledLexerElement2551);
stream_PLUS_ASSIGN.add(ass);
}
break;
}
// org\\antlr\\v4\\parse\\ANTLRParser.g:561:3: ( lexerAtom -> ^( $ass id lexerAtom ) | lexerBlock -> ^( $ass id lexerBlock ) )
int alt43=2;
int LA43_0 = input.LA(1);
if ( (LA43_0==DOT||LA43_0==LEXER_CHAR_SET||LA43_0==NOT||LA43_0==RULE_REF||LA43_0==STRING_LITERAL||LA43_0==TOKEN_REF) ) {
alt43=1;
}
else if ( (LA43_0==LPAREN) ) {
alt43=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 43, 0, input);
throw nvae;
}
switch (alt43) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:561:5: lexerAtom
{
pushFollow(FOLLOW_lexerAtom_in_labeledLexerElement2558);
lexerAtom134=lexerAtom();
state._fsp--;
stream_lexerAtom.add(lexerAtom134.getTree());
// AST REWRITE
// elements: lexerAtom, ass, id
// token labels: ass
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleTokenStream stream_ass=new RewriteRuleTokenStream(adaptor,"token ass",ass);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 561:15: -> ^( $ass id lexerAtom )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:561:18: ^( $ass id lexerAtom )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot(stream_ass.nextNode(), root_1);
adaptor.addChild(root_1, stream_id.nextTree());
adaptor.addChild(root_1, stream_lexerAtom.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:562:5: lexerBlock
{
pushFollow(FOLLOW_lexerBlock_in_labeledLexerElement2575);
lexerBlock135=lexerBlock();
state._fsp--;
stream_lexerBlock.add(lexerBlock135.getTree());
// AST REWRITE
// elements: ass, id, lexerBlock
// token labels: ass
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleTokenStream stream_ass=new RewriteRuleTokenStream(adaptor,"token ass",ass);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 562:16: -> ^( $ass id lexerBlock )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:562:19: ^( $ass id lexerBlock )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot(stream_ass.nextNode(), root_1);
adaptor.addChild(root_1, stream_id.nextTree());
adaptor.addChild(root_1, stream_lexerBlock.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
}
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "labeledLexerElement"
public static class lexerBlock_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "lexerBlock"
// org\\antlr\\v4\\parse\\ANTLRParser.g:567:1: lexerBlock : LPAREN ( optionsSpec COLON )? lexerAltList RPAREN -> ^( BLOCK[$LPAREN,\"BLOCK\"] ( optionsSpec )? lexerAltList ) ;
public final ANTLRParser.lexerBlock_return lexerBlock() throws RecognitionException {
ANTLRParser.lexerBlock_return retval = new ANTLRParser.lexerBlock_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token LPAREN136=null;
Token COLON138=null;
Token RPAREN140=null;
ParserRuleReturnScope optionsSpec137 =null;
ParserRuleReturnScope lexerAltList139 =null;
GrammarAST LPAREN136_tree=null;
GrammarAST COLON138_tree=null;
GrammarAST RPAREN140_tree=null;
RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON");
RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
RewriteRuleSubtreeStream stream_optionsSpec=new RewriteRuleSubtreeStream(adaptor,"rule optionsSpec");
RewriteRuleSubtreeStream stream_lexerAltList=new RewriteRuleSubtreeStream(adaptor,"rule lexerAltList");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:574:3: ( LPAREN ( optionsSpec COLON )? lexerAltList RPAREN -> ^( BLOCK[$LPAREN,\"BLOCK\"] ( optionsSpec )? lexerAltList ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:574:5: LPAREN ( optionsSpec COLON )? lexerAltList RPAREN
{
LPAREN136=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_lexerBlock2608);
stream_LPAREN.add(LPAREN136);
// org\\antlr\\v4\\parse\\ANTLRParser.g:575:9: ( optionsSpec COLON )?
int alt44=2;
int LA44_0 = input.LA(1);
if ( (LA44_0==OPTIONS) ) {
alt44=1;
}
switch (alt44) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:575:11: optionsSpec COLON
{
pushFollow(FOLLOW_optionsSpec_in_lexerBlock2620);
optionsSpec137=optionsSpec();
state._fsp--;
stream_optionsSpec.add(optionsSpec137.getTree());
COLON138=(Token)match(input,COLON,FOLLOW_COLON_in_lexerBlock2622);
stream_COLON.add(COLON138);
}
break;
}
pushFollow(FOLLOW_lexerAltList_in_lexerBlock2635);
lexerAltList139=lexerAltList();
state._fsp--;
stream_lexerAltList.add(lexerAltList139.getTree());
RPAREN140=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_lexerBlock2645);
stream_RPAREN.add(RPAREN140);
// AST REWRITE
// elements: optionsSpec, lexerAltList
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 578:7: -> ^( BLOCK[$LPAREN,\"BLOCK\"] ( optionsSpec )? lexerAltList )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:578:10: ^( BLOCK[$LPAREN,\"BLOCK\"] ( optionsSpec )? lexerAltList )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot(new BlockAST(BLOCK, LPAREN136, "BLOCK"), root_1);
// org\\antlr\\v4\\parse\\ANTLRParser.g:578:45: ( optionsSpec )?
if ( stream_optionsSpec.hasNext() ) {
adaptor.addChild(root_1, stream_optionsSpec.nextTree());
}
stream_optionsSpec.reset();
adaptor.addChild(root_1, stream_lexerAltList.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
GrammarAST options = (GrammarAST)retval.tree.getFirstChildWithType(ANTLRParser.OPTIONS);
if ( options!=null ) {
Grammar.setNodeOptions(retval.tree, options);
}
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "lexerBlock"
public static class lexerCommands_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "lexerCommands"
// org\\antlr\\v4\\parse\\ANTLRParser.g:582:1: lexerCommands : RARROW lexerCommand ( COMMA lexerCommand )* -> ( lexerCommand )+ ;
public final ANTLRParser.lexerCommands_return lexerCommands() throws RecognitionException {
ANTLRParser.lexerCommands_return retval = new ANTLRParser.lexerCommands_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token RARROW141=null;
Token COMMA143=null;
ParserRuleReturnScope lexerCommand142 =null;
ParserRuleReturnScope lexerCommand144 =null;
GrammarAST RARROW141_tree=null;
GrammarAST COMMA143_tree=null;
RewriteRuleTokenStream stream_RARROW=new RewriteRuleTokenStream(adaptor,"token RARROW");
RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
RewriteRuleSubtreeStream stream_lexerCommand=new RewriteRuleSubtreeStream(adaptor,"rule lexerCommand");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:583:2: ( RARROW lexerCommand ( COMMA lexerCommand )* -> ( lexerCommand )+ )
// org\\antlr\\v4\\parse\\ANTLRParser.g:583:4: RARROW lexerCommand ( COMMA lexerCommand )*
{
RARROW141=(Token)match(input,RARROW,FOLLOW_RARROW_in_lexerCommands2682);
stream_RARROW.add(RARROW141);
pushFollow(FOLLOW_lexerCommand_in_lexerCommands2684);
lexerCommand142=lexerCommand();
state._fsp--;
stream_lexerCommand.add(lexerCommand142.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:583:24: ( COMMA lexerCommand )*
loop45:
while (true) {
int alt45=2;
int LA45_0 = input.LA(1);
if ( (LA45_0==COMMA) ) {
alt45=1;
}
switch (alt45) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:583:25: COMMA lexerCommand
{
COMMA143=(Token)match(input,COMMA,FOLLOW_COMMA_in_lexerCommands2687);
stream_COMMA.add(COMMA143);
pushFollow(FOLLOW_lexerCommand_in_lexerCommands2689);
lexerCommand144=lexerCommand();
state._fsp--;
stream_lexerCommand.add(lexerCommand144.getTree());
}
break;
default :
break loop45;
}
}
// AST REWRITE
// elements: lexerCommand
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 583:46: -> ( lexerCommand )+
{
if ( !(stream_lexerCommand.hasNext()) ) {
throw new RewriteEarlyExitException();
}
while ( stream_lexerCommand.hasNext() ) {
adaptor.addChild(root_0, stream_lexerCommand.nextTree());
}
stream_lexerCommand.reset();
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "lexerCommands"
public static class lexerCommand_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "lexerCommand"
// org\\antlr\\v4\\parse\\ANTLRParser.g:586:1: lexerCommand : ( lexerCommandName LPAREN lexerCommandExpr RPAREN -> ^( LEXER_ACTION_CALL lexerCommandName lexerCommandExpr ) | lexerCommandName );
public final ANTLRParser.lexerCommand_return lexerCommand() throws RecognitionException {
ANTLRParser.lexerCommand_return retval = new ANTLRParser.lexerCommand_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token LPAREN146=null;
Token RPAREN148=null;
ParserRuleReturnScope lexerCommandName145 =null;
ParserRuleReturnScope lexerCommandExpr147 =null;
ParserRuleReturnScope lexerCommandName149 =null;
GrammarAST LPAREN146_tree=null;
GrammarAST RPAREN148_tree=null;
RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
RewriteRuleSubtreeStream stream_lexerCommandName=new RewriteRuleSubtreeStream(adaptor,"rule lexerCommandName");
RewriteRuleSubtreeStream stream_lexerCommandExpr=new RewriteRuleSubtreeStream(adaptor,"rule lexerCommandExpr");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:587:2: ( lexerCommandName LPAREN lexerCommandExpr RPAREN -> ^( LEXER_ACTION_CALL lexerCommandName lexerCommandExpr ) | lexerCommandName )
int alt46=2;
switch ( input.LA(1) ) {
case RULE_REF:
{
int LA46_1 = input.LA(2);
if ( (LA46_1==LPAREN) ) {
alt46=1;
}
else if ( (LA46_1==COMMA||LA46_1==OR||LA46_1==RPAREN||LA46_1==SEMI) ) {
alt46=2;
}
else {
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 46, 1, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case TOKEN_REF:
{
int LA46_2 = input.LA(2);
if ( (LA46_2==LPAREN) ) {
alt46=1;
}
else if ( (LA46_2==COMMA||LA46_2==OR||LA46_2==RPAREN||LA46_2==SEMI) ) {
alt46=2;
}
else {
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 46, 2, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case MODE:
{
int LA46_3 = input.LA(2);
if ( (LA46_3==LPAREN) ) {
alt46=1;
}
else if ( (LA46_3==COMMA||LA46_3==OR||LA46_3==RPAREN||LA46_3==SEMI) ) {
alt46=2;
}
else {
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 46, 3, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 46, 0, input);
throw nvae;
}
switch (alt46) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:587:4: lexerCommandName LPAREN lexerCommandExpr RPAREN
{
pushFollow(FOLLOW_lexerCommandName_in_lexerCommand2707);
lexerCommandName145=lexerCommandName();
state._fsp--;
stream_lexerCommandName.add(lexerCommandName145.getTree());
LPAREN146=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_lexerCommand2709);
stream_LPAREN.add(LPAREN146);
pushFollow(FOLLOW_lexerCommandExpr_in_lexerCommand2711);
lexerCommandExpr147=lexerCommandExpr();
state._fsp--;
stream_lexerCommandExpr.add(lexerCommandExpr147.getTree());
RPAREN148=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_lexerCommand2713);
stream_RPAREN.add(RPAREN148);
// AST REWRITE
// elements: lexerCommandName, lexerCommandExpr
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 587:52: -> ^( LEXER_ACTION_CALL lexerCommandName lexerCommandExpr )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:587:55: ^( LEXER_ACTION_CALL lexerCommandName lexerCommandExpr )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot((GrammarAST)adaptor.create(LEXER_ACTION_CALL, "LEXER_ACTION_CALL"), root_1);
adaptor.addChild(root_1, stream_lexerCommandName.nextTree());
adaptor.addChild(root_1, stream_lexerCommandExpr.nextTree());
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:588:4: lexerCommandName
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_lexerCommandName_in_lexerCommand2728);
lexerCommandName149=lexerCommandName();
state._fsp--;
adaptor.addChild(root_0, lexerCommandName149.getTree());
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "lexerCommand"
public static class lexerCommandExpr_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "lexerCommandExpr"
// org\\antlr\\v4\\parse\\ANTLRParser.g:591:1: lexerCommandExpr : ( id | INT );
public final ANTLRParser.lexerCommandExpr_return lexerCommandExpr() throws RecognitionException {
ANTLRParser.lexerCommandExpr_return retval = new ANTLRParser.lexerCommandExpr_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token INT151=null;
ParserRuleReturnScope id150 =null;
GrammarAST INT151_tree=null;
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:592:2: ( id | INT )
int alt47=2;
int LA47_0 = input.LA(1);
if ( (LA47_0==RULE_REF||LA47_0==TOKEN_REF) ) {
alt47=1;
}
else if ( (LA47_0==INT) ) {
alt47=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 47, 0, input);
throw nvae;
}
switch (alt47) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:592:4: id
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_id_in_lexerCommandExpr2739);
id150=id();
state._fsp--;
adaptor.addChild(root_0, id150.getTree());
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:593:4: INT
{
root_0 = (GrammarAST)adaptor.nil();
INT151=(Token)match(input,INT,FOLLOW_INT_in_lexerCommandExpr2744);
INT151_tree = (GrammarAST)adaptor.create(INT151);
adaptor.addChild(root_0, INT151_tree);
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "lexerCommandExpr"
public static class lexerCommandName_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "lexerCommandName"
// org\\antlr\\v4\\parse\\ANTLRParser.g:596:1: lexerCommandName : ( id | MODE -> ID[$MODE] );
public final ANTLRParser.lexerCommandName_return lexerCommandName() throws RecognitionException {
ANTLRParser.lexerCommandName_return retval = new ANTLRParser.lexerCommandName_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token MODE153=null;
ParserRuleReturnScope id152 =null;
GrammarAST MODE153_tree=null;
RewriteRuleTokenStream stream_MODE=new RewriteRuleTokenStream(adaptor,"token MODE");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:597:9: ( id | MODE -> ID[$MODE] )
int alt48=2;
int LA48_0 = input.LA(1);
if ( (LA48_0==RULE_REF||LA48_0==TOKEN_REF) ) {
alt48=1;
}
else if ( (LA48_0==MODE) ) {
alt48=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 48, 0, input);
throw nvae;
}
switch (alt48) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:597:17: id
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_id_in_lexerCommandName2768);
id152=id();
state._fsp--;
adaptor.addChild(root_0, id152.getTree());
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:598:17: MODE
{
MODE153=(Token)match(input,MODE,FOLLOW_MODE_in_lexerCommandName2786);
stream_MODE.add(MODE153);
// AST REWRITE
// elements:
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 598:25: -> ID[$MODE]
{
adaptor.addChild(root_0, (GrammarAST)adaptor.create(ID, MODE153));
}
retval.tree = root_0;
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "lexerCommandName"
public static class altList_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "altList"
// org\\antlr\\v4\\parse\\ANTLRParser.g:601:1: altList : alternative ( OR alternative )* -> ( alternative )+ ;
public final ANTLRParser.altList_return altList() throws RecognitionException {
ANTLRParser.altList_return retval = new ANTLRParser.altList_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token OR155=null;
ParserRuleReturnScope alternative154 =null;
ParserRuleReturnScope alternative156 =null;
GrammarAST OR155_tree=null;
RewriteRuleTokenStream stream_OR=new RewriteRuleTokenStream(adaptor,"token OR");
RewriteRuleSubtreeStream stream_alternative=new RewriteRuleSubtreeStream(adaptor,"rule alternative");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:602:5: ( alternative ( OR alternative )* -> ( alternative )+ )
// org\\antlr\\v4\\parse\\ANTLRParser.g:602:7: alternative ( OR alternative )*
{
pushFollow(FOLLOW_alternative_in_altList2814);
alternative154=alternative();
state._fsp--;
stream_alternative.add(alternative154.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:602:19: ( OR alternative )*
loop49:
while (true) {
int alt49=2;
int LA49_0 = input.LA(1);
if ( (LA49_0==OR) ) {
alt49=1;
}
switch (alt49) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:602:20: OR alternative
{
OR155=(Token)match(input,OR,FOLLOW_OR_in_altList2817);
stream_OR.add(OR155);
pushFollow(FOLLOW_alternative_in_altList2819);
alternative156=alternative();
state._fsp--;
stream_alternative.add(alternative156.getTree());
}
break;
default :
break loop49;
}
}
// AST REWRITE
// elements: alternative
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 602:37: -> ( alternative )+
{
if ( !(stream_alternative.hasNext()) ) {
throw new RewriteEarlyExitException();
}
while ( stream_alternative.hasNext() ) {
adaptor.addChild(root_0, stream_alternative.nextTree());
}
stream_alternative.reset();
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "altList"
public static class alternative_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "alternative"
// org\\antlr\\v4\\parse\\ANTLRParser.g:606:1: alternative : (o= elementOptions )? ( (e+= element )+ -> ^( ALT ( elementOptions )? ( $e)+ ) | -> ^( ALT ( elementOptions )? EPSILON ) ) ;
public final ANTLRParser.alternative_return alternative() throws RecognitionException {
ANTLRParser.alternative_return retval = new ANTLRParser.alternative_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
List © 2015 - 2025 Weber Informatics LLC | Privacy Policy