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 antlr4 Show documentation
Show all versions of antlr4 Show documentation
The ANTLR 4 grammar compiler.
// $ANTLR 3.5.2 org\\antlr\\v4\\parse\\ANTLRParser.g 2015-05-22 01:33:43
/*
[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",
"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 UnicodeBOM=69;
public static final int WS=70;
public static final int WSCHARS=71;
public static final int WSNLCHARS=72;
public static final int ALT=73;
public static final int ALTLIST=74;
public static final int ARG=75;
public static final int ARGLIST=76;
public static final int BLOCK=77;
public static final int CHAR_RANGE=78;
public static final int CLOSURE=79;
public static final int COMBINED=80;
public static final int ELEMENT_OPTIONS=81;
public static final int EPSILON=82;
public static final int INITACTION=83;
public static final int LABEL=84;
public static final int LEXER_ACTION_CALL=85;
public static final int LEXER_ALT_ACTION=86;
public static final int LIST=87;
public static final int OPTIONAL=88;
public static final int POSITIVE_CLOSURE=89;
public static final int PREC_RULE=90;
public static final int RESULT=91;
public static final int RET=92;
public static final int RULE=93;
public static final int RULEACTIONS=94;
public static final int RULEMODIFIERS=95;
public static final int RULES=96;
public static final int SET=97;
public static final int TEMPLATE=98;
public static final int WILDCARD=99;
// 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: modeSpec, prequelConstruct, rules, id, grammarType
// 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: OPTIONS, option
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 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 )* ( COMMA )? RBRACE -> ^( TOKENS_SPEC ( id )+ ) | TOKENS_SPEC RBRACE ->| TOKENS_SPEC ^ ( v3tokenSpec )+ RBRACE !);
public final ANTLRParser.tokensSpec_return tokensSpec() throws RecognitionException {
ANTLRParser.tokensSpec_return retval = new ANTLRParser.tokensSpec_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token TOKENS_SPEC35=null;
Token COMMA37=null;
Token COMMA39=null;
Token RBRACE40=null;
Token TOKENS_SPEC41=null;
Token RBRACE42=null;
Token TOKENS_SPEC43=null;
Token RBRACE45=null;
ParserRuleReturnScope id36 =null;
ParserRuleReturnScope id38 =null;
ParserRuleReturnScope v3tokenSpec44 =null;
GrammarAST TOKENS_SPEC35_tree=null;
GrammarAST COMMA37_tree=null;
GrammarAST COMMA39_tree=null;
GrammarAST RBRACE40_tree=null;
GrammarAST TOKENS_SPEC41_tree=null;
GrammarAST RBRACE42_tree=null;
GrammarAST TOKENS_SPEC43_tree=null;
GrammarAST RBRACE45_tree=null;
RewriteRuleTokenStream stream_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 )* ( COMMA )? RBRACE -> ^( TOKENS_SPEC ( id )+ ) | TOKENS_SPEC RBRACE ->| TOKENS_SPEC ^ ( v3tokenSpec )+ RBRACE !)
int alt12=3;
int LA12_0 = input.LA(1);
if ( (LA12_0==TOKENS_SPEC) ) {
switch ( input.LA(2) ) {
case RBRACE:
{
alt12=2;
}
break;
case RULE_REF:
{
int LA12_3 = input.LA(3);
if ( (LA12_3==COMMA||LA12_3==RBRACE) ) {
alt12=1;
}
else if ( (LA12_3==ASSIGN||LA12_3==SEMI) ) {
alt12=3;
}
else {
int nvaeMark = input.mark();
try {
for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) {
input.consume();
}
NoViableAltException nvae =
new NoViableAltException("", 12, 3, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case TOKEN_REF:
{
int LA12_4 = input.LA(3);
if ( (LA12_4==COMMA||LA12_4==RBRACE) ) {
alt12=1;
}
else if ( (LA12_4==ASSIGN||LA12_4==SEMI) ) {
alt12=3;
}
else {
int nvaeMark = input.mark();
try {
for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) {
input.consume();
}
NoViableAltException nvae =
new NoViableAltException("", 12, 4, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
default:
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 12, 1, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
else {
NoViableAltException nvae =
new NoViableAltException("", 12, 0, input);
throw nvae;
}
switch (alt12) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:281:4: TOKENS_SPEC id ( COMMA id )* ( COMMA )? RBRACE
{
TOKENS_SPEC35=(Token)match(input,TOKENS_SPEC,FOLLOW_TOKENS_SPEC_in_tokensSpec1110);
stream_TOKENS_SPEC.add(TOKENS_SPEC35);
pushFollow(FOLLOW_id_in_tokensSpec1112);
id36=id();
state._fsp--;
stream_id.add(id36.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:281:19: ( COMMA id )*
loop9:
while (true) {
int alt9=2;
int LA9_0 = input.LA(1);
if ( (LA9_0==COMMA) ) {
int LA9_1 = input.LA(2);
if ( (LA9_1==RULE_REF||LA9_1==TOKEN_REF) ) {
alt9=1;
}
}
switch (alt9) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g: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;
}
}
// org\\antlr\\v4\\parse\\ANTLRParser.g:281:31: ( COMMA )?
int alt10=2;
int LA10_0 = input.LA(1);
if ( (LA10_0==COMMA) ) {
alt10=1;
}
switch (alt10) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:281:31: COMMA
{
COMMA39=(Token)match(input,COMMA,FOLLOW_COMMA_in_tokensSpec1121);
stream_COMMA.add(COMMA39);
}
break;
}
RBRACE40=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_tokensSpec1124);
stream_RBRACE.add(RBRACE40);
// AST REWRITE
// elements: TOKENS_SPEC, id
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 281:45: -> ^( TOKENS_SPEC ( id )+ )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:281:48: ^( TOKENS_SPEC ( id )+ )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot(stream_TOKENS_SPEC.nextNode(), root_1);
if ( !(stream_id.hasNext()) ) {
throw new RewriteEarlyExitException();
}
while ( stream_id.hasNext() ) {
adaptor.addChild(root_1, stream_id.nextTree());
}
stream_id.reset();
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:282:7: TOKENS_SPEC RBRACE
{
TOKENS_SPEC41=(Token)match(input,TOKENS_SPEC,FOLLOW_TOKENS_SPEC_in_tokensSpec1141);
stream_TOKENS_SPEC.add(TOKENS_SPEC41);
RBRACE42=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_tokensSpec1143);
stream_RBRACE.add(RBRACE42);
// AST REWRITE
// elements:
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 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_SPEC43=(Token)match(input,TOKENS_SPEC,FOLLOW_TOKENS_SPEC_in_tokensSpec1153);
TOKENS_SPEC43_tree = (GrammarAST)adaptor.create(TOKENS_SPEC43);
root_0 = (GrammarAST)adaptor.becomeRoot(TOKENS_SPEC43_tree, root_0);
// org\\antlr\\v4\\parse\\ANTLRParser.g:283:20: ( v3tokenSpec )+
int cnt11=0;
loop11:
while (true) {
int alt11=2;
int LA11_0 = input.LA(1);
if ( (LA11_0==RULE_REF||LA11_0==TOKEN_REF) ) {
alt11=1;
}
switch (alt11) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:283:20: v3tokenSpec
{
pushFollow(FOLLOW_v3tokenSpec_in_tokensSpec1156);
v3tokenSpec44=v3tokenSpec();
state._fsp--;
adaptor.addChild(root_0, v3tokenSpec44.getTree());
}
break;
default :
if ( cnt11 >= 1 ) break loop11;
EarlyExitException eee = new EarlyExitException(11, input);
throw eee;
}
cnt11++;
}
RBRACE45=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_tokensSpec1159);
grammarError(ErrorType.V3_TOKENS_SYNTAX, TOKENS_SPEC43);
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "tokensSpec"
public static class v3tokenSpec_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "v3tokenSpec"
// org\\antlr\\v4\\parse\\ANTLRParser.g: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 ASSIGN47=null;
Token SEMI48=null;
ParserRuleReturnScope id46 =null;
GrammarAST lit_tree=null;
GrammarAST ASSIGN47_tree=null;
GrammarAST SEMI48_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_v3tokenSpec1179);
id46=id();
state._fsp--;
stream_id.add(id46.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:289:3: ( ASSIGN lit= STRING_LITERAL -> id | -> id )
int alt13=2;
int LA13_0 = input.LA(1);
if ( (LA13_0==ASSIGN) ) {
alt13=1;
}
else if ( (LA13_0==SEMI) ) {
alt13=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 13, 0, input);
throw nvae;
}
switch (alt13) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:289:5: ASSIGN lit= STRING_LITERAL
{
ASSIGN47=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_v3tokenSpec1185);
stream_ASSIGN.add(ASSIGN47);
lit=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_v3tokenSpec1189);
stream_STRING_LITERAL.add(lit);
grammarError(ErrorType.V3_ASSIGN_IN_TOKENS, (id46!=null?(id46.start):null),
(id46!=null?input.toString(id46.start,id46.stop):null), lit.getText());
// AST REWRITE
// elements: id
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 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;
}
SEMI48=(Token)match(input,SEMI,FOLLOW_SEMI_in_v3tokenSpec1250);
stream_SEMI.add(SEMI48);
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "v3tokenSpec"
public static class channelsSpec_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "channelsSpec"
// org\\antlr\\v4\\parse\\ANTLRParser.g:300:1: channelsSpec : CHANNELS ^ ( id ( COMMA ! id )* ( COMMA )? )? RBRACE !;
public final ANTLRParser.channelsSpec_return channelsSpec() throws RecognitionException {
ANTLRParser.channelsSpec_return retval = new ANTLRParser.channelsSpec_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token CHANNELS49=null;
Token COMMA51=null;
Token COMMA53=null;
Token RBRACE54=null;
ParserRuleReturnScope id50 =null;
ParserRuleReturnScope id52 =null;
GrammarAST CHANNELS49_tree=null;
GrammarAST COMMA51_tree=null;
GrammarAST COMMA53_tree=null;
GrammarAST RBRACE54_tree=null;
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:301:2: ( CHANNELS ^ ( id ( COMMA ! id )* ( COMMA )? )? RBRACE !)
// org\\antlr\\v4\\parse\\ANTLRParser.g:301:4: CHANNELS ^ ( id ( COMMA ! id )* ( COMMA )? )? RBRACE !
{
root_0 = (GrammarAST)adaptor.nil();
CHANNELS49=(Token)match(input,CHANNELS,FOLLOW_CHANNELS_in_channelsSpec1261);
CHANNELS49_tree = (GrammarAST)adaptor.create(CHANNELS49);
root_0 = (GrammarAST)adaptor.becomeRoot(CHANNELS49_tree, root_0);
// org\\antlr\\v4\\parse\\ANTLRParser.g:301:14: ( id ( COMMA ! id )* ( COMMA )? )?
int alt16=2;
int LA16_0 = input.LA(1);
if ( (LA16_0==RULE_REF||LA16_0==TOKEN_REF) ) {
alt16=1;
}
switch (alt16) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:301:15: id ( COMMA ! id )* ( COMMA )?
{
pushFollow(FOLLOW_id_in_channelsSpec1265);
id50=id();
state._fsp--;
adaptor.addChild(root_0, id50.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:301:18: ( COMMA ! id )*
loop14:
while (true) {
int alt14=2;
int LA14_0 = input.LA(1);
if ( (LA14_0==COMMA) ) {
int LA14_1 = input.LA(2);
if ( (LA14_1==RULE_REF||LA14_1==TOKEN_REF) ) {
alt14=1;
}
}
switch (alt14) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:301:19: COMMA ! id
{
COMMA51=(Token)match(input,COMMA,FOLLOW_COMMA_in_channelsSpec1268);
pushFollow(FOLLOW_id_in_channelsSpec1271);
id52=id();
state._fsp--;
adaptor.addChild(root_0, id52.getTree());
}
break;
default :
break loop14;
}
}
// org\\antlr\\v4\\parse\\ANTLRParser.g:301:31: ( COMMA )?
int alt15=2;
int LA15_0 = input.LA(1);
if ( (LA15_0==COMMA) ) {
alt15=1;
}
switch (alt15) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:301:31: COMMA
{
COMMA53=(Token)match(input,COMMA,FOLLOW_COMMA_in_channelsSpec1275);
COMMA53_tree = (GrammarAST)adaptor.create(COMMA53);
adaptor.addChild(root_0, COMMA53_tree);
}
break;
}
}
break;
}
RBRACE54=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_channelsSpec1280);
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "channelsSpec"
public static class action_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "action"
// org\\antlr\\v4\\parse\\ANTLRParser.g: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 AT55=null;
Token COLONCOLON57=null;
Token ACTION59=null;
ParserRuleReturnScope actionScopeName56 =null;
ParserRuleReturnScope id58 =null;
GrammarAST AT55_tree=null;
GrammarAST COLONCOLON57_tree=null;
GrammarAST ACTION59_tree=null;
RewriteRuleTokenStream stream_AT=new RewriteRuleTokenStream(adaptor,"token AT");
RewriteRuleTokenStream stream_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
{
AT55=(Token)match(input,AT,FOLLOW_AT_in_action1297);
stream_AT.add(AT55);
// org\\antlr\\v4\\parse\\ANTLRParser.g:309:7: ( actionScopeName COLONCOLON )?
int alt17=2;
switch ( input.LA(1) ) {
case RULE_REF:
{
int LA17_1 = input.LA(2);
if ( (LA17_1==COLONCOLON) ) {
alt17=1;
}
}
break;
case TOKEN_REF:
{
int LA17_2 = input.LA(2);
if ( (LA17_2==COLONCOLON) ) {
alt17=1;
}
}
break;
case LEXER:
case PARSER:
{
alt17=1;
}
break;
}
switch (alt17) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:309:8: actionScopeName COLONCOLON
{
pushFollow(FOLLOW_actionScopeName_in_action1300);
actionScopeName56=actionScopeName();
state._fsp--;
stream_actionScopeName.add(actionScopeName56.getTree());
COLONCOLON57=(Token)match(input,COLONCOLON,FOLLOW_COLONCOLON_in_action1302);
stream_COLONCOLON.add(COLONCOLON57);
}
break;
}
pushFollow(FOLLOW_id_in_action1306);
id58=id();
state._fsp--;
stream_id.add(id58.getTree());
ACTION59=(Token)match(input,ACTION,FOLLOW_ACTION_in_action1308);
stream_ACTION.add(ACTION59);
// AST REWRITE
// elements: id, ACTION, AT, actionScopeName
// 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 LEXER61=null;
Token PARSER62=null;
ParserRuleReturnScope id60 =null;
GrammarAST LEXER61_tree=null;
GrammarAST PARSER62_tree=null;
RewriteRuleTokenStream stream_PARSER=new RewriteRuleTokenStream(adaptor,"token PARSER");
RewriteRuleTokenStream stream_LEXER=new RewriteRuleTokenStream(adaptor,"token LEXER");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:316:2: ( id | LEXER -> ID[$LEXER] | PARSER -> ID[$PARSER] )
int alt18=3;
switch ( input.LA(1) ) {
case RULE_REF:
case TOKEN_REF:
{
alt18=1;
}
break;
case LEXER:
{
alt18=2;
}
break;
case PARSER:
{
alt18=3;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 18, 0, input);
throw nvae;
}
switch (alt18) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:316:4: id
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_id_in_actionScopeName1337);
id60=id();
state._fsp--;
adaptor.addChild(root_0, id60.getTree());
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:317:4: LEXER
{
LEXER61=(Token)match(input,LEXER,FOLLOW_LEXER_in_actionScopeName1342);
stream_LEXER.add(LEXER61);
// AST REWRITE
// elements:
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 317:10: -> ID[$LEXER]
{
adaptor.addChild(root_0, (GrammarAST)adaptor.create(ID, LEXER61));
}
retval.tree = root_0;
}
break;
case 3 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:318:9: PARSER
{
PARSER62=(Token)match(input,PARSER,FOLLOW_PARSER_in_actionScopeName1357);
stream_PARSER.add(PARSER62);
// AST REWRITE
// elements:
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 318:16: -> ID[$PARSER]
{
adaptor.addChild(root_0, (GrammarAST)adaptor.create(ID, PARSER62));
}
retval.tree = root_0;
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "actionScopeName"
public static class modeSpec_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "modeSpec"
// org\\antlr\\v4\\parse\\ANTLRParser.g: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 MODE63=null;
Token SEMI65=null;
ParserRuleReturnScope id64 =null;
ParserRuleReturnScope sync66 =null;
ParserRuleReturnScope lexerRule67 =null;
ParserRuleReturnScope sync68 =null;
GrammarAST MODE63_tree=null;
GrammarAST SEMI65_tree=null;
RewriteRuleTokenStream stream_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 )*
{
MODE63=(Token)match(input,MODE,FOLLOW_MODE_in_modeSpec1376);
stream_MODE.add(MODE63);
pushFollow(FOLLOW_id_in_modeSpec1378);
id64=id();
state._fsp--;
stream_id.add(id64.getTree());
SEMI65=(Token)match(input,SEMI,FOLLOW_SEMI_in_modeSpec1380);
stream_SEMI.add(SEMI65);
pushFollow(FOLLOW_sync_in_modeSpec1382);
sync66=sync();
state._fsp--;
stream_sync.add(sync66.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:322:25: ( lexerRule sync )*
loop19:
while (true) {
int alt19=2;
int LA19_0 = input.LA(1);
if ( (LA19_0==FRAGMENT||LA19_0==TOKEN_REF) ) {
alt19=1;
}
switch (alt19) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:322:26: lexerRule sync
{
pushFollow(FOLLOW_lexerRule_in_modeSpec1385);
lexerRule67=lexerRule();
state._fsp--;
stream_lexerRule.add(lexerRule67.getTree());
pushFollow(FOLLOW_sync_in_modeSpec1387);
sync68=sync();
state._fsp--;
stream_sync.add(sync68.getTree());
}
break;
default :
break loop19;
}
}
// AST REWRITE
// elements: lexerRule, MODE, 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();
// 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 sync69 =null;
ParserRuleReturnScope rule70 =null;
ParserRuleReturnScope sync71 =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_rules1418);
sync69=sync();
state._fsp--;
stream_sync.add(sync69.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:326:12: ( rule sync )*
loop20:
while (true) {
int alt20=2;
int LA20_0 = input.LA(1);
if ( (LA20_0==FRAGMENT||LA20_0==RULE_REF||LA20_0==TOKEN_REF) ) {
alt20=1;
}
switch (alt20) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:326:13: rule sync
{
pushFollow(FOLLOW_rule_in_rules1421);
rule70=rule();
state._fsp--;
stream_rule.add(rule70.getTree());
pushFollow(FOLLOW_sync_in_rules1423);
sync71=sync();
state._fsp--;
stream_sync.add(sync71.getTree());
}
break;
default :
break loop20;
}
}
// AST REWRITE
// elements: rule
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 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 parserRule72 =null;
ParserRuleReturnScope lexerRule73 =null;
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:345:5: ( parserRule | lexerRule )
int alt21=2;
int LA21_0 = input.LA(1);
if ( (LA21_0==RULE_REF) ) {
alt21=1;
}
else if ( (LA21_0==FRAGMENT||LA21_0==TOKEN_REF) ) {
alt21=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 21, 0, input);
throw nvae;
}
switch (alt21) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:345:7: parserRule
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_parserRule_in_rule1485);
parserRule72=parserRule();
state._fsp--;
adaptor.addChild(root_0, parserRule72.getTree());
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:346:4: lexerRule
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_lexerRule_in_rule1490);
lexerRule73=lexerRule();
state._fsp--;
adaptor.addChild(root_0, lexerRule73.getTree());
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "rule"
public static class parserRule_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "parserRule"
// org\\antlr\\v4\\parse\\ANTLRParser.g: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_REF74=null;
Token ARG_ACTION75=null;
Token COLON80=null;
Token SEMI82=null;
ParserRuleReturnScope ruleReturns76 =null;
ParserRuleReturnScope throwsSpec77 =null;
ParserRuleReturnScope localsSpec78 =null;
ParserRuleReturnScope rulePrequels79 =null;
ParserRuleReturnScope ruleBlock81 =null;
ParserRuleReturnScope exceptionGroup83 =null;
GrammarAST RULE_REF74_tree=null;
GrammarAST ARG_ACTION75_tree=null;
GrammarAST COLON80_tree=null;
GrammarAST SEMI82_tree=null;
RewriteRuleTokenStream stream_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_REF74=(Token)match(input,RULE_REF,FOLLOW_RULE_REF_in_parserRule1539);
stream_RULE_REF.add(RULE_REF74);
// org\\antlr\\v4\\parse\\ANTLRParser.g:379:4: ( ARG_ACTION )?
int alt22=2;
int LA22_0 = input.LA(1);
if ( (LA22_0==ARG_ACTION) ) {
alt22=1;
}
switch (alt22) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:379:4: ARG_ACTION
{
ARG_ACTION75=(Token)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_parserRule1569);
stream_ARG_ACTION.add(ARG_ACTION75);
}
break;
}
// org\\antlr\\v4\\parse\\ANTLRParser.g:381:4: ( ruleReturns )?
int alt23=2;
int LA23_0 = input.LA(1);
if ( (LA23_0==RETURNS) ) {
alt23=1;
}
switch (alt23) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:381:4: ruleReturns
{
pushFollow(FOLLOW_ruleReturns_in_parserRule1576);
ruleReturns76=ruleReturns();
state._fsp--;
stream_ruleReturns.add(ruleReturns76.getTree());
}
break;
}
// org\\antlr\\v4\\parse\\ANTLRParser.g:383:4: ( throwsSpec )?
int alt24=2;
int LA24_0 = input.LA(1);
if ( (LA24_0==THROWS) ) {
alt24=1;
}
switch (alt24) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:383:4: throwsSpec
{
pushFollow(FOLLOW_throwsSpec_in_parserRule1583);
throwsSpec77=throwsSpec();
state._fsp--;
stream_throwsSpec.add(throwsSpec77.getTree());
}
break;
}
// org\\antlr\\v4\\parse\\ANTLRParser.g:385:4: ( localsSpec )?
int alt25=2;
int LA25_0 = input.LA(1);
if ( (LA25_0==LOCALS) ) {
alt25=1;
}
switch (alt25) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:385:4: localsSpec
{
pushFollow(FOLLOW_localsSpec_in_parserRule1590);
localsSpec78=localsSpec();
state._fsp--;
stream_localsSpec.add(localsSpec78.getTree());
}
break;
}
pushFollow(FOLLOW_rulePrequels_in_parserRule1628);
rulePrequels79=rulePrequels();
state._fsp--;
stream_rulePrequels.add(rulePrequels79.getTree());
COLON80=(Token)match(input,COLON,FOLLOW_COLON_in_parserRule1637);
stream_COLON.add(COLON80);
pushFollow(FOLLOW_ruleBlock_in_parserRule1660);
ruleBlock81=ruleBlock();
state._fsp--;
stream_ruleBlock.add(ruleBlock81.getTree());
SEMI82=(Token)match(input,SEMI,FOLLOW_SEMI_in_parserRule1669);
stream_SEMI.add(SEMI82);
pushFollow(FOLLOW_exceptionGroup_in_parserRule1678);
exceptionGroup83=exceptionGroup();
state._fsp--;
stream_exceptionGroup.add(exceptionGroup83.getTree());
// AST REWRITE
// elements: throwsSpec, ARG_ACTION, rulePrequels, exceptionGroup, ruleReturns, ruleBlock, RULE_REF, localsSpec
// 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 exceptionHandler84 =null;
ParserRuleReturnScope finallyClause85 =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 )*
loop26:
while (true) {
int alt26=2;
int LA26_0 = input.LA(1);
if ( (LA26_0==CATCH) ) {
alt26=1;
}
switch (alt26) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:424:7: exceptionHandler
{
pushFollow(FOLLOW_exceptionHandler_in_exceptionGroup1761);
exceptionHandler84=exceptionHandler();
state._fsp--;
adaptor.addChild(root_0, exceptionHandler84.getTree());
}
break;
default :
break loop26;
}
}
// org\\antlr\\v4\\parse\\ANTLRParser.g:424:25: ( finallyClause )?
int alt27=2;
int LA27_0 = input.LA(1);
if ( (LA27_0==FINALLY) ) {
alt27=1;
}
switch (alt27) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:424:25: finallyClause
{
pushFollow(FOLLOW_finallyClause_in_exceptionGroup1764);
finallyClause85=finallyClause();
state._fsp--;
adaptor.addChild(root_0, finallyClause85.getTree());
}
break;
}
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "exceptionGroup"
public static class exceptionHandler_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "exceptionHandler"
// org\\antlr\\v4\\parse\\ANTLRParser.g: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 CATCH86=null;
Token ARG_ACTION87=null;
Token ACTION88=null;
GrammarAST CATCH86_tree=null;
GrammarAST ARG_ACTION87_tree=null;
GrammarAST ACTION88_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
{
CATCH86=(Token)match(input,CATCH,FOLLOW_CATCH_in_exceptionHandler1781);
stream_CATCH.add(CATCH86);
ARG_ACTION87=(Token)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_exceptionHandler1783);
stream_ARG_ACTION.add(ARG_ACTION87);
ACTION88=(Token)match(input,ACTION,FOLLOW_ACTION_in_exceptionHandler1785);
stream_ACTION.add(ACTION88);
// AST REWRITE
// elements: CATCH, ARG_ACTION, 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 FINALLY89=null;
Token ACTION90=null;
GrammarAST FINALLY89_tree=null;
GrammarAST ACTION90_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
{
FINALLY89=(Token)match(input,FINALLY,FOLLOW_FINALLY_in_finallyClause1812);
stream_FINALLY.add(FINALLY89);
ACTION90=(Token)match(input,ACTION,FOLLOW_ACTION_in_finallyClause1814);
stream_ACTION.add(ACTION90);
// AST REWRITE
// elements: FINALLY, ACTION
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 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 sync91 =null;
ParserRuleReturnScope rulePrequel92 =null;
ParserRuleReturnScope sync93 =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_rulePrequels1846);
sync91=sync();
state._fsp--;
stream_sync.add(sync91.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:440:9: ( rulePrequel sync )*
loop28:
while (true) {
int alt28=2;
int LA28_0 = input.LA(1);
if ( (LA28_0==AT||LA28_0==OPTIONS) ) {
alt28=1;
}
switch (alt28) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:440:10: rulePrequel sync
{
pushFollow(FOLLOW_rulePrequel_in_rulePrequels1849);
rulePrequel92=rulePrequel();
state._fsp--;
stream_rulePrequel.add(rulePrequel92.getTree());
pushFollow(FOLLOW_sync_in_rulePrequels1851);
sync93=sync();
state._fsp--;
stream_sync.add(sync93.getTree());
}
break;
default :
break loop28;
}
}
// AST REWRITE
// elements: rulePrequel
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 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 optionsSpec94 =null;
ParserRuleReturnScope ruleAction95 =null;
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:447:5: ( optionsSpec | ruleAction )
int alt29=2;
int LA29_0 = input.LA(1);
if ( (LA29_0==OPTIONS) ) {
alt29=1;
}
else if ( (LA29_0==AT) ) {
alt29=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 29, 0, input);
throw nvae;
}
switch (alt29) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:447:7: optionsSpec
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_optionsSpec_in_rulePrequel1875);
optionsSpec94=optionsSpec();
state._fsp--;
adaptor.addChild(root_0, optionsSpec94.getTree());
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:448:7: ruleAction
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_ruleAction_in_rulePrequel1883);
ruleAction95=ruleAction();
state._fsp--;
adaptor.addChild(root_0, ruleAction95.getTree());
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "rulePrequel"
public static class ruleReturns_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "ruleReturns"
// org\\antlr\\v4\\parse\\ANTLRParser.g: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 RETURNS96=null;
Token ARG_ACTION97=null;
GrammarAST RETURNS96_tree=null;
GrammarAST ARG_ACTION97_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();
RETURNS96=(Token)match(input,RETURNS,FOLLOW_RETURNS_in_ruleReturns1903);
RETURNS96_tree = (GrammarAST)adaptor.create(RETURNS96);
root_0 = (GrammarAST)adaptor.becomeRoot(RETURNS96_tree, root_0);
ARG_ACTION97=(Token)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_ruleReturns1906);
ARG_ACTION97_tree = new ActionAST(ARG_ACTION97) ;
adaptor.addChild(root_0, ARG_ACTION97_tree);
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "ruleReturns"
public static class throwsSpec_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "throwsSpec"
// org\\antlr\\v4\\parse\\ANTLRParser.g: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 THROWS98=null;
Token COMMA100=null;
ParserRuleReturnScope qid99 =null;
ParserRuleReturnScope qid101 =null;
GrammarAST THROWS98_tree=null;
GrammarAST COMMA100_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 )*
{
THROWS98=(Token)match(input,THROWS,FOLLOW_THROWS_in_throwsSpec1934);
stream_THROWS.add(THROWS98);
pushFollow(FOLLOW_qid_in_throwsSpec1936);
qid99=qid();
state._fsp--;
stream_qid.add(qid99.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:473:18: ( COMMA qid )*
loop30:
while (true) {
int alt30=2;
int LA30_0 = input.LA(1);
if ( (LA30_0==COMMA) ) {
alt30=1;
}
switch (alt30) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:473:19: COMMA qid
{
COMMA100=(Token)match(input,COMMA,FOLLOW_COMMA_in_throwsSpec1939);
stream_COMMA.add(COMMA100);
pushFollow(FOLLOW_qid_in_throwsSpec1941);
qid101=qid();
state._fsp--;
stream_qid.add(qid101.getTree());
}
break;
default :
break loop30;
}
}
// AST REWRITE
// elements: 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 LOCALS102=null;
Token ARG_ACTION103=null;
GrammarAST LOCALS102_tree=null;
GrammarAST ARG_ACTION103_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();
LOCALS102=(Token)match(input,LOCALS,FOLLOW_LOCALS_in_localsSpec1966);
LOCALS102_tree = (GrammarAST)adaptor.create(LOCALS102);
root_0 = (GrammarAST)adaptor.becomeRoot(LOCALS102_tree, root_0);
ARG_ACTION103=(Token)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_localsSpec1969);
ARG_ACTION103_tree = new ActionAST(ARG_ACTION103) ;
adaptor.addChild(root_0, ARG_ACTION103_tree);
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "localsSpec"
public static class ruleAction_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "ruleAction"
// org\\antlr\\v4\\parse\\ANTLRParser.g: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 AT104=null;
Token ACTION106=null;
ParserRuleReturnScope id105 =null;
GrammarAST AT104_tree=null;
GrammarAST ACTION106_tree=null;
RewriteRuleTokenStream stream_AT=new RewriteRuleTokenStream(adaptor,"token AT");
RewriteRuleTokenStream stream_ACTION=new RewriteRuleTokenStream(adaptor,"token ACTION");
RewriteRuleSubtreeStream stream_id=new RewriteRuleSubtreeStream(adaptor,"rule id");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:489:2: ( AT id ACTION -> ^( AT id ACTION ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:489:4: AT id ACTION
{
AT104=(Token)match(input,AT,FOLLOW_AT_in_ruleAction1992);
stream_AT.add(AT104);
pushFollow(FOLLOW_id_in_ruleAction1994);
id105=id();
state._fsp--;
stream_id.add(id105.getTree());
ACTION106=(Token)match(input,ACTION,FOLLOW_ACTION_in_ruleAction1996);
stream_ACTION.add(ACTION106);
// AST REWRITE
// elements: ACTION, id, AT
// 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 ruleAltList107 =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_ruleBlock2034);
ruleAltList107=ruleAltList();
state._fsp--;
stream_ruleAltList.add(ruleAltList107.getTree());
// AST REWRITE
// elements: ruleAltList
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 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 OR109=null;
ParserRuleReturnScope labeledAlt108 =null;
ParserRuleReturnScope labeledAlt110 =null;
GrammarAST OR109_tree=null;
RewriteRuleTokenStream stream_OR=new RewriteRuleTokenStream(adaptor,"token OR");
RewriteRuleSubtreeStream stream_labeledAlt=new RewriteRuleSubtreeStream(adaptor,"rule labeledAlt");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:508:2: ( labeledAlt ( OR labeledAlt )* -> ( labeledAlt )+ )
// org\\antlr\\v4\\parse\\ANTLRParser.g:508:4: labeledAlt ( OR labeledAlt )*
{
pushFollow(FOLLOW_labeledAlt_in_ruleAltList2070);
labeledAlt108=labeledAlt();
state._fsp--;
stream_labeledAlt.add(labeledAlt108.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:508:15: ( OR labeledAlt )*
loop31:
while (true) {
int alt31=2;
int LA31_0 = input.LA(1);
if ( (LA31_0==OR) ) {
alt31=1;
}
switch (alt31) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:508:16: OR labeledAlt
{
OR109=(Token)match(input,OR,FOLLOW_OR_in_ruleAltList2073);
stream_OR.add(OR109);
pushFollow(FOLLOW_labeledAlt_in_ruleAltList2075);
labeledAlt110=labeledAlt();
state._fsp--;
stream_labeledAlt.add(labeledAlt110.getTree());
}
break;
default :
break loop31;
}
}
// AST REWRITE
// elements: labeledAlt
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 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 POUND112=null;
ParserRuleReturnScope alternative111 =null;
ParserRuleReturnScope id113 =null;
GrammarAST POUND112_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_labeledAlt2093);
alternative111=alternative();
state._fsp--;
adaptor.addChild(root_0, alternative111.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:513:3: ( POUND ! id !)?
int alt32=2;
int LA32_0 = input.LA(1);
if ( (LA32_0==POUND) ) {
alt32=1;
}
switch (alt32) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:513:5: POUND ! id !
{
POUND112=(Token)match(input,POUND,FOLLOW_POUND_in_labeledAlt2099);
pushFollow(FOLLOW_id_in_labeledAlt2102);
id113=id();
state._fsp--;
((AltAST)(alternative111!=null?((GrammarAST)alternative111.getTree()):null)).altLabel=(id113!=null?((GrammarAST)id113.getTree()):null);
}
break;
}
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "labeledAlt"
public static class lexerRule_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "lexerRule"
// org\\antlr\\v4\\parse\\ANTLRParser.g: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 FRAGMENT114=null;
Token TOKEN_REF115=null;
Token COLON116=null;
Token SEMI118=null;
ParserRuleReturnScope lexerRuleBlock117 =null;
GrammarAST FRAGMENT114_tree=null;
GrammarAST TOKEN_REF115_tree=null;
GrammarAST COLON116_tree=null;
GrammarAST SEMI118_tree=null;
RewriteRuleTokenStream stream_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 alt33=2;
int LA33_0 = input.LA(1);
if ( (LA33_0==FRAGMENT) ) {
alt33=1;
}
switch (alt33) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:522:7: FRAGMENT
{
FRAGMENT114=(Token)match(input,FRAGMENT,FOLLOW_FRAGMENT_in_lexerRule2134);
stream_FRAGMENT.add(FRAGMENT114);
}
break;
}
TOKEN_REF115=(Token)match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_lexerRule2140);
stream_TOKEN_REF.add(TOKEN_REF115);
COLON116=(Token)match(input,COLON,FOLLOW_COLON_in_lexerRule2142);
stream_COLON.add(COLON116);
pushFollow(FOLLOW_lexerRuleBlock_in_lexerRule2144);
lexerRuleBlock117=lexerRuleBlock();
state._fsp--;
stream_lexerRuleBlock.add(lexerRuleBlock117.getTree());
SEMI118=(Token)match(input,SEMI,FOLLOW_SEMI_in_lexerRule2146);
stream_SEMI.add(SEMI118);
// AST REWRITE
// elements: 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 lexerAltList119 =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_lexerRuleBlock2210);
lexerAltList119=lexerAltList();
state._fsp--;
stream_lexerAltList.add(lexerAltList119.getTree());
// AST REWRITE
// elements: lexerAltList
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 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 OR121=null;
ParserRuleReturnScope lexerAlt120 =null;
ParserRuleReturnScope lexerAlt122 =null;
GrammarAST OR121_tree=null;
RewriteRuleTokenStream stream_OR=new RewriteRuleTokenStream(adaptor,"token OR");
RewriteRuleSubtreeStream stream_lexerAlt=new RewriteRuleSubtreeStream(adaptor,"rule lexerAlt");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:539:2: ( lexerAlt ( OR lexerAlt )* -> ( lexerAlt )+ )
// org\\antlr\\v4\\parse\\ANTLRParser.g:539:4: lexerAlt ( OR lexerAlt )*
{
pushFollow(FOLLOW_lexerAlt_in_lexerAltList2246);
lexerAlt120=lexerAlt();
state._fsp--;
stream_lexerAlt.add(lexerAlt120.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:539:13: ( OR lexerAlt )*
loop34:
while (true) {
int alt34=2;
int LA34_0 = input.LA(1);
if ( (LA34_0==OR) ) {
alt34=1;
}
switch (alt34) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:539:14: OR lexerAlt
{
OR121=(Token)match(input,OR,FOLLOW_OR_in_lexerAltList2249);
stream_OR.add(OR121);
pushFollow(FOLLOW_lexerAlt_in_lexerAltList2251);
lexerAlt122=lexerAlt();
state._fsp--;
stream_lexerAlt.add(lexerAlt122.getTree());
}
break;
default :
break loop34;
}
}
// AST REWRITE
// elements: lexerAlt
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 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 lexerElements123 =null;
ParserRuleReturnScope lexerCommands124 =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_lexerAlt2269);
lexerElements123=lexerElements();
state._fsp--;
stream_lexerElements.add(lexerElements123.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:544:3: ( lexerCommands -> ^( LEXER_ALT_ACTION lexerElements lexerCommands ) | -> lexerElements )
int alt35=2;
int LA35_0 = input.LA(1);
if ( (LA35_0==RARROW) ) {
alt35=1;
}
else if ( (LA35_0==OR||LA35_0==RPAREN||LA35_0==SEMI) ) {
alt35=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 35, 0, input);
throw nvae;
}
switch (alt35) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:544:5: lexerCommands
{
pushFollow(FOLLOW_lexerCommands_in_lexerAlt2275);
lexerCommands124=lexerCommands();
state._fsp--;
stream_lexerCommands.add(lexerCommands124.getTree());
// AST REWRITE
// elements: lexerElements, lexerCommands
// 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 lexerElement125 =null;
RewriteRuleSubtreeStream stream_lexerElement=new RewriteRuleSubtreeStream(adaptor,"rule lexerElement");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:550:5: ( ( lexerElement )+ -> ^( ALT ( lexerElement )+ ) | -> ^( ALT EPSILON ) )
int alt37=2;
int LA37_0 = input.LA(1);
if ( (LA37_0==ACTION||LA37_0==DOT||LA37_0==LEXER_CHAR_SET||LA37_0==LPAREN||LA37_0==NOT||LA37_0==RULE_REF||LA37_0==SEMPRED||LA37_0==STRING_LITERAL||LA37_0==TOKEN_REF) ) {
alt37=1;
}
else if ( (LA37_0==OR||LA37_0==RARROW||LA37_0==RPAREN||LA37_0==SEMI) ) {
alt37=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 37, 0, input);
throw nvae;
}
switch (alt37) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:550:7: ( lexerElement )+
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:550:7: ( lexerElement )+
int cnt36=0;
loop36:
while (true) {
int alt36=2;
int LA36_0 = input.LA(1);
if ( (LA36_0==ACTION||LA36_0==DOT||LA36_0==LEXER_CHAR_SET||LA36_0==LPAREN||LA36_0==NOT||LA36_0==RULE_REF||LA36_0==SEMPRED||LA36_0==STRING_LITERAL||LA36_0==TOKEN_REF) ) {
alt36=1;
}
switch (alt36) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:550:7: lexerElement
{
pushFollow(FOLLOW_lexerElement_in_lexerElements2318);
lexerElement125=lexerElement();
state._fsp--;
stream_lexerElement.add(lexerElement125.getTree());
}
break;
default :
if ( cnt36 >= 1 ) break loop36;
EarlyExitException eee = new EarlyExitException(36, input);
throw eee;
}
cnt36++;
}
// AST REWRITE
// elements: lexerElement
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 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 labeledLexerElement126 =null;
ParserRuleReturnScope ebnfSuffix127 =null;
ParserRuleReturnScope lexerAtom128 =null;
ParserRuleReturnScope ebnfSuffix129 =null;
ParserRuleReturnScope lexerBlock130 =null;
ParserRuleReturnScope ebnfSuffix131 =null;
ParserRuleReturnScope actionElement132 =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 alt41=4;
switch ( input.LA(1) ) {
case RULE_REF:
{
int LA41_1 = input.LA(2);
if ( (LA41_1==ASSIGN||LA41_1==PLUS_ASSIGN) ) {
alt41=1;
}
else if ( (LA41_1==ACTION||LA41_1==DOT||LA41_1==LEXER_CHAR_SET||LA41_1==LPAREN||LA41_1==NOT||LA41_1==OR||LA41_1==PLUS||LA41_1==QUESTION||LA41_1==RARROW||(LA41_1 >= RPAREN && LA41_1 <= SEMPRED)||(LA41_1 >= STAR && LA41_1 <= STRING_LITERAL)||LA41_1==TOKEN_REF) ) {
alt41=2;
}
else {
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 41, 1, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case TOKEN_REF:
{
int LA41_2 = input.LA(2);
if ( (LA41_2==ASSIGN||LA41_2==PLUS_ASSIGN) ) {
alt41=1;
}
else if ( (LA41_2==ACTION||LA41_2==DOT||LA41_2==LEXER_CHAR_SET||(LA41_2 >= LPAREN && LA41_2 <= LT)||LA41_2==NOT||LA41_2==OR||LA41_2==PLUS||LA41_2==QUESTION||LA41_2==RARROW||(LA41_2 >= RPAREN && LA41_2 <= SEMPRED)||(LA41_2 >= STAR && LA41_2 <= STRING_LITERAL)||LA41_2==TOKEN_REF) ) {
alt41=2;
}
else {
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 41, 2, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case DOT:
case LEXER_CHAR_SET:
case NOT:
case STRING_LITERAL:
{
alt41=2;
}
break;
case LPAREN:
{
alt41=3;
}
break;
case ACTION:
case SEMPRED:
{
alt41=4;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 41, 0, input);
throw nvae;
}
switch (alt41) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:560:4: labeledLexerElement ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[$labeledLexerElement.start,\"BLOCK\"] ^( ALT labeledLexerElement ) ) ) | -> labeledLexerElement )
{
pushFollow(FOLLOW_labeledLexerElement_in_lexerElement2374);
labeledLexerElement126=labeledLexerElement();
state._fsp--;
stream_labeledLexerElement.add(labeledLexerElement126.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:561:3: ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[$labeledLexerElement.start,\"BLOCK\"] ^( ALT labeledLexerElement ) ) ) | -> labeledLexerElement )
int alt38=2;
int LA38_0 = input.LA(1);
if ( (LA38_0==PLUS||LA38_0==QUESTION||LA38_0==STAR) ) {
alt38=1;
}
else if ( (LA38_0==ACTION||LA38_0==DOT||LA38_0==LEXER_CHAR_SET||LA38_0==LPAREN||LA38_0==NOT||LA38_0==OR||LA38_0==RARROW||(LA38_0 >= RPAREN && LA38_0 <= SEMPRED)||LA38_0==STRING_LITERAL||LA38_0==TOKEN_REF) ) {
alt38=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 38, 0, input);
throw nvae;
}
switch (alt38) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:561:5: ebnfSuffix
{
pushFollow(FOLLOW_ebnfSuffix_in_lexerElement2380);
ebnfSuffix127=ebnfSuffix();
state._fsp--;
stream_ebnfSuffix.add(ebnfSuffix127.getTree());
// AST REWRITE
// elements: labeledLexerElement, ebnfSuffix
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 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, (labeledLexerElement126!=null?(labeledLexerElement126.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_lexerElement2426);
lexerAtom128=lexerAtom();
state._fsp--;
stream_lexerAtom.add(lexerAtom128.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:565:3: ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[$lexerAtom.start,\"BLOCK\"] ^( ALT lexerAtom ) ) ) | -> lexerAtom )
int alt39=2;
int LA39_0 = input.LA(1);
if ( (LA39_0==PLUS||LA39_0==QUESTION||LA39_0==STAR) ) {
alt39=1;
}
else if ( (LA39_0==ACTION||LA39_0==DOT||LA39_0==LEXER_CHAR_SET||LA39_0==LPAREN||LA39_0==NOT||LA39_0==OR||LA39_0==RARROW||(LA39_0 >= RPAREN && LA39_0 <= SEMPRED)||LA39_0==STRING_LITERAL||LA39_0==TOKEN_REF) ) {
alt39=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 39, 0, input);
throw nvae;
}
switch (alt39) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:565:5: ebnfSuffix
{
pushFollow(FOLLOW_ebnfSuffix_in_lexerElement2432);
ebnfSuffix129=ebnfSuffix();
state._fsp--;
stream_ebnfSuffix.add(ebnfSuffix129.getTree());
// AST REWRITE
// elements: ebnfSuffix, lexerAtom
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 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, (lexerAtom128!=null?(lexerAtom128.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_lexerElement2478);
lexerBlock130=lexerBlock();
state._fsp--;
stream_lexerBlock.add(lexerBlock130.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:569:3: ( ebnfSuffix -> ^( ebnfSuffix lexerBlock ) | -> lexerBlock )
int alt40=2;
int LA40_0 = input.LA(1);
if ( (LA40_0==PLUS||LA40_0==QUESTION||LA40_0==STAR) ) {
alt40=1;
}
else if ( (LA40_0==ACTION||LA40_0==DOT||LA40_0==LEXER_CHAR_SET||LA40_0==LPAREN||LA40_0==NOT||LA40_0==OR||LA40_0==RARROW||(LA40_0 >= RPAREN && LA40_0 <= SEMPRED)||LA40_0==STRING_LITERAL||LA40_0==TOKEN_REF) ) {
alt40=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 40, 0, input);
throw nvae;
}
switch (alt40) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:569:5: ebnfSuffix
{
pushFollow(FOLLOW_ebnfSuffix_in_lexerElement2484);
ebnfSuffix131=ebnfSuffix();
state._fsp--;
stream_ebnfSuffix.add(ebnfSuffix131.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_lexerElement2512);
actionElement132=actionElement();
state._fsp--;
adaptor.addChild(root_0, actionElement132.getTree());
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
paraphrases.pop();
}
catch (RecognitionException re) {
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
int ttype = input.get(input.range()).getType(); // seems to be next token
// look for anything that really belongs at the start of the rule minus the initial ID
if ( ttype==COLON || ttype==RETURNS || ttype==CATCH || ttype==FINALLY || ttype==AT || ttype==EOF ) {
RecognitionException missingSemi =
new v4ParserException("unterminated rule (missing ';') detected at '"+
input.LT(1).getText()+" "+input.LT(2).getText()+"'", input);
reportError(missingSemi);
if ( ttype==EOF ) {
input.seek(input.index()+1);
}
else if ( ttype==CATCH || ttype==FINALLY ) {
input.seek(input.range()); // ignore what's before rule trailer stuff
}
else if ( ttype==RETURNS || ttype==AT ) { // scan back looking for ID of rule header
int p = input.index();
Token t = input.get(p);
while ( t.getType()!=RULE_REF && t.getType()!=TOKEN_REF ) {
p--;
t = input.get(p);
}
input.seek(p);
}
throw new ResyncToEndOfRuleBlock(); // make sure it goes back to rule block level to recover
}
reportError(re);
recover(input,re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "lexerElement"
public static class labeledLexerElement_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "labeledLexerElement"
// org\\antlr\\v4\\parse\\ANTLRParser.g: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 id133 =null;
ParserRuleReturnScope lexerAtom134 =null;
ParserRuleReturnScope lexerBlock135 =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_labeledLexerElement2542);
id133=id();
state._fsp--;
stream_id.add(id133.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:606:7: (ass= ASSIGN |ass= PLUS_ASSIGN )
int alt42=2;
int LA42_0 = input.LA(1);
if ( (LA42_0==ASSIGN) ) {
alt42=1;
}
else if ( (LA42_0==PLUS_ASSIGN) ) {
alt42=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 42, 0, input);
throw nvae;
}
switch (alt42) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:606:8: ass= ASSIGN
{
ass=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_labeledLexerElement2547);
stream_ASSIGN.add(ass);
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:606:19: ass= PLUS_ASSIGN
{
ass=(Token)match(input,PLUS_ASSIGN,FOLLOW_PLUS_ASSIGN_in_labeledLexerElement2551);
stream_PLUS_ASSIGN.add(ass);
}
break;
}
// org\\antlr\\v4\\parse\\ANTLRParser.g:607:3: ( lexerAtom -> ^( $ass id lexerAtom ) | lexerBlock -> ^( $ass id lexerBlock ) )
int alt43=2;
int LA43_0 = input.LA(1);
if ( (LA43_0==DOT||LA43_0==LEXER_CHAR_SET||LA43_0==NOT||LA43_0==RULE_REF||LA43_0==STRING_LITERAL||LA43_0==TOKEN_REF) ) {
alt43=1;
}
else if ( (LA43_0==LPAREN) ) {
alt43=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 43, 0, input);
throw nvae;
}
switch (alt43) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:607:5: lexerAtom
{
pushFollow(FOLLOW_lexerAtom_in_labeledLexerElement2558);
lexerAtom134=lexerAtom();
state._fsp--;
stream_lexerAtom.add(lexerAtom134.getTree());
// AST REWRITE
// elements: id, ass, lexerAtom
// 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_labeledLexerElement2575);
lexerBlock135=lexerBlock();
state._fsp--;
stream_lexerBlock.add(lexerBlock135.getTree());
// AST REWRITE
// elements: lexerBlock, ass, id
// token labels: ass
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleTokenStream stream_ass=new RewriteRuleTokenStream(adaptor,"token ass",ass);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 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 LPAREN136=null;
Token COLON138=null;
Token RPAREN140=null;
ParserRuleReturnScope optionsSpec137 =null;
ParserRuleReturnScope lexerAltList139 =null;
GrammarAST LPAREN136_tree=null;
GrammarAST COLON138_tree=null;
GrammarAST RPAREN140_tree=null;
RewriteRuleTokenStream stream_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
{
LPAREN136=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_lexerBlock2608);
stream_LPAREN.add(LPAREN136);
// org\\antlr\\v4\\parse\\ANTLRParser.g:621:9: ( optionsSpec COLON )?
int alt44=2;
int LA44_0 = input.LA(1);
if ( (LA44_0==OPTIONS) ) {
alt44=1;
}
switch (alt44) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:621:11: optionsSpec COLON
{
pushFollow(FOLLOW_optionsSpec_in_lexerBlock2620);
optionsSpec137=optionsSpec();
state._fsp--;
stream_optionsSpec.add(optionsSpec137.getTree());
COLON138=(Token)match(input,COLON,FOLLOW_COLON_in_lexerBlock2622);
stream_COLON.add(COLON138);
}
break;
}
pushFollow(FOLLOW_lexerAltList_in_lexerBlock2635);
lexerAltList139=lexerAltList();
state._fsp--;
stream_lexerAltList.add(lexerAltList139.getTree());
RPAREN140=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_lexerBlock2645);
stream_RPAREN.add(RPAREN140);
// AST REWRITE
// elements: 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, LPAREN136, "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 RARROW141=null;
Token COMMA143=null;
ParserRuleReturnScope lexerCommand142 =null;
ParserRuleReturnScope lexerCommand144 =null;
GrammarAST RARROW141_tree=null;
GrammarAST COMMA143_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 )*
{
RARROW141=(Token)match(input,RARROW,FOLLOW_RARROW_in_lexerCommands2682);
stream_RARROW.add(RARROW141);
pushFollow(FOLLOW_lexerCommand_in_lexerCommands2684);
lexerCommand142=lexerCommand();
state._fsp--;
stream_lexerCommand.add(lexerCommand142.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:629:24: ( COMMA lexerCommand )*
loop45:
while (true) {
int alt45=2;
int LA45_0 = input.LA(1);
if ( (LA45_0==COMMA) ) {
alt45=1;
}
switch (alt45) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:629:25: COMMA lexerCommand
{
COMMA143=(Token)match(input,COMMA,FOLLOW_COMMA_in_lexerCommands2687);
stream_COMMA.add(COMMA143);
pushFollow(FOLLOW_lexerCommand_in_lexerCommands2689);
lexerCommand144=lexerCommand();
state._fsp--;
stream_lexerCommand.add(lexerCommand144.getTree());
}
break;
default :
break loop45;
}
}
// AST REWRITE
// elements: lexerCommand
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 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 LPAREN146=null;
Token RPAREN148=null;
ParserRuleReturnScope lexerCommandName145 =null;
ParserRuleReturnScope lexerCommandExpr147 =null;
ParserRuleReturnScope lexerCommandName149 =null;
GrammarAST LPAREN146_tree=null;
GrammarAST RPAREN148_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 alt46=2;
switch ( input.LA(1) ) {
case RULE_REF:
{
int LA46_1 = input.LA(2);
if ( (LA46_1==LPAREN) ) {
alt46=1;
}
else if ( (LA46_1==COMMA||LA46_1==OR||LA46_1==RPAREN||LA46_1==SEMI) ) {
alt46=2;
}
else {
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 46, 1, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case TOKEN_REF:
{
int LA46_2 = input.LA(2);
if ( (LA46_2==LPAREN) ) {
alt46=1;
}
else if ( (LA46_2==COMMA||LA46_2==OR||LA46_2==RPAREN||LA46_2==SEMI) ) {
alt46=2;
}
else {
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 46, 2, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case MODE:
{
int LA46_3 = input.LA(2);
if ( (LA46_3==LPAREN) ) {
alt46=1;
}
else if ( (LA46_3==COMMA||LA46_3==OR||LA46_3==RPAREN||LA46_3==SEMI) ) {
alt46=2;
}
else {
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 46, 3, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 46, 0, input);
throw nvae;
}
switch (alt46) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:633:4: lexerCommandName LPAREN lexerCommandExpr RPAREN
{
pushFollow(FOLLOW_lexerCommandName_in_lexerCommand2707);
lexerCommandName145=lexerCommandName();
state._fsp--;
stream_lexerCommandName.add(lexerCommandName145.getTree());
LPAREN146=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_lexerCommand2709);
stream_LPAREN.add(LPAREN146);
pushFollow(FOLLOW_lexerCommandExpr_in_lexerCommand2711);
lexerCommandExpr147=lexerCommandExpr();
state._fsp--;
stream_lexerCommandExpr.add(lexerCommandExpr147.getTree());
RPAREN148=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_lexerCommand2713);
stream_RPAREN.add(RPAREN148);
// AST REWRITE
// elements: lexerCommandExpr, lexerCommandName
// 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_lexerCommand2728);
lexerCommandName149=lexerCommandName();
state._fsp--;
adaptor.addChild(root_0, lexerCommandName149.getTree());
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "lexerCommand"
public static class lexerCommandExpr_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "lexerCommandExpr"
// org\\antlr\\v4\\parse\\ANTLRParser.g: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 INT151=null;
ParserRuleReturnScope id150 =null;
GrammarAST INT151_tree=null;
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:638:2: ( id | INT )
int alt47=2;
int LA47_0 = input.LA(1);
if ( (LA47_0==RULE_REF||LA47_0==TOKEN_REF) ) {
alt47=1;
}
else if ( (LA47_0==INT) ) {
alt47=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 47, 0, input);
throw nvae;
}
switch (alt47) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:638:4: id
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_id_in_lexerCommandExpr2739);
id150=id();
state._fsp--;
adaptor.addChild(root_0, id150.getTree());
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:639:4: INT
{
root_0 = (GrammarAST)adaptor.nil();
INT151=(Token)match(input,INT,FOLLOW_INT_in_lexerCommandExpr2744);
INT151_tree = (GrammarAST)adaptor.create(INT151);
adaptor.addChild(root_0, INT151_tree);
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "lexerCommandExpr"
public static class lexerCommandName_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "lexerCommandName"
// org\\antlr\\v4\\parse\\ANTLRParser.g: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 MODE153=null;
ParserRuleReturnScope id152 =null;
GrammarAST MODE153_tree=null;
RewriteRuleTokenStream stream_MODE=new RewriteRuleTokenStream(adaptor,"token MODE");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:643:9: ( id | MODE -> ID[$MODE] )
int alt48=2;
int LA48_0 = input.LA(1);
if ( (LA48_0==RULE_REF||LA48_0==TOKEN_REF) ) {
alt48=1;
}
else if ( (LA48_0==MODE) ) {
alt48=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 48, 0, input);
throw nvae;
}
switch (alt48) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:643:17: id
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_id_in_lexerCommandName2768);
id152=id();
state._fsp--;
adaptor.addChild(root_0, id152.getTree());
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:644:17: MODE
{
MODE153=(Token)match(input,MODE,FOLLOW_MODE_in_lexerCommandName2786);
stream_MODE.add(MODE153);
// AST REWRITE
// elements:
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 644:25: -> ID[$MODE]
{
adaptor.addChild(root_0, (GrammarAST)adaptor.create(ID, MODE153));
}
retval.tree = root_0;
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "lexerCommandName"
public static class altList_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "altList"
// org\\antlr\\v4\\parse\\ANTLRParser.g: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 OR155=null;
ParserRuleReturnScope alternative154 =null;
ParserRuleReturnScope alternative156 =null;
GrammarAST OR155_tree=null;
RewriteRuleTokenStream stream_OR=new RewriteRuleTokenStream(adaptor,"token OR");
RewriteRuleSubtreeStream stream_alternative=new RewriteRuleSubtreeStream(adaptor,"rule alternative");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:648:5: ( alternative ( OR alternative )* -> ( alternative )+ )
// org\\antlr\\v4\\parse\\ANTLRParser.g:648:7: alternative ( OR alternative )*
{
pushFollow(FOLLOW_alternative_in_altList2814);
alternative154=alternative();
state._fsp--;
stream_alternative.add(alternative154.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:648:19: ( OR alternative )*
loop49:
while (true) {
int alt49=2;
int LA49_0 = input.LA(1);
if ( (LA49_0==OR) ) {
alt49=1;
}
switch (alt49) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:648:20: OR alternative
{
OR155=(Token)match(input,OR,FOLLOW_OR_in_altList2817);
stream_OR.add(OR155);
pushFollow(FOLLOW_alternative_in_altList2819);
alternative156=alternative();
state._fsp--;
stream_alternative.add(alternative156.getTree());
}
break;
default :
break loop49;
}
}
// AST REWRITE
// elements: alternative
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 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