org.antlr.v4.parse.ANTLRParser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of virtdata-lib-realer Show documentation
Show all versions of virtdata-lib-realer Show documentation
With inspiration from other libraries
// $ANTLR 3.5.2 org/antlr/v4/parse/ANTLRParser.g 2018-12-18 10:37:17
/*
[The "BSD licence"]
Copyright (c) 2005-20012 Terence Parr
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
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:146: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_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
RewriteRuleTokenStream stream_SEMI=new RewriteRuleTokenStream(adaptor,"token SEMI");
RewriteRuleSubtreeStream stream_id=new RewriteRuleSubtreeStream(adaptor,"rule id");
RewriteRuleSubtreeStream stream_sync=new RewriteRuleSubtreeStream(adaptor,"rule sync");
RewriteRuleSubtreeStream stream_modeSpec=new RewriteRuleSubtreeStream(adaptor,"rule modeSpec");
RewriteRuleSubtreeStream stream_prequelConstruct=new RewriteRuleSubtreeStream(adaptor,"rule prequelConstruct");
RewriteRuleSubtreeStream stream_grammarType=new RewriteRuleSubtreeStream(adaptor,"rule grammarType");
RewriteRuleSubtreeStream stream_rules=new RewriteRuleSubtreeStream(adaptor,"rule rules");
try {
// org/antlr/v4/parse/ANTLRParser.g:153:5: ( grammarType id SEMI sync ( prequelConstruct sync )* rules ( modeSpec )* EOF -> ^( grammarType id ( prequelConstruct )* rules ( modeSpec )* ) )
// org/antlr/v4/parse/ANTLRParser.g:156: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:169: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:169: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:177: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:177: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, rules, grammarType, modeSpec, prequelConstruct
// 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();
// 190:7: -> ^( grammarType id ( prequelConstruct )* rules ( modeSpec )* )
{
// org/antlr/v4/parse/ANTLRParser.g:190: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:192: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:194: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:198: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_TREE_GRAMMAR=new RewriteRuleTokenStream(adaptor,"token TREE_GRAMMAR");
RewriteRuleTokenStream stream_PARSER=new RewriteRuleTokenStream(adaptor,"token PARSER");
RewriteRuleTokenStream stream_LEXER=new RewriteRuleTokenStream(adaptor,"token LEXER");
RewriteRuleTokenStream stream_GRAMMAR=new RewriteRuleTokenStream(adaptor,"token GRAMMAR");
try {
// org/antlr/v4/parse/ANTLRParser.g:204: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:204: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:204: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:204: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();
// 204: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:206: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();
// 206: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:209: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();
// 209: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:210: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:218: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:219: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:220: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:224: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:231: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:234: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:240: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:244: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:245:2: ( OPTIONS ( option SEMI )* RBRACE -> ^( OPTIONS[$OPTIONS, \"OPTIONS\"] ( option )* ) )
// org/antlr/v4/parse/ANTLRParser.g:245:4: OPTIONS ( option SEMI )* RBRACE
{
OPTIONS15=(Token)match(input,OPTIONS,FOLLOW_OPTIONS_in_optionsSpec917);
stream_OPTIONS.add(OPTIONS15);
// org/antlr/v4/parse/ANTLRParser.g:245: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:245: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: option, OPTIONS
// 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();
// 245:34: -> ^( OPTIONS[$OPTIONS, \"OPTIONS\"] ( option )* )
{
// org/antlr/v4/parse/ANTLRParser.g:245: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:245: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:248: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:249:5: ( id ASSIGN ^ optionValue )
// org/antlr/v4/parse/ANTLRParser.g:249: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:257: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:258: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:261: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:262: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:263: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:264: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:269: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_IMPORT=new RewriteRuleTokenStream(adaptor,"token IMPORT");
RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
RewriteRuleTokenStream stream_SEMI=new RewriteRuleTokenStream(adaptor,"token SEMI");
RewriteRuleSubtreeStream stream_delegateGrammar=new RewriteRuleSubtreeStream(adaptor,"rule delegateGrammar");
try {
// org/antlr/v4/parse/ANTLRParser.g:270:2: ( IMPORT delegateGrammar ( COMMA delegateGrammar )* SEMI -> ^( IMPORT ( delegateGrammar )+ ) )
// org/antlr/v4/parse/ANTLRParser.g:270: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:270: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:270: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();
// 270:57: -> ^( IMPORT ( delegateGrammar )+ )
{
// org/antlr/v4/parse/ANTLRParser.g:270: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:275: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:276: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:276: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:277: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:280:1: tokensSpec : ( TOKENS_SPEC id ( COMMA id )* 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 RBRACE39=null;
Token TOKENS_SPEC40=null;
Token RBRACE41=null;
Token TOKENS_SPEC42=null;
Token RBRACE44=null;
ParserRuleReturnScope id36 =null;
ParserRuleReturnScope id38 =null;
ParserRuleReturnScope v3tokenSpec43 =null;
GrammarAST TOKENS_SPEC35_tree=null;
GrammarAST COMMA37_tree=null;
GrammarAST RBRACE39_tree=null;
GrammarAST TOKENS_SPEC40_tree=null;
GrammarAST RBRACE41_tree=null;
GrammarAST TOKENS_SPEC42_tree=null;
GrammarAST RBRACE44_tree=null;
RewriteRuleTokenStream stream_RBRACE=new RewriteRuleTokenStream(adaptor,"token RBRACE");
RewriteRuleTokenStream stream_TOKENS_SPEC=new RewriteRuleTokenStream(adaptor,"token TOKENS_SPEC");
RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
RewriteRuleSubtreeStream stream_id=new RewriteRuleSubtreeStream(adaptor,"rule id");
try {
// org/antlr/v4/parse/ANTLRParser.g:281:2: ( TOKENS_SPEC id ( COMMA id )* RBRACE -> ^( TOKENS_SPEC ( id )+ ) | TOKENS_SPEC RBRACE ->| TOKENS_SPEC ^ ( v3tokenSpec )+ RBRACE !)
int alt11=3;
int LA11_0 = input.LA(1);
if ( (LA11_0==TOKENS_SPEC) ) {
switch ( input.LA(2) ) {
case RBRACE:
{
alt11=2;
}
break;
case RULE_REF:
{
int LA11_3 = input.LA(3);
if ( (LA11_3==COMMA||LA11_3==RBRACE) ) {
alt11=1;
}
else if ( (LA11_3==ASSIGN||LA11_3==SEMI) ) {
alt11=3;
}
else {
int nvaeMark = input.mark();
try {
for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) {
input.consume();
}
NoViableAltException nvae =
new NoViableAltException("", 11, 3, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case TOKEN_REF:
{
int LA11_4 = input.LA(3);
if ( (LA11_4==COMMA||LA11_4==RBRACE) ) {
alt11=1;
}
else if ( (LA11_4==ASSIGN||LA11_4==SEMI) ) {
alt11=3;
}
else {
int nvaeMark = input.mark();
try {
for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) {
input.consume();
}
NoViableAltException nvae =
new NoViableAltException("", 11, 4, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
default:
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 11, 1, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
else {
NoViableAltException nvae =
new NoViableAltException("", 11, 0, input);
throw nvae;
}
switch (alt11) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:281:4: TOKENS_SPEC id ( COMMA id )* 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:281:19: ( COMMA id )*
loop9:
while (true) {
int alt9=2;
int LA9_0 = input.LA(1);
if ( (LA9_0==COMMA) ) {
alt9=1;
}
switch (alt9) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:281: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;
}
}
RBRACE39=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_tokensSpec1121);
stream_RBRACE.add(RBRACE39);
// AST REWRITE
// elements: id, TOKENS_SPEC
// 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();
// 281:38: -> ^( TOKENS_SPEC ( id )+ )
{
// org/antlr/v4/parse/ANTLRParser.g:281:41: ^( 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:282:7: TOKENS_SPEC RBRACE
{
TOKENS_SPEC40=(Token)match(input,TOKENS_SPEC,FOLLOW_TOKENS_SPEC_in_tokensSpec1138);
stream_TOKENS_SPEC.add(TOKENS_SPEC40);
RBRACE41=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_tokensSpec1140);
stream_RBRACE.add(RBRACE41);
// 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();
// 282:26: ->
{
root_0 = null;
}
retval.tree = root_0;
}
break;
case 3 :
// org/antlr/v4/parse/ANTLRParser.g:283:7: TOKENS_SPEC ^ ( v3tokenSpec )+ RBRACE !
{
root_0 = (GrammarAST)adaptor.nil();
TOKENS_SPEC42=(Token)match(input,TOKENS_SPEC,FOLLOW_TOKENS_SPEC_in_tokensSpec1150);
TOKENS_SPEC42_tree = (GrammarAST)adaptor.create(TOKENS_SPEC42);
root_0 = (GrammarAST)adaptor.becomeRoot(TOKENS_SPEC42_tree, root_0);
// org/antlr/v4/parse/ANTLRParser.g:283:20: ( v3tokenSpec )+
int cnt10=0;
loop10:
while (true) {
int alt10=2;
int LA10_0 = input.LA(1);
if ( (LA10_0==RULE_REF||LA10_0==TOKEN_REF) ) {
alt10=1;
}
switch (alt10) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:283:20: v3tokenSpec
{
pushFollow(FOLLOW_v3tokenSpec_in_tokensSpec1153);
v3tokenSpec43=v3tokenSpec();
state._fsp--;
adaptor.addChild(root_0, v3tokenSpec43.getTree());
}
break;
default :
if ( cnt10 >= 1 ) break loop10;
EarlyExitException eee = new EarlyExitException(10, input);
throw eee;
}
cnt10++;
}
RBRACE44=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_tokensSpec1156);
grammarError(ErrorType.V3_TOKENS_SYNTAX, TOKENS_SPEC42);
}
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:287: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 ASSIGN46=null;
Token SEMI47=null;
ParserRuleReturnScope id45 =null;
GrammarAST lit_tree=null;
GrammarAST ASSIGN46_tree=null;
GrammarAST SEMI47_tree=null;
RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL");
RewriteRuleTokenStream stream_SEMI=new RewriteRuleTokenStream(adaptor,"token SEMI");
RewriteRuleTokenStream stream_ASSIGN=new RewriteRuleTokenStream(adaptor,"token ASSIGN");
RewriteRuleSubtreeStream stream_id=new RewriteRuleSubtreeStream(adaptor,"rule id");
try {
// org/antlr/v4/parse/ANTLRParser.g:288:2: ( id ( ASSIGN lit= STRING_LITERAL -> id | -> id ) SEMI )
// org/antlr/v4/parse/ANTLRParser.g:288:4: id ( ASSIGN lit= STRING_LITERAL -> id | -> id ) SEMI
{
pushFollow(FOLLOW_id_in_v3tokenSpec1176);
id45=id();
state._fsp--;
stream_id.add(id45.getTree());
// org/antlr/v4/parse/ANTLRParser.g:289:3: ( ASSIGN lit= STRING_LITERAL -> id | -> id )
int alt12=2;
int LA12_0 = input.LA(1);
if ( (LA12_0==ASSIGN) ) {
alt12=1;
}
else if ( (LA12_0==SEMI) ) {
alt12=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 12, 0, input);
throw nvae;
}
switch (alt12) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:289:5: ASSIGN lit= STRING_LITERAL
{
ASSIGN46=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_v3tokenSpec1182);
stream_ASSIGN.add(ASSIGN46);
lit=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_v3tokenSpec1186);
stream_STRING_LITERAL.add(lit);
grammarError(ErrorType.V3_ASSIGN_IN_TOKENS, (id45!=null?(id45.start):null),
(id45!=null?input.toString(id45.start,id45.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();
// 294:20: -> id
{
adaptor.addChild(root_0, stream_id.nextTree());
}
retval.tree = root_0;
}
break;
case 2 :
// org/antlr/v4/parse/ANTLRParser.g:295: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();
// 295:12: -> id
{
adaptor.addChild(root_0, stream_id.nextTree());
}
retval.tree = root_0;
}
break;
}
SEMI47=(Token)match(input,SEMI,FOLLOW_SEMI_in_v3tokenSpec1247);
stream_SEMI.add(SEMI47);
}
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:300:1: channelsSpec : CHANNELS ^ id ( COMMA ! id )* 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 CHANNELS48=null;
Token COMMA50=null;
Token RBRACE52=null;
ParserRuleReturnScope id49 =null;
ParserRuleReturnScope id51 =null;
GrammarAST CHANNELS48_tree=null;
GrammarAST COMMA50_tree=null;
GrammarAST RBRACE52_tree=null;
try {
// org/antlr/v4/parse/ANTLRParser.g:301:2: ( CHANNELS ^ id ( COMMA ! id )* RBRACE !)
// org/antlr/v4/parse/ANTLRParser.g:301:4: CHANNELS ^ id ( COMMA ! id )* RBRACE !
{
root_0 = (GrammarAST)adaptor.nil();
CHANNELS48=(Token)match(input,CHANNELS,FOLLOW_CHANNELS_in_channelsSpec1258);
CHANNELS48_tree = (GrammarAST)adaptor.create(CHANNELS48);
root_0 = (GrammarAST)adaptor.becomeRoot(CHANNELS48_tree, root_0);
pushFollow(FOLLOW_id_in_channelsSpec1261);
id49=id();
state._fsp--;
adaptor.addChild(root_0, id49.getTree());
// org/antlr/v4/parse/ANTLRParser.g:301:17: ( COMMA ! id )*
loop13:
while (true) {
int alt13=2;
int LA13_0 = input.LA(1);
if ( (LA13_0==COMMA) ) {
alt13=1;
}
switch (alt13) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:301:18: COMMA ! id
{
COMMA50=(Token)match(input,COMMA,FOLLOW_COMMA_in_channelsSpec1264);
pushFollow(FOLLOW_id_in_channelsSpec1267);
id51=id();
state._fsp--;
adaptor.addChild(root_0, id51.getTree());
}
break;
default :
break loop13;
}
}
RBRACE52=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_channelsSpec1271);
}
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:308: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 AT53=null;
Token COLONCOLON55=null;
Token ACTION57=null;
ParserRuleReturnScope actionScopeName54 =null;
ParserRuleReturnScope id56 =null;
GrammarAST AT53_tree=null;
GrammarAST COLONCOLON55_tree=null;
GrammarAST ACTION57_tree=null;
RewriteRuleTokenStream stream_AT=new RewriteRuleTokenStream(adaptor,"token AT");
RewriteRuleTokenStream stream_COLONCOLON=new RewriteRuleTokenStream(adaptor,"token COLONCOLON");
RewriteRuleTokenStream stream_ACTION=new RewriteRuleTokenStream(adaptor,"token ACTION");
RewriteRuleSubtreeStream stream_id=new RewriteRuleSubtreeStream(adaptor,"rule id");
RewriteRuleSubtreeStream stream_actionScopeName=new RewriteRuleSubtreeStream(adaptor,"rule actionScopeName");
try {
// org/antlr/v4/parse/ANTLRParser.g:309:2: ( AT ( actionScopeName COLONCOLON )? id ACTION -> ^( AT ( actionScopeName )? id ACTION ) )
// org/antlr/v4/parse/ANTLRParser.g:309:4: AT ( actionScopeName COLONCOLON )? id ACTION
{
AT53=(Token)match(input,AT,FOLLOW_AT_in_action1288);
stream_AT.add(AT53);
// org/antlr/v4/parse/ANTLRParser.g:309:7: ( actionScopeName COLONCOLON )?
int alt14=2;
switch ( input.LA(1) ) {
case RULE_REF:
{
int LA14_1 = input.LA(2);
if ( (LA14_1==COLONCOLON) ) {
alt14=1;
}
}
break;
case TOKEN_REF:
{
int LA14_2 = input.LA(2);
if ( (LA14_2==COLONCOLON) ) {
alt14=1;
}
}
break;
case LEXER:
case PARSER:
{
alt14=1;
}
break;
}
switch (alt14) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:309:8: actionScopeName COLONCOLON
{
pushFollow(FOLLOW_actionScopeName_in_action1291);
actionScopeName54=actionScopeName();
state._fsp--;
stream_actionScopeName.add(actionScopeName54.getTree());
COLONCOLON55=(Token)match(input,COLONCOLON,FOLLOW_COLONCOLON_in_action1293);
stream_COLONCOLON.add(COLONCOLON55);
}
break;
}
pushFollow(FOLLOW_id_in_action1297);
id56=id();
state._fsp--;
stream_id.add(id56.getTree());
ACTION57=(Token)match(input,ACTION,FOLLOW_ACTION_in_action1299);
stream_ACTION.add(ACTION57);
// AST REWRITE
// elements: AT, actionScopeName, 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();
// 309:47: -> ^( AT ( actionScopeName )? id ACTION )
{
// org/antlr/v4/parse/ANTLRParser.g:309: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:309: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:315: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 LEXER59=null;
Token PARSER60=null;
ParserRuleReturnScope id58 =null;
GrammarAST LEXER59_tree=null;
GrammarAST PARSER60_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:316:2: ( id | LEXER -> ID[$LEXER] | PARSER -> ID[$PARSER] )
int alt15=3;
switch ( input.LA(1) ) {
case RULE_REF:
case TOKEN_REF:
{
alt15=1;
}
break;
case LEXER:
{
alt15=2;
}
break;
case PARSER:
{
alt15=3;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 15, 0, input);
throw nvae;
}
switch (alt15) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:316:4: id
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_id_in_actionScopeName1328);
id58=id();
state._fsp--;
adaptor.addChild(root_0, id58.getTree());
}
break;
case 2 :
// org/antlr/v4/parse/ANTLRParser.g:317:4: LEXER
{
LEXER59=(Token)match(input,LEXER,FOLLOW_LEXER_in_actionScopeName1333);
stream_LEXER.add(LEXER59);
// 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();
// 317:10: -> ID[$LEXER]
{
adaptor.addChild(root_0, (GrammarAST)adaptor.create(ID, LEXER59));
}
retval.tree = root_0;
}
break;
case 3 :
// org/antlr/v4/parse/ANTLRParser.g:318:9: PARSER
{
PARSER60=(Token)match(input,PARSER,FOLLOW_PARSER_in_actionScopeName1348);
stream_PARSER.add(PARSER60);
// 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();
// 318:16: -> ID[$PARSER]
{
adaptor.addChild(root_0, (GrammarAST)adaptor.create(ID, PARSER60));
}
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:321: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 MODE61=null;
Token SEMI63=null;
ParserRuleReturnScope id62 =null;
ParserRuleReturnScope sync64 =null;
ParserRuleReturnScope lexerRule65 =null;
ParserRuleReturnScope sync66 =null;
GrammarAST MODE61_tree=null;
GrammarAST SEMI63_tree=null;
RewriteRuleTokenStream stream_SEMI=new RewriteRuleTokenStream(adaptor,"token SEMI");
RewriteRuleTokenStream stream_MODE=new RewriteRuleTokenStream(adaptor,"token MODE");
RewriteRuleSubtreeStream stream_id=new RewriteRuleSubtreeStream(adaptor,"rule id");
RewriteRuleSubtreeStream stream_sync=new RewriteRuleSubtreeStream(adaptor,"rule sync");
RewriteRuleSubtreeStream stream_lexerRule=new RewriteRuleSubtreeStream(adaptor,"rule lexerRule");
try {
// org/antlr/v4/parse/ANTLRParser.g:322:5: ( MODE id SEMI sync ( lexerRule sync )* -> ^( MODE id ( lexerRule )* ) )
// org/antlr/v4/parse/ANTLRParser.g:322:7: MODE id SEMI sync ( lexerRule sync )*
{
MODE61=(Token)match(input,MODE,FOLLOW_MODE_in_modeSpec1367);
stream_MODE.add(MODE61);
pushFollow(FOLLOW_id_in_modeSpec1369);
id62=id();
state._fsp--;
stream_id.add(id62.getTree());
SEMI63=(Token)match(input,SEMI,FOLLOW_SEMI_in_modeSpec1371);
stream_SEMI.add(SEMI63);
pushFollow(FOLLOW_sync_in_modeSpec1373);
sync64=sync();
state._fsp--;
stream_sync.add(sync64.getTree());
// org/antlr/v4/parse/ANTLRParser.g:322:25: ( lexerRule sync )*
loop16:
while (true) {
int alt16=2;
int LA16_0 = input.LA(1);
if ( (LA16_0==FRAGMENT||LA16_0==TOKEN_REF) ) {
alt16=1;
}
switch (alt16) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:322:26: lexerRule sync
{
pushFollow(FOLLOW_lexerRule_in_modeSpec1376);
lexerRule65=lexerRule();
state._fsp--;
stream_lexerRule.add(lexerRule65.getTree());
pushFollow(FOLLOW_sync_in_modeSpec1378);
sync66=sync();
state._fsp--;
stream_sync.add(sync66.getTree());
}
break;
default :
break loop16;
}
}
// AST REWRITE
// elements: id, MODE, lexerRule
// 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();
// 322:44: -> ^( MODE id ( lexerRule )* )
{
// org/antlr/v4/parse/ANTLRParser.g:322: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:322: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:325: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 sync67 =null;
ParserRuleReturnScope rule68 =null;
ParserRuleReturnScope sync69 =null;
RewriteRuleSubtreeStream stream_sync=new RewriteRuleSubtreeStream(adaptor,"rule sync");
RewriteRuleSubtreeStream stream_rule=new RewriteRuleSubtreeStream(adaptor,"rule rule");
try {
// org/antlr/v4/parse/ANTLRParser.g:326:5: ( sync ( rule sync )* -> ^( RULES ( rule )* ) )
// org/antlr/v4/parse/ANTLRParser.g:326:7: sync ( rule sync )*
{
pushFollow(FOLLOW_sync_in_rules1409);
sync67=sync();
state._fsp--;
stream_sync.add(sync67.getTree());
// org/antlr/v4/parse/ANTLRParser.g:326:12: ( rule sync )*
loop17:
while (true) {
int alt17=2;
int LA17_0 = input.LA(1);
if ( (LA17_0==FRAGMENT||LA17_0==RULE_REF||LA17_0==TOKEN_REF) ) {
alt17=1;
}
switch (alt17) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:326:13: rule sync
{
pushFollow(FOLLOW_rule_in_rules1412);
rule68=rule();
state._fsp--;
stream_rule.add(rule68.getTree());
pushFollow(FOLLOW_sync_in_rules1414);
sync69=sync();
state._fsp--;
stream_sync.add(sync69.getTree());
}
break;
default :
break loop17;
}
}
// 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();
// 330:7: -> ^( RULES ( rule )* )
{
// org/antlr/v4/parse/ANTLRParser.g:330: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:330: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:333: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:342:3: ()
// org/antlr/v4/parse/ANTLRParser.g:343: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:345: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 parserRule70 =null;
ParserRuleReturnScope lexerRule71 =null;
try {
// org/antlr/v4/parse/ANTLRParser.g:345:5: ( parserRule | lexerRule )
int alt18=2;
int LA18_0 = input.LA(1);
if ( (LA18_0==RULE_REF) ) {
alt18=1;
}
else if ( (LA18_0==FRAGMENT||LA18_0==TOKEN_REF) ) {
alt18=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 18, 0, input);
throw nvae;
}
switch (alt18) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:345:7: parserRule
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_parserRule_in_rule1476);
parserRule70=parserRule();
state._fsp--;
adaptor.addChild(root_0, parserRule70.getTree());
}
break;
case 2 :
// org/antlr/v4/parse/ANTLRParser.g:346:4: lexerRule
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_lexerRule_in_rule1481);
lexerRule71=lexerRule();
state._fsp--;
adaptor.addChild(root_0, lexerRule71.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:358: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_REF72=null;
Token ARG_ACTION73=null;
Token COLON78=null;
Token SEMI80=null;
ParserRuleReturnScope ruleReturns74 =null;
ParserRuleReturnScope throwsSpec75 =null;
ParserRuleReturnScope localsSpec76 =null;
ParserRuleReturnScope rulePrequels77 =null;
ParserRuleReturnScope ruleBlock79 =null;
ParserRuleReturnScope exceptionGroup81 =null;
GrammarAST RULE_REF72_tree=null;
GrammarAST ARG_ACTION73_tree=null;
GrammarAST COLON78_tree=null;
GrammarAST SEMI80_tree=null;
RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON");
RewriteRuleTokenStream stream_SEMI=new RewriteRuleTokenStream(adaptor,"token SEMI");
RewriteRuleTokenStream stream_RULE_REF=new RewriteRuleTokenStream(adaptor,"token RULE_REF");
RewriteRuleTokenStream stream_ARG_ACTION=new RewriteRuleTokenStream(adaptor,"token ARG_ACTION");
RewriteRuleSubtreeStream stream_rulePrequels=new RewriteRuleSubtreeStream(adaptor,"rule rulePrequels");
RewriteRuleSubtreeStream stream_exceptionGroup=new RewriteRuleSubtreeStream(adaptor,"rule exceptionGroup");
RewriteRuleSubtreeStream stream_ruleReturns=new RewriteRuleSubtreeStream(adaptor,"rule ruleReturns");
RewriteRuleSubtreeStream stream_throwsSpec=new RewriteRuleSubtreeStream(adaptor,"rule throwsSpec");
RewriteRuleSubtreeStream stream_ruleBlock=new RewriteRuleSubtreeStream(adaptor,"rule ruleBlock");
RewriteRuleSubtreeStream stream_localsSpec=new RewriteRuleSubtreeStream(adaptor,"rule localsSpec");
paraphrases.push("matching a rule");
try {
// org/antlr/v4/parse/ANTLRParser.g:367: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:371:4: RULE_REF ( ARG_ACTION )? ( ruleReturns )? ( throwsSpec )? ( localsSpec )? rulePrequels COLON ruleBlock SEMI exceptionGroup
{
RULE_REF72=(Token)match(input,RULE_REF,FOLLOW_RULE_REF_in_parserRule1530);
stream_RULE_REF.add(RULE_REF72);
// org/antlr/v4/parse/ANTLRParser.g:379:4: ( ARG_ACTION )?
int alt19=2;
int LA19_0 = input.LA(1);
if ( (LA19_0==ARG_ACTION) ) {
alt19=1;
}
switch (alt19) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:379:4: ARG_ACTION
{
ARG_ACTION73=(Token)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_parserRule1560);
stream_ARG_ACTION.add(ARG_ACTION73);
}
break;
}
// org/antlr/v4/parse/ANTLRParser.g:381:4: ( ruleReturns )?
int alt20=2;
int LA20_0 = input.LA(1);
if ( (LA20_0==RETURNS) ) {
alt20=1;
}
switch (alt20) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:381:4: ruleReturns
{
pushFollow(FOLLOW_ruleReturns_in_parserRule1567);
ruleReturns74=ruleReturns();
state._fsp--;
stream_ruleReturns.add(ruleReturns74.getTree());
}
break;
}
// org/antlr/v4/parse/ANTLRParser.g:383:4: ( throwsSpec )?
int alt21=2;
int LA21_0 = input.LA(1);
if ( (LA21_0==THROWS) ) {
alt21=1;
}
switch (alt21) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:383:4: throwsSpec
{
pushFollow(FOLLOW_throwsSpec_in_parserRule1574);
throwsSpec75=throwsSpec();
state._fsp--;
stream_throwsSpec.add(throwsSpec75.getTree());
}
break;
}
// org/antlr/v4/parse/ANTLRParser.g:385:4: ( localsSpec )?
int alt22=2;
int LA22_0 = input.LA(1);
if ( (LA22_0==LOCALS) ) {
alt22=1;
}
switch (alt22) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:385:4: localsSpec
{
pushFollow(FOLLOW_localsSpec_in_parserRule1581);
localsSpec76=localsSpec();
state._fsp--;
stream_localsSpec.add(localsSpec76.getTree());
}
break;
}
pushFollow(FOLLOW_rulePrequels_in_parserRule1619);
rulePrequels77=rulePrequels();
state._fsp--;
stream_rulePrequels.add(rulePrequels77.getTree());
COLON78=(Token)match(input,COLON,FOLLOW_COLON_in_parserRule1628);
stream_COLON.add(COLON78);
pushFollow(FOLLOW_ruleBlock_in_parserRule1651);
ruleBlock79=ruleBlock();
state._fsp--;
stream_ruleBlock.add(ruleBlock79.getTree());
SEMI80=(Token)match(input,SEMI,FOLLOW_SEMI_in_parserRule1660);
stream_SEMI.add(SEMI80);
pushFollow(FOLLOW_exceptionGroup_in_parserRule1669);
exceptionGroup81=exceptionGroup();
state._fsp--;
stream_exceptionGroup.add(exceptionGroup81.getTree());
// AST REWRITE
// elements: ARG_ACTION, ruleBlock, localsSpec, throwsSpec, ruleReturns, RULE_REF, rulePrequels, 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();
// 412:7: -> ^( RULE RULE_REF ( ARG_ACTION )? ( ruleReturns )? ( throwsSpec )? ( localsSpec )? ( rulePrequels )? ruleBlock ( exceptionGroup )* )
{
// org/antlr/v4/parse/ANTLRParser.g:412: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:412: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:413:9: ( ruleReturns )?
if ( stream_ruleReturns.hasNext() ) {
adaptor.addChild(root_1, stream_ruleReturns.nextTree());
}
stream_ruleReturns.reset();
// org/antlr/v4/parse/ANTLRParser.g:413:22: ( throwsSpec )?
if ( stream_throwsSpec.hasNext() ) {
adaptor.addChild(root_1, stream_throwsSpec.nextTree());
}
stream_throwsSpec.reset();
// org/antlr/v4/parse/ANTLRParser.g:413:34: ( localsSpec )?
if ( stream_localsSpec.hasNext() ) {
adaptor.addChild(root_1, stream_localsSpec.nextTree());
}
stream_localsSpec.reset();
// org/antlr/v4/parse/ANTLRParser.g:413: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:413: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:423: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 exceptionHandler82 =null;
ParserRuleReturnScope finallyClause83 =null;
try {
// org/antlr/v4/parse/ANTLRParser.g:424:5: ( ( exceptionHandler )* ( finallyClause )? )
// org/antlr/v4/parse/ANTLRParser.g:424:7: ( exceptionHandler )* ( finallyClause )?
{
root_0 = (GrammarAST)adaptor.nil();
// org/antlr/v4/parse/ANTLRParser.g:424:7: ( exceptionHandler )*
loop23:
while (true) {
int alt23=2;
int LA23_0 = input.LA(1);
if ( (LA23_0==CATCH) ) {
alt23=1;
}
switch (alt23) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:424:7: exceptionHandler
{
pushFollow(FOLLOW_exceptionHandler_in_exceptionGroup1752);
exceptionHandler82=exceptionHandler();
state._fsp--;
adaptor.addChild(root_0, exceptionHandler82.getTree());
}
break;
default :
break loop23;
}
}
// org/antlr/v4/parse/ANTLRParser.g:424:25: ( finallyClause )?
int alt24=2;
int LA24_0 = input.LA(1);
if ( (LA24_0==FINALLY) ) {
alt24=1;
}
switch (alt24) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:424:25: finallyClause
{
pushFollow(FOLLOW_finallyClause_in_exceptionGroup1755);
finallyClause83=finallyClause();
state._fsp--;
adaptor.addChild(root_0, finallyClause83.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:429: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 CATCH84=null;
Token ARG_ACTION85=null;
Token ACTION86=null;
GrammarAST CATCH84_tree=null;
GrammarAST ARG_ACTION85_tree=null;
GrammarAST ACTION86_tree=null;
RewriteRuleTokenStream stream_CATCH=new RewriteRuleTokenStream(adaptor,"token CATCH");
RewriteRuleTokenStream stream_ACTION=new RewriteRuleTokenStream(adaptor,"token ACTION");
RewriteRuleTokenStream stream_ARG_ACTION=new RewriteRuleTokenStream(adaptor,"token ARG_ACTION");
try {
// org/antlr/v4/parse/ANTLRParser.g:430:2: ( CATCH ARG_ACTION ACTION -> ^( CATCH ARG_ACTION ACTION ) )
// org/antlr/v4/parse/ANTLRParser.g:430:4: CATCH ARG_ACTION ACTION
{
CATCH84=(Token)match(input,CATCH,FOLLOW_CATCH_in_exceptionHandler1772);
stream_CATCH.add(CATCH84);
ARG_ACTION85=(Token)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_exceptionHandler1774);
stream_ARG_ACTION.add(ARG_ACTION85);
ACTION86=(Token)match(input,ACTION,FOLLOW_ACTION_in_exceptionHandler1776);
stream_ACTION.add(ACTION86);
// AST REWRITE
// elements: ACTION, CATCH, ARG_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();
// 430:28: -> ^( CATCH ARG_ACTION ACTION )
{
// org/antlr/v4/parse/ANTLRParser.g:430: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:433: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 FINALLY87=null;
Token ACTION88=null;
GrammarAST FINALLY87_tree=null;
GrammarAST ACTION88_tree=null;
RewriteRuleTokenStream stream_FINALLY=new RewriteRuleTokenStream(adaptor,"token FINALLY");
RewriteRuleTokenStream stream_ACTION=new RewriteRuleTokenStream(adaptor,"token ACTION");
try {
// org/antlr/v4/parse/ANTLRParser.g:434:2: ( FINALLY ACTION -> ^( FINALLY ACTION ) )
// org/antlr/v4/parse/ANTLRParser.g:434:4: FINALLY ACTION
{
FINALLY87=(Token)match(input,FINALLY,FOLLOW_FINALLY_in_finallyClause1803);
stream_FINALLY.add(FINALLY87);
ACTION88=(Token)match(input,ACTION,FOLLOW_ACTION_in_finallyClause1805);
stream_ACTION.add(ACTION88);
// AST REWRITE
// elements: ACTION, FINALLY
// 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();
// 434:19: -> ^( FINALLY ACTION )
{
// org/antlr/v4/parse/ANTLRParser.g:434: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:437: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 sync89 =null;
ParserRuleReturnScope rulePrequel90 =null;
ParserRuleReturnScope sync91 =null;
RewriteRuleSubtreeStream stream_rulePrequel=new RewriteRuleSubtreeStream(adaptor,"rule rulePrequel");
RewriteRuleSubtreeStream stream_sync=new RewriteRuleSubtreeStream(adaptor,"rule sync");
paraphrases.push("matching rule preamble");
try {
// org/antlr/v4/parse/ANTLRParser.g:440:2: ( sync ( rulePrequel sync )* -> ( rulePrequel )* )
// org/antlr/v4/parse/ANTLRParser.g:440:4: sync ( rulePrequel sync )*
{
pushFollow(FOLLOW_sync_in_rulePrequels1837);
sync89=sync();
state._fsp--;
stream_sync.add(sync89.getTree());
// org/antlr/v4/parse/ANTLRParser.g:440:9: ( rulePrequel sync )*
loop25:
while (true) {
int alt25=2;
int LA25_0 = input.LA(1);
if ( (LA25_0==AT||LA25_0==OPTIONS) ) {
alt25=1;
}
switch (alt25) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:440:10: rulePrequel sync
{
pushFollow(FOLLOW_rulePrequel_in_rulePrequels1840);
rulePrequel90=rulePrequel();
state._fsp--;
stream_rulePrequel.add(rulePrequel90.getTree());
pushFollow(FOLLOW_sync_in_rulePrequels1842);
sync91=sync();
state._fsp--;
stream_sync.add(sync91.getTree());
}
break;
default :
break loop25;
}
}
// 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();
// 440:29: -> ( rulePrequel )*
{
// org/antlr/v4/parse/ANTLRParser.g:440: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:446: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 optionsSpec92 =null;
ParserRuleReturnScope ruleAction93 =null;
try {
// org/antlr/v4/parse/ANTLRParser.g:447:5: ( optionsSpec | ruleAction )
int alt26=2;
int LA26_0 = input.LA(1);
if ( (LA26_0==OPTIONS) ) {
alt26=1;
}
else if ( (LA26_0==AT) ) {
alt26=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 26, 0, input);
throw nvae;
}
switch (alt26) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:447:7: optionsSpec
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_optionsSpec_in_rulePrequel1866);
optionsSpec92=optionsSpec();
state._fsp--;
adaptor.addChild(root_0, optionsSpec92.getTree());
}
break;
case 2 :
// org/antlr/v4/parse/ANTLRParser.g:448:7: ruleAction
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_ruleAction_in_rulePrequel1874);
ruleAction93=ruleAction();
state._fsp--;
adaptor.addChild(root_0, ruleAction93.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:457: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 RETURNS94=null;
Token ARG_ACTION95=null;
GrammarAST RETURNS94_tree=null;
GrammarAST ARG_ACTION95_tree=null;
try {
// org/antlr/v4/parse/ANTLRParser.g:458:2: ( RETURNS ^ ARG_ACTION )
// org/antlr/v4/parse/ANTLRParser.g:458:4: RETURNS ^ ARG_ACTION
{
root_0 = (GrammarAST)adaptor.nil();
RETURNS94=(Token)match(input,RETURNS,FOLLOW_RETURNS_in_ruleReturns1894);
RETURNS94_tree = (GrammarAST)adaptor.create(RETURNS94);
root_0 = (GrammarAST)adaptor.becomeRoot(RETURNS94_tree, root_0);
ARG_ACTION95=(Token)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_ruleReturns1897);
ARG_ACTION95_tree = new ActionAST(ARG_ACTION95) ;
adaptor.addChild(root_0, ARG_ACTION95_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:472: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 THROWS96=null;
Token COMMA98=null;
ParserRuleReturnScope qid97 =null;
ParserRuleReturnScope qid99 =null;
GrammarAST THROWS96_tree=null;
GrammarAST COMMA98_tree=null;
RewriteRuleTokenStream stream_THROWS=new RewriteRuleTokenStream(adaptor,"token THROWS");
RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
RewriteRuleSubtreeStream stream_qid=new RewriteRuleSubtreeStream(adaptor,"rule qid");
try {
// org/antlr/v4/parse/ANTLRParser.g:473:5: ( THROWS qid ( COMMA qid )* -> ^( THROWS ( qid )+ ) )
// org/antlr/v4/parse/ANTLRParser.g:473:7: THROWS qid ( COMMA qid )*
{
THROWS96=(Token)match(input,THROWS,FOLLOW_THROWS_in_throwsSpec1925);
stream_THROWS.add(THROWS96);
pushFollow(FOLLOW_qid_in_throwsSpec1927);
qid97=qid();
state._fsp--;
stream_qid.add(qid97.getTree());
// org/antlr/v4/parse/ANTLRParser.g:473:18: ( COMMA qid )*
loop27:
while (true) {
int alt27=2;
int LA27_0 = input.LA(1);
if ( (LA27_0==COMMA) ) {
alt27=1;
}
switch (alt27) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:473:19: COMMA qid
{
COMMA98=(Token)match(input,COMMA,FOLLOW_COMMA_in_throwsSpec1930);
stream_COMMA.add(COMMA98);
pushFollow(FOLLOW_qid_in_throwsSpec1932);
qid99=qid();
state._fsp--;
stream_qid.add(qid99.getTree());
}
break;
default :
break loop27;
}
}
// AST REWRITE
// elements: qid, THROWS
// 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();
// 473:31: -> ^( THROWS ( qid )+ )
{
// org/antlr/v4/parse/ANTLRParser.g:473: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:477: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 LOCALS100=null;
Token ARG_ACTION101=null;
GrammarAST LOCALS100_tree=null;
GrammarAST ARG_ACTION101_tree=null;
try {
// org/antlr/v4/parse/ANTLRParser.g:477:12: ( LOCALS ^ ARG_ACTION )
// org/antlr/v4/parse/ANTLRParser.g:477:14: LOCALS ^ ARG_ACTION
{
root_0 = (GrammarAST)adaptor.nil();
LOCALS100=(Token)match(input,LOCALS,FOLLOW_LOCALS_in_localsSpec1957);
LOCALS100_tree = (GrammarAST)adaptor.create(LOCALS100);
root_0 = (GrammarAST)adaptor.becomeRoot(LOCALS100_tree, root_0);
ARG_ACTION101=(Token)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_localsSpec1960);
ARG_ACTION101_tree = new ActionAST(ARG_ACTION101) ;
adaptor.addChild(root_0, ARG_ACTION101_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:488: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 AT102=null;
Token ACTION104=null;
ParserRuleReturnScope id103 =null;
GrammarAST AT102_tree=null;
GrammarAST ACTION104_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:489:2: ( AT id ACTION -> ^( AT id ACTION ) )
// org/antlr/v4/parse/ANTLRParser.g:489:4: AT id ACTION
{
AT102=(Token)match(input,AT,FOLLOW_AT_in_ruleAction1983);
stream_AT.add(AT102);
pushFollow(FOLLOW_id_in_ruleAction1985);
id103=id();
state._fsp--;
stream_id.add(id103.getTree());
ACTION104=(Token)match(input,ACTION,FOLLOW_ACTION_in_ruleAction1987);
stream_ACTION.add(ACTION104);
// AST REWRITE
// elements: id, AT, 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();
// 489:17: -> ^( AT id ACTION )
{
// org/antlr/v4/parse/ANTLRParser.g:489: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:498: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 ruleAltList105 =null;
RewriteRuleSubtreeStream stream_ruleAltList=new RewriteRuleSubtreeStream(adaptor,"rule ruleAltList");
Token colon = input.LT(-1);
try {
// org/antlr/v4/parse/ANTLRParser.g:500:5: ( ruleAltList -> ^( BLOCK[colon,\"BLOCK\"] ruleAltList ) )
// org/antlr/v4/parse/ANTLRParser.g:500:7: ruleAltList
{
pushFollow(FOLLOW_ruleAltList_in_ruleBlock2025);
ruleAltList105=ruleAltList();
state._fsp--;
stream_ruleAltList.add(ruleAltList105.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();
// 500:19: -> ^( BLOCK[colon,\"BLOCK\"] ruleAltList )
{
// org/antlr/v4/parse/ANTLRParser.g:500: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:507: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 OR107=null;
ParserRuleReturnScope labeledAlt106 =null;
ParserRuleReturnScope labeledAlt108 =null;
GrammarAST OR107_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:508:2: ( labeledAlt ( OR labeledAlt )* -> ( labeledAlt )+ )
// org/antlr/v4/parse/ANTLRParser.g:508:4: labeledAlt ( OR labeledAlt )*
{
pushFollow(FOLLOW_labeledAlt_in_ruleAltList2061);
labeledAlt106=labeledAlt();
state._fsp--;
stream_labeledAlt.add(labeledAlt106.getTree());
// org/antlr/v4/parse/ANTLRParser.g:508:15: ( OR labeledAlt )*
loop28:
while (true) {
int alt28=2;
int LA28_0 = input.LA(1);
if ( (LA28_0==OR) ) {
alt28=1;
}
switch (alt28) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:508:16: OR labeledAlt
{
OR107=(Token)match(input,OR,FOLLOW_OR_in_ruleAltList2064);
stream_OR.add(OR107);
pushFollow(FOLLOW_labeledAlt_in_ruleAltList2066);
labeledAlt108=labeledAlt();
state._fsp--;
stream_labeledAlt.add(labeledAlt108.getTree());
}
break;
default :
break loop28;
}
}
// 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();
// 508: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:511: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 POUND110=null;
ParserRuleReturnScope alternative109 =null;
ParserRuleReturnScope id111 =null;
GrammarAST POUND110_tree=null;
try {
// org/antlr/v4/parse/ANTLRParser.g:512:2: ( alternative ( POUND ! id !)? )
// org/antlr/v4/parse/ANTLRParser.g:512:4: alternative ( POUND ! id !)?
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_alternative_in_labeledAlt2084);
alternative109=alternative();
state._fsp--;
adaptor.addChild(root_0, alternative109.getTree());
// org/antlr/v4/parse/ANTLRParser.g:513:3: ( POUND ! id !)?
int alt29=2;
int LA29_0 = input.LA(1);
if ( (LA29_0==POUND) ) {
alt29=1;
}
switch (alt29) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:513:5: POUND ! id !
{
POUND110=(Token)match(input,POUND,FOLLOW_POUND_in_labeledAlt2090);
pushFollow(FOLLOW_id_in_labeledAlt2093);
id111=id();
state._fsp--;
((AltAST)(alternative109!=null?((GrammarAST)alternative109.getTree()):null)).altLabel=(id111!=null?((GrammarAST)id111.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:517: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 FRAGMENT112=null;
Token TOKEN_REF113=null;
Token COLON114=null;
Token SEMI116=null;
ParserRuleReturnScope lexerRuleBlock115 =null;
GrammarAST FRAGMENT112_tree=null;
GrammarAST TOKEN_REF113_tree=null;
GrammarAST COLON114_tree=null;
GrammarAST SEMI116_tree=null;
RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON");
RewriteRuleTokenStream stream_SEMI=new RewriteRuleTokenStream(adaptor,"token SEMI");
RewriteRuleTokenStream stream_FRAGMENT=new RewriteRuleTokenStream(adaptor,"token FRAGMENT");
RewriteRuleTokenStream stream_TOKEN_REF=new RewriteRuleTokenStream(adaptor,"token TOKEN_REF");
RewriteRuleSubtreeStream stream_lexerRuleBlock=new RewriteRuleSubtreeStream(adaptor,"rule lexerRuleBlock");
paraphrases.push("matching a lexer rule");
try {
// org/antlr/v4/parse/ANTLRParser.g:522:5: ( ( FRAGMENT )? TOKEN_REF COLON lexerRuleBlock SEMI -> ^( RULE TOKEN_REF ( ^( RULEMODIFIERS FRAGMENT ) )? lexerRuleBlock ) )
// org/antlr/v4/parse/ANTLRParser.g:522:7: ( FRAGMENT )? TOKEN_REF COLON lexerRuleBlock SEMI
{
// org/antlr/v4/parse/ANTLRParser.g:522:7: ( FRAGMENT )?
int alt30=2;
int LA30_0 = input.LA(1);
if ( (LA30_0==FRAGMENT) ) {
alt30=1;
}
switch (alt30) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:522:7: FRAGMENT
{
FRAGMENT112=(Token)match(input,FRAGMENT,FOLLOW_FRAGMENT_in_lexerRule2125);
stream_FRAGMENT.add(FRAGMENT112);
}
break;
}
TOKEN_REF113=(Token)match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_lexerRule2131);
stream_TOKEN_REF.add(TOKEN_REF113);
COLON114=(Token)match(input,COLON,FOLLOW_COLON_in_lexerRule2133);
stream_COLON.add(COLON114);
pushFollow(FOLLOW_lexerRuleBlock_in_lexerRule2135);
lexerRuleBlock115=lexerRuleBlock();
state._fsp--;
stream_lexerRuleBlock.add(lexerRuleBlock115.getTree());
SEMI116=(Token)match(input,SEMI,FOLLOW_SEMI_in_lexerRule2137);
stream_SEMI.add(SEMI116);
// AST REWRITE
// elements: TOKEN_REF, lexerRuleBlock, 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();
// 524:7: -> ^( RULE TOKEN_REF ( ^( RULEMODIFIERS FRAGMENT ) )? lexerRuleBlock )
{
// org/antlr/v4/parse/ANTLRParser.g:524: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:525:9: ( ^( RULEMODIFIERS FRAGMENT ) )?
if ( stream_FRAGMENT.hasNext() ) {
// org/antlr/v4/parse/ANTLRParser.g:525: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:529: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 lexerAltList117 =null;
RewriteRuleSubtreeStream stream_lexerAltList=new RewriteRuleSubtreeStream(adaptor,"rule lexerAltList");
Token colon = input.LT(-1);
try {
// org/antlr/v4/parse/ANTLRParser.g:531:5: ( lexerAltList -> ^( BLOCK[colon,\"BLOCK\"] lexerAltList ) )
// org/antlr/v4/parse/ANTLRParser.g:531:7: lexerAltList
{
pushFollow(FOLLOW_lexerAltList_in_lexerRuleBlock2201);
lexerAltList117=lexerAltList();
state._fsp--;
stream_lexerAltList.add(lexerAltList117.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();
// 531:20: -> ^( BLOCK[colon,\"BLOCK\"] lexerAltList )
{
// org/antlr/v4/parse/ANTLRParser.g:531: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:538: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 OR119=null;
ParserRuleReturnScope lexerAlt118 =null;
ParserRuleReturnScope lexerAlt120 =null;
GrammarAST OR119_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:539:2: ( lexerAlt ( OR lexerAlt )* -> ( lexerAlt )+ )
// org/antlr/v4/parse/ANTLRParser.g:539:4: lexerAlt ( OR lexerAlt )*
{
pushFollow(FOLLOW_lexerAlt_in_lexerAltList2237);
lexerAlt118=lexerAlt();
state._fsp--;
stream_lexerAlt.add(lexerAlt118.getTree());
// org/antlr/v4/parse/ANTLRParser.g:539:13: ( OR lexerAlt )*
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:539:14: OR lexerAlt
{
OR119=(Token)match(input,OR,FOLLOW_OR_in_lexerAltList2240);
stream_OR.add(OR119);
pushFollow(FOLLOW_lexerAlt_in_lexerAltList2242);
lexerAlt120=lexerAlt();
state._fsp--;
stream_lexerAlt.add(lexerAlt120.getTree());
}
break;
default :
break loop31;
}
}
// 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();
// 539: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:542: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 lexerElements121 =null;
ParserRuleReturnScope lexerCommands122 =null;
RewriteRuleSubtreeStream stream_lexerElements=new RewriteRuleSubtreeStream(adaptor,"rule lexerElements");
RewriteRuleSubtreeStream stream_lexerCommands=new RewriteRuleSubtreeStream(adaptor,"rule lexerCommands");
try {
// org/antlr/v4/parse/ANTLRParser.g:543:2: ( lexerElements ( lexerCommands -> ^( LEXER_ALT_ACTION lexerElements lexerCommands ) | -> lexerElements ) )
// org/antlr/v4/parse/ANTLRParser.g:543:4: lexerElements ( lexerCommands -> ^( LEXER_ALT_ACTION lexerElements lexerCommands ) | -> lexerElements )
{
pushFollow(FOLLOW_lexerElements_in_lexerAlt2260);
lexerElements121=lexerElements();
state._fsp--;
stream_lexerElements.add(lexerElements121.getTree());
// org/antlr/v4/parse/ANTLRParser.g:544:3: ( lexerCommands -> ^( LEXER_ALT_ACTION lexerElements lexerCommands ) | -> lexerElements )
int alt32=2;
int LA32_0 = input.LA(1);
if ( (LA32_0==RARROW) ) {
alt32=1;
}
else if ( (LA32_0==OR||LA32_0==RPAREN||LA32_0==SEMI) ) {
alt32=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 32, 0, input);
throw nvae;
}
switch (alt32) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:544:5: lexerCommands
{
pushFollow(FOLLOW_lexerCommands_in_lexerAlt2266);
lexerCommands122=lexerCommands();
state._fsp--;
stream_lexerCommands.add(lexerCommands122.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();
// 544:19: -> ^( LEXER_ALT_ACTION lexerElements lexerCommands )
{
// org/antlr/v4/parse/ANTLRParser.g:544: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:545: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();
// 545: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:549: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 lexerElement123 =null;
RewriteRuleSubtreeStream stream_lexerElement=new RewriteRuleSubtreeStream(adaptor,"rule lexerElement");
try {
// org/antlr/v4/parse/ANTLRParser.g:550:5: ( ( lexerElement )+ -> ^( ALT ( lexerElement )+ ) | -> ^( ALT EPSILON ) )
int alt34=2;
int LA34_0 = input.LA(1);
if ( (LA34_0==ACTION||LA34_0==DOT||LA34_0==LEXER_CHAR_SET||LA34_0==LPAREN||LA34_0==NOT||LA34_0==RULE_REF||LA34_0==SEMPRED||LA34_0==STRING_LITERAL||LA34_0==TOKEN_REF) ) {
alt34=1;
}
else if ( (LA34_0==OR||LA34_0==RARROW||LA34_0==RPAREN||LA34_0==SEMI) ) {
alt34=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 34, 0, input);
throw nvae;
}
switch (alt34) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:550:7: ( lexerElement )+
{
// org/antlr/v4/parse/ANTLRParser.g:550:7: ( lexerElement )+
int cnt33=0;
loop33:
while (true) {
int alt33=2;
int LA33_0 = input.LA(1);
if ( (LA33_0==ACTION||LA33_0==DOT||LA33_0==LEXER_CHAR_SET||LA33_0==LPAREN||LA33_0==NOT||LA33_0==RULE_REF||LA33_0==SEMPRED||LA33_0==STRING_LITERAL||LA33_0==TOKEN_REF) ) {
alt33=1;
}
switch (alt33) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:550:7: lexerElement
{
pushFollow(FOLLOW_lexerElement_in_lexerElements2309);
lexerElement123=lexerElement();
state._fsp--;
stream_lexerElement.add(lexerElement123.getTree());
}
break;
default :
if ( cnt33 >= 1 ) break loop33;
EarlyExitException eee = new EarlyExitException(33, input);
throw eee;
}
cnt33++;
}
// 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();
// 550:21: -> ^( ALT ( lexerElement )+ )
{
// org/antlr/v4/parse/ANTLRParser.g:550: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:551: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();
// 551:8: -> ^( ALT EPSILON )
{
// org/antlr/v4/parse/ANTLRParser.g:551: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:554: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 labeledLexerElement124 =null;
ParserRuleReturnScope ebnfSuffix125 =null;
ParserRuleReturnScope lexerAtom126 =null;
ParserRuleReturnScope ebnfSuffix127 =null;
ParserRuleReturnScope lexerBlock128 =null;
ParserRuleReturnScope ebnfSuffix129 =null;
ParserRuleReturnScope actionElement130 =null;
RewriteRuleSubtreeStream stream_ebnfSuffix=new RewriteRuleSubtreeStream(adaptor,"rule ebnfSuffix");
RewriteRuleSubtreeStream stream_lexerBlock=new RewriteRuleSubtreeStream(adaptor,"rule lexerBlock");
RewriteRuleSubtreeStream stream_labeledLexerElement=new RewriteRuleSubtreeStream(adaptor,"rule labeledLexerElement");
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:560: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 alt38=4;
switch ( input.LA(1) ) {
case RULE_REF:
{
int LA38_1 = input.LA(2);
if ( (LA38_1==ASSIGN||LA38_1==PLUS_ASSIGN) ) {
alt38=1;
}
else if ( (LA38_1==ACTION||LA38_1==DOT||LA38_1==LEXER_CHAR_SET||LA38_1==LPAREN||LA38_1==NOT||LA38_1==OR||LA38_1==PLUS||LA38_1==QUESTION||LA38_1==RARROW||(LA38_1 >= RPAREN && LA38_1 <= SEMPRED)||(LA38_1 >= STAR && LA38_1 <= STRING_LITERAL)||LA38_1==TOKEN_REF) ) {
alt38=2;
}
else {
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 38, 1, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case TOKEN_REF:
{
int LA38_2 = input.LA(2);
if ( (LA38_2==ASSIGN||LA38_2==PLUS_ASSIGN) ) {
alt38=1;
}
else if ( (LA38_2==ACTION||LA38_2==DOT||LA38_2==LEXER_CHAR_SET||(LA38_2 >= LPAREN && LA38_2 <= LT)||LA38_2==NOT||LA38_2==OR||LA38_2==PLUS||LA38_2==QUESTION||LA38_2==RARROW||(LA38_2 >= RPAREN && LA38_2 <= SEMPRED)||(LA38_2 >= STAR && LA38_2 <= STRING_LITERAL)||LA38_2==TOKEN_REF) ) {
alt38=2;
}
else {
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 38, 2, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case DOT:
case LEXER_CHAR_SET:
case NOT:
case STRING_LITERAL:
{
alt38=2;
}
break;
case LPAREN:
{
alt38=3;
}
break;
case ACTION:
case SEMPRED:
{
alt38=4;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 38, 0, input);
throw nvae;
}
switch (alt38) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:560:4: labeledLexerElement ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[$labeledLexerElement.start,\"BLOCK\"] ^( ALT labeledLexerElement ) ) ) | -> labeledLexerElement )
{
pushFollow(FOLLOW_labeledLexerElement_in_lexerElement2365);
labeledLexerElement124=labeledLexerElement();
state._fsp--;
stream_labeledLexerElement.add(labeledLexerElement124.getTree());
// org/antlr/v4/parse/ANTLRParser.g:561:3: ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[$labeledLexerElement.start,\"BLOCK\"] ^( ALT labeledLexerElement ) ) ) | -> labeledLexerElement )
int alt35=2;
int LA35_0 = input.LA(1);
if ( (LA35_0==PLUS||LA35_0==QUESTION||LA35_0==STAR) ) {
alt35=1;
}
else if ( (LA35_0==ACTION||LA35_0==DOT||LA35_0==LEXER_CHAR_SET||LA35_0==LPAREN||LA35_0==NOT||LA35_0==OR||LA35_0==RARROW||(LA35_0 >= RPAREN && LA35_0 <= SEMPRED)||LA35_0==STRING_LITERAL||LA35_0==TOKEN_REF) ) {
alt35=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 35, 0, input);
throw nvae;
}
switch (alt35) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:561:5: ebnfSuffix
{
pushFollow(FOLLOW_ebnfSuffix_in_lexerElement2371);
ebnfSuffix125=ebnfSuffix();
state._fsp--;
stream_ebnfSuffix.add(ebnfSuffix125.getTree());
// AST REWRITE
// elements: ebnfSuffix, 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();
// 561:16: -> ^( ebnfSuffix ^( BLOCK[$labeledLexerElement.start,\"BLOCK\"] ^( ALT labeledLexerElement ) ) )
{
// org/antlr/v4/parse/ANTLRParser.g:561: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:561:33: ^( BLOCK[$labeledLexerElement.start,\"BLOCK\"] ^( ALT labeledLexerElement ) )
{
GrammarAST root_2 = (GrammarAST)adaptor.nil();
root_2 = (GrammarAST)adaptor.becomeRoot(new BlockAST(BLOCK, (labeledLexerElement124!=null?(labeledLexerElement124.start):null), "BLOCK"), root_2);
// org/antlr/v4/parse/ANTLRParser.g:561: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:562: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();
// 562:8: -> labeledLexerElement
{
adaptor.addChild(root_0, stream_labeledLexerElement.nextTree());
}
retval.tree = root_0;
}
break;
}
}
break;
case 2 :
// org/antlr/v4/parse/ANTLRParser.g:564:4: lexerAtom ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[$lexerAtom.start,\"BLOCK\"] ^( ALT lexerAtom ) ) ) | -> lexerAtom )
{
pushFollow(FOLLOW_lexerAtom_in_lexerElement2417);
lexerAtom126=lexerAtom();
state._fsp--;
stream_lexerAtom.add(lexerAtom126.getTree());
// org/antlr/v4/parse/ANTLRParser.g:565:3: ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[$lexerAtom.start,\"BLOCK\"] ^( ALT lexerAtom ) ) ) | -> lexerAtom )
int alt36=2;
int LA36_0 = input.LA(1);
if ( (LA36_0==PLUS||LA36_0==QUESTION||LA36_0==STAR) ) {
alt36=1;
}
else if ( (LA36_0==ACTION||LA36_0==DOT||LA36_0==LEXER_CHAR_SET||LA36_0==LPAREN||LA36_0==NOT||LA36_0==OR||LA36_0==RARROW||(LA36_0 >= RPAREN && LA36_0 <= SEMPRED)||LA36_0==STRING_LITERAL||LA36_0==TOKEN_REF) ) {
alt36=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 36, 0, input);
throw nvae;
}
switch (alt36) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:565:5: ebnfSuffix
{
pushFollow(FOLLOW_ebnfSuffix_in_lexerElement2423);
ebnfSuffix127=ebnfSuffix();
state._fsp--;
stream_ebnfSuffix.add(ebnfSuffix127.getTree());
// AST REWRITE
// elements: lexerAtom, 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();
// 565:16: -> ^( ebnfSuffix ^( BLOCK[$lexerAtom.start,\"BLOCK\"] ^( ALT lexerAtom ) ) )
{
// org/antlr/v4/parse/ANTLRParser.g:565: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:565:33: ^( BLOCK[$lexerAtom.start,\"BLOCK\"] ^( ALT lexerAtom ) )
{
GrammarAST root_2 = (GrammarAST)adaptor.nil();
root_2 = (GrammarAST)adaptor.becomeRoot(new BlockAST(BLOCK, (lexerAtom126!=null?(lexerAtom126.start):null), "BLOCK"), root_2);
// org/antlr/v4/parse/ANTLRParser.g:565: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:566: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();
// 566:8: -> lexerAtom
{
adaptor.addChild(root_0, stream_lexerAtom.nextTree());
}
retval.tree = root_0;
}
break;
}
}
break;
case 3 :
// org/antlr/v4/parse/ANTLRParser.g:568:4: lexerBlock ( ebnfSuffix -> ^( ebnfSuffix lexerBlock ) | -> lexerBlock )
{
pushFollow(FOLLOW_lexerBlock_in_lexerElement2469);
lexerBlock128=lexerBlock();
state._fsp--;
stream_lexerBlock.add(lexerBlock128.getTree());
// org/antlr/v4/parse/ANTLRParser.g:569:3: ( ebnfSuffix -> ^( ebnfSuffix lexerBlock ) | -> lexerBlock )
int alt37=2;
int LA37_0 = input.LA(1);
if ( (LA37_0==PLUS||LA37_0==QUESTION||LA37_0==STAR) ) {
alt37=1;
}
else if ( (LA37_0==ACTION||LA37_0==DOT||LA37_0==LEXER_CHAR_SET||LA37_0==LPAREN||LA37_0==NOT||LA37_0==OR||LA37_0==RARROW||(LA37_0 >= RPAREN && LA37_0 <= SEMPRED)||LA37_0==STRING_LITERAL||LA37_0==TOKEN_REF) ) {
alt37=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 37, 0, input);
throw nvae;
}
switch (alt37) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:569:5: ebnfSuffix
{
pushFollow(FOLLOW_ebnfSuffix_in_lexerElement2475);
ebnfSuffix129=ebnfSuffix();
state._fsp--;
stream_ebnfSuffix.add(ebnfSuffix129.getTree());
// AST REWRITE
// elements: ebnfSuffix, 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();
// 569:16: -> ^( ebnfSuffix lexerBlock )
{
// org/antlr/v4/parse/ANTLRParser.g:569: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:570: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();
// 570:8: -> lexerBlock
{
adaptor.addChild(root_0, stream_lexerBlock.nextTree());
}
retval.tree = root_0;
}
break;
}
}
break;
case 4 :
// org/antlr/v4/parse/ANTLRParser.g:572:4: actionElement
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_actionElement_in_lexerElement2503);
actionElement130=actionElement();
state._fsp--;
adaptor.addChild(root_0, actionElement130.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:605: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 id131 =null;
ParserRuleReturnScope lexerAtom132 =null;
ParserRuleReturnScope lexerBlock133 =null;
GrammarAST ass_tree=null;
RewriteRuleTokenStream stream_ASSIGN=new RewriteRuleTokenStream(adaptor,"token ASSIGN");
RewriteRuleTokenStream stream_PLUS_ASSIGN=new RewriteRuleTokenStream(adaptor,"token PLUS_ASSIGN");
RewriteRuleSubtreeStream stream_id=new RewriteRuleSubtreeStream(adaptor,"rule id");
RewriteRuleSubtreeStream stream_lexerBlock=new RewriteRuleSubtreeStream(adaptor,"rule lexerBlock");
RewriteRuleSubtreeStream stream_lexerAtom=new RewriteRuleSubtreeStream(adaptor,"rule lexerAtom");
try {
// org/antlr/v4/parse/ANTLRParser.g:606:2: ( id (ass= ASSIGN |ass= PLUS_ASSIGN ) ( lexerAtom -> ^( $ass id lexerAtom ) | lexerBlock -> ^( $ass id lexerBlock ) ) )
// org/antlr/v4/parse/ANTLRParser.g:606:4: id (ass= ASSIGN |ass= PLUS_ASSIGN ) ( lexerAtom -> ^( $ass id lexerAtom ) | lexerBlock -> ^( $ass id lexerBlock ) )
{
pushFollow(FOLLOW_id_in_labeledLexerElement2533);
id131=id();
state._fsp--;
stream_id.add(id131.getTree());
// org/antlr/v4/parse/ANTLRParser.g:606:7: (ass= ASSIGN |ass= PLUS_ASSIGN )
int alt39=2;
int LA39_0 = input.LA(1);
if ( (LA39_0==ASSIGN) ) {
alt39=1;
}
else if ( (LA39_0==PLUS_ASSIGN) ) {
alt39=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 39, 0, input);
throw nvae;
}
switch (alt39) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:606:8: ass= ASSIGN
{
ass=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_labeledLexerElement2538);
stream_ASSIGN.add(ass);
}
break;
case 2 :
// org/antlr/v4/parse/ANTLRParser.g:606:19: ass= PLUS_ASSIGN
{
ass=(Token)match(input,PLUS_ASSIGN,FOLLOW_PLUS_ASSIGN_in_labeledLexerElement2542);
stream_PLUS_ASSIGN.add(ass);
}
break;
}
// org/antlr/v4/parse/ANTLRParser.g:607:3: ( lexerAtom -> ^( $ass id lexerAtom ) | lexerBlock -> ^( $ass id lexerBlock ) )
int alt40=2;
int LA40_0 = input.LA(1);
if ( (LA40_0==DOT||LA40_0==LEXER_CHAR_SET||LA40_0==NOT||LA40_0==RULE_REF||LA40_0==STRING_LITERAL||LA40_0==TOKEN_REF) ) {
alt40=1;
}
else if ( (LA40_0==LPAREN) ) {
alt40=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 40, 0, input);
throw nvae;
}
switch (alt40) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:607:5: lexerAtom
{
pushFollow(FOLLOW_lexerAtom_in_labeledLexerElement2549);
lexerAtom132=lexerAtom();
state._fsp--;
stream_lexerAtom.add(lexerAtom132.getTree());
// AST REWRITE
// elements: ass, lexerAtom, 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();
// 607:15: -> ^( $ass id lexerAtom )
{
// org/antlr/v4/parse/ANTLRParser.g:607: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:608:5: lexerBlock
{
pushFollow(FOLLOW_lexerBlock_in_labeledLexerElement2566);
lexerBlock133=lexerBlock();
state._fsp--;
stream_lexerBlock.add(lexerBlock133.getTree());
// AST REWRITE
// elements: ass, lexerBlock, 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();
// 608:16: -> ^( $ass id lexerBlock )
{
// org/antlr/v4/parse/ANTLRParser.g:608: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:613: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 LPAREN134=null;
Token COLON136=null;
Token RPAREN138=null;
ParserRuleReturnScope optionsSpec135 =null;
ParserRuleReturnScope lexerAltList137 =null;
GrammarAST LPAREN134_tree=null;
GrammarAST COLON136_tree=null;
GrammarAST RPAREN138_tree=null;
RewriteRuleTokenStream stream_COLON=new RewriteRuleTokenStream(adaptor,"token COLON");
RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
RewriteRuleSubtreeStream stream_optionsSpec=new RewriteRuleSubtreeStream(adaptor,"rule optionsSpec");
RewriteRuleSubtreeStream stream_lexerAltList=new RewriteRuleSubtreeStream(adaptor,"rule lexerAltList");
try {
// org/antlr/v4/parse/ANTLRParser.g:620:3: ( LPAREN ( optionsSpec COLON )? lexerAltList RPAREN -> ^( BLOCK[$LPAREN,\"BLOCK\"] ( optionsSpec )? lexerAltList ) )
// org/antlr/v4/parse/ANTLRParser.g:620:5: LPAREN ( optionsSpec COLON )? lexerAltList RPAREN
{
LPAREN134=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_lexerBlock2599);
stream_LPAREN.add(LPAREN134);
// org/antlr/v4/parse/ANTLRParser.g:621:9: ( optionsSpec COLON )?
int alt41=2;
int LA41_0 = input.LA(1);
if ( (LA41_0==OPTIONS) ) {
alt41=1;
}
switch (alt41) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:621:11: optionsSpec COLON
{
pushFollow(FOLLOW_optionsSpec_in_lexerBlock2611);
optionsSpec135=optionsSpec();
state._fsp--;
stream_optionsSpec.add(optionsSpec135.getTree());
COLON136=(Token)match(input,COLON,FOLLOW_COLON_in_lexerBlock2613);
stream_COLON.add(COLON136);
}
break;
}
pushFollow(FOLLOW_lexerAltList_in_lexerBlock2626);
lexerAltList137=lexerAltList();
state._fsp--;
stream_lexerAltList.add(lexerAltList137.getTree());
RPAREN138=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_lexerBlock2636);
stream_RPAREN.add(RPAREN138);
// AST REWRITE
// elements: lexerAltList, optionsSpec
// 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();
// 624:7: -> ^( BLOCK[$LPAREN,\"BLOCK\"] ( optionsSpec )? lexerAltList )
{
// org/antlr/v4/parse/ANTLRParser.g:624:10: ^( BLOCK[$LPAREN,\"BLOCK\"] ( optionsSpec )? lexerAltList )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot(new BlockAST(BLOCK, LPAREN134, "BLOCK"), root_1);
// org/antlr/v4/parse/ANTLRParser.g:624: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:628: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 RARROW139=null;
Token COMMA141=null;
ParserRuleReturnScope lexerCommand140 =null;
ParserRuleReturnScope lexerCommand142 =null;
GrammarAST RARROW139_tree=null;
GrammarAST COMMA141_tree=null;
RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
RewriteRuleTokenStream stream_RARROW=new RewriteRuleTokenStream(adaptor,"token RARROW");
RewriteRuleSubtreeStream stream_lexerCommand=new RewriteRuleSubtreeStream(adaptor,"rule lexerCommand");
try {
// org/antlr/v4/parse/ANTLRParser.g:629:2: ( RARROW lexerCommand ( COMMA lexerCommand )* -> ( lexerCommand )+ )
// org/antlr/v4/parse/ANTLRParser.g:629:4: RARROW lexerCommand ( COMMA lexerCommand )*
{
RARROW139=(Token)match(input,RARROW,FOLLOW_RARROW_in_lexerCommands2673);
stream_RARROW.add(RARROW139);
pushFollow(FOLLOW_lexerCommand_in_lexerCommands2675);
lexerCommand140=lexerCommand();
state._fsp--;
stream_lexerCommand.add(lexerCommand140.getTree());
// org/antlr/v4/parse/ANTLRParser.g:629:24: ( COMMA lexerCommand )*
loop42:
while (true) {
int alt42=2;
int LA42_0 = input.LA(1);
if ( (LA42_0==COMMA) ) {
alt42=1;
}
switch (alt42) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:629:25: COMMA lexerCommand
{
COMMA141=(Token)match(input,COMMA,FOLLOW_COMMA_in_lexerCommands2678);
stream_COMMA.add(COMMA141);
pushFollow(FOLLOW_lexerCommand_in_lexerCommands2680);
lexerCommand142=lexerCommand();
state._fsp--;
stream_lexerCommand.add(lexerCommand142.getTree());
}
break;
default :
break loop42;
}
}
// 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();
// 629: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:632: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 LPAREN144=null;
Token RPAREN146=null;
ParserRuleReturnScope lexerCommandName143 =null;
ParserRuleReturnScope lexerCommandExpr145 =null;
ParserRuleReturnScope lexerCommandName147 =null;
GrammarAST LPAREN144_tree=null;
GrammarAST RPAREN146_tree=null;
RewriteRuleTokenStream stream_RPAREN=new RewriteRuleTokenStream(adaptor,"token RPAREN");
RewriteRuleTokenStream stream_LPAREN=new RewriteRuleTokenStream(adaptor,"token LPAREN");
RewriteRuleSubtreeStream stream_lexerCommandName=new RewriteRuleSubtreeStream(adaptor,"rule lexerCommandName");
RewriteRuleSubtreeStream stream_lexerCommandExpr=new RewriteRuleSubtreeStream(adaptor,"rule lexerCommandExpr");
try {
// org/antlr/v4/parse/ANTLRParser.g:633:2: ( lexerCommandName LPAREN lexerCommandExpr RPAREN -> ^( LEXER_ACTION_CALL lexerCommandName lexerCommandExpr ) | lexerCommandName )
int alt43=2;
switch ( input.LA(1) ) {
case RULE_REF:
{
int LA43_1 = input.LA(2);
if ( (LA43_1==LPAREN) ) {
alt43=1;
}
else if ( (LA43_1==COMMA||LA43_1==OR||LA43_1==RPAREN||LA43_1==SEMI) ) {
alt43=2;
}
else {
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 43, 1, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case TOKEN_REF:
{
int LA43_2 = input.LA(2);
if ( (LA43_2==LPAREN) ) {
alt43=1;
}
else if ( (LA43_2==COMMA||LA43_2==OR||LA43_2==RPAREN||LA43_2==SEMI) ) {
alt43=2;
}
else {
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 43, 2, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case MODE:
{
int LA43_3 = input.LA(2);
if ( (LA43_3==LPAREN) ) {
alt43=1;
}
else if ( (LA43_3==COMMA||LA43_3==OR||LA43_3==RPAREN||LA43_3==SEMI) ) {
alt43=2;
}
else {
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 43, 3, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 43, 0, input);
throw nvae;
}
switch (alt43) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:633:4: lexerCommandName LPAREN lexerCommandExpr RPAREN
{
pushFollow(FOLLOW_lexerCommandName_in_lexerCommand2698);
lexerCommandName143=lexerCommandName();
state._fsp--;
stream_lexerCommandName.add(lexerCommandName143.getTree());
LPAREN144=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_lexerCommand2700);
stream_LPAREN.add(LPAREN144);
pushFollow(FOLLOW_lexerCommandExpr_in_lexerCommand2702);
lexerCommandExpr145=lexerCommandExpr();
state._fsp--;
stream_lexerCommandExpr.add(lexerCommandExpr145.getTree());
RPAREN146=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_lexerCommand2704);
stream_RPAREN.add(RPAREN146);
// 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();
// 633:52: -> ^( LEXER_ACTION_CALL lexerCommandName lexerCommandExpr )
{
// org/antlr/v4/parse/ANTLRParser.g:633: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:634:4: lexerCommandName
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_lexerCommandName_in_lexerCommand2719);
lexerCommandName147=lexerCommandName();
state._fsp--;
adaptor.addChild(root_0, lexerCommandName147.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:637: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 INT149=null;
ParserRuleReturnScope id148 =null;
GrammarAST INT149_tree=null;
try {
// org/antlr/v4/parse/ANTLRParser.g:638:2: ( id | INT )
int alt44=2;
int LA44_0 = input.LA(1);
if ( (LA44_0==RULE_REF||LA44_0==TOKEN_REF) ) {
alt44=1;
}
else if ( (LA44_0==INT) ) {
alt44=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 44, 0, input);
throw nvae;
}
switch (alt44) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:638:4: id
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_id_in_lexerCommandExpr2730);
id148=id();
state._fsp--;
adaptor.addChild(root_0, id148.getTree());
}
break;
case 2 :
// org/antlr/v4/parse/ANTLRParser.g:639:4: INT
{
root_0 = (GrammarAST)adaptor.nil();
INT149=(Token)match(input,INT,FOLLOW_INT_in_lexerCommandExpr2735);
INT149_tree = (GrammarAST)adaptor.create(INT149);
adaptor.addChild(root_0, INT149_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:642: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 MODE151=null;
ParserRuleReturnScope id150 =null;
GrammarAST MODE151_tree=null;
RewriteRuleTokenStream stream_MODE=new RewriteRuleTokenStream(adaptor,"token MODE");
try {
// org/antlr/v4/parse/ANTLRParser.g:643:9: ( id | MODE -> ID[$MODE] )
int alt45=2;
int LA45_0 = input.LA(1);
if ( (LA45_0==RULE_REF||LA45_0==TOKEN_REF) ) {
alt45=1;
}
else if ( (LA45_0==MODE) ) {
alt45=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 45, 0, input);
throw nvae;
}
switch (alt45) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:643:17: id
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_id_in_lexerCommandName2759);
id150=id();
state._fsp--;
adaptor.addChild(root_0, id150.getTree());
}
break;
case 2 :
// org/antlr/v4/parse/ANTLRParser.g:644:17: MODE
{
MODE151=(Token)match(input,MODE,FOLLOW_MODE_in_lexerCommandName2777);
stream_MODE.add(MODE151);
// 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();
// 644:25: -> ID[$MODE]
{
adaptor.addChild(root_0, (GrammarAST)adaptor.create(ID, MODE151));
}
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:647: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 OR153=null;
ParserRuleReturnScope alternative152 =null;
ParserRuleReturnScope alternative154 =null;
GrammarAST OR153_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:648:5: ( alternative ( OR alternative )* -> ( alternative )+ )
// org/antlr/v4/parse/ANTLRParser.g:648:7: alternative ( OR alternative )*
{
pushFollow(FOLLOW_alternative_in_altList2805);
alternative152=alternative();
state._fsp--;
stream_alternative.add(alternative152.getTree());
// org/antlr/v4/parse/ANTLRParser.g:648:19: ( OR alternative )*
loop46:
while (true) {
int alt46=2;
int LA46_0 = input.LA(1);
if ( (LA46_0==OR) ) {
alt46=1;
}
switch (alt46) {
case 1 :
// org/antlr/v4/parse/ANTLRParser.g:648:20: OR alternative
{
OR153=(Token)match(input,OR,FOLLOW_OR_in_altList2808);
stream_OR.add(OR153);
pushFollow(FOLLOW_alternative_in_altList2810);
alternative154=alternative();
state._fsp--;
stream_alternative.add(alternative154.getTree());
}
break;
default :
break loop46;
}
}
// 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();
// 648: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:652: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