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 org\\antlr\\v4\\parse\\ANTLRParser.g 2013-01-21 20:03:18
/*
[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", "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",
"WS", "WSCHARS", "WSNLCHARS", "ALT", "ALTLIST", "ARG", "ARGLIST", "BLOCK",
"CHAR_RANGE", "CLOSURE", "COMBINED", "ELEMENT_OPTIONS", "EPSILON", "INITACTION",
"LABEL", "LEXER_ACTION_CALL", "LEXER_ALT_ACTION", "LIST", "OPTIONAL",
"POSITIVE_CLOSURE", "PREC_RULE", "RESULT", "RET", "RULE", "RULEACTIONS",
"RULEMODIFIERS", "RULES", "SET", "TEMPLATE", "WILDCARD"
};
public static final int EOF=-1;
public static final int ACTION=4;
public static final int ACTION_CHAR_LITERAL=5;
public static final int ACTION_ESC=6;
public static final int ACTION_STRING_LITERAL=7;
public static final int ARG_ACTION=8;
public static final int ARG_OR_CHARSET=9;
public static final int ASSIGN=10;
public static final int AT=11;
public static final int CATCH=12;
public static final int COLON=13;
public static final int COLONCOLON=14;
public static final int COMMA=15;
public static final int COMMENT=16;
public static final int DOC_COMMENT=17;
public static final int DOLLAR=18;
public static final int DOT=19;
public static final int ERRCHAR=20;
public static final int ESC_SEQ=21;
public static final int FINALLY=22;
public static final int FRAGMENT=23;
public static final int GRAMMAR=24;
public static final int GT=25;
public static final int HEX_DIGIT=26;
public static final int ID=27;
public static final int IMPORT=28;
public static final int INT=29;
public static final int LEXER=30;
public static final int LEXER_CHAR_SET=31;
public static final int LOCALS=32;
public static final int LPAREN=33;
public static final int LT=34;
public static final int MODE=35;
public static final int NESTED_ACTION=36;
public static final int NLCHARS=37;
public static final int NOT=38;
public static final int NameChar=39;
public static final int NameStartChar=40;
public static final int OPTIONS=41;
public static final int OR=42;
public static final int PARSER=43;
public static final int PLUS=44;
public static final int PLUS_ASSIGN=45;
public static final int POUND=46;
public static final int PRIVATE=47;
public static final int PROTECTED=48;
public static final int PUBLIC=49;
public static final int QUESTION=50;
public static final int RANGE=51;
public static final int RARROW=52;
public static final int RBRACE=53;
public static final int RETURNS=54;
public static final int RPAREN=55;
public static final int RULE_REF=56;
public static final int SEMI=57;
public static final int SEMPRED=58;
public static final int SRC=59;
public static final int STAR=60;
public static final int STRING_LITERAL=61;
public static final int SYNPRED=62;
public static final int THROWS=63;
public static final int TOKENS_SPEC=64;
public static final int TOKEN_REF=65;
public static final int TREE_GRAMMAR=66;
public static final int UNICODE_ESC=67;
public static final int WS=68;
public static final int WSCHARS=69;
public static final int WSNLCHARS=70;
public static final int ALT=71;
public static final int ALTLIST=72;
public static final int ARG=73;
public static final int ARGLIST=74;
public static final int BLOCK=75;
public static final int CHAR_RANGE=76;
public static final int CLOSURE=77;
public static final int COMBINED=78;
public static final int ELEMENT_OPTIONS=79;
public static final int EPSILON=80;
public static final int INITACTION=81;
public static final int LABEL=82;
public static final int LEXER_ACTION_CALL=83;
public static final int LEXER_ALT_ACTION=84;
public static final int LIST=85;
public static final int OPTIONAL=86;
public static final int POSITIVE_CLOSURE=87;
public static final int PREC_RULE=88;
public static final int RESULT=89;
public static final int RET=90;
public static final int RULE=91;
public static final int RULEACTIONS=92;
public static final int RULEMODIFIERS=93;
public static final int RULES=94;
public static final int SET=95;
public static final int TEMPLATE=96;
public static final int WILDCARD=97;
// 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 : ( DOC_COMMENT )? grammarType id SEMI sync ( prequelConstruct sync )* rules ( modeSpec )* EOF -> ^( grammarType id ( DOC_COMMENT )? ( 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 DOC_COMMENT1=null;
Token SEMI4=null;
Token EOF10=null;
ParserRuleReturnScope grammarType2 =null;
ParserRuleReturnScope id3 =null;
ParserRuleReturnScope sync5 =null;
ParserRuleReturnScope prequelConstruct6 =null;
ParserRuleReturnScope sync7 =null;
ParserRuleReturnScope rules8 =null;
ParserRuleReturnScope modeSpec9 =null;
GrammarAST DOC_COMMENT1_tree=null;
GrammarAST SEMI4_tree=null;
GrammarAST EOF10_tree=null;
RewriteRuleTokenStream stream_DOC_COMMENT=new RewriteRuleTokenStream(adaptor,"token DOC_COMMENT");
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: ( ( DOC_COMMENT )? grammarType id SEMI sync ( prequelConstruct sync )* rules ( modeSpec )* EOF -> ^( grammarType id ( DOC_COMMENT )? ( prequelConstruct )* rules ( modeSpec )* ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:157:7: ( DOC_COMMENT )? grammarType id SEMI sync ( prequelConstruct sync )* rules ( modeSpec )* EOF
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:157:7: ( DOC_COMMENT )?
int alt1=2;
int LA1_0 = input.LA(1);
if ( (LA1_0==DOC_COMMENT) ) {
alt1=1;
}
switch (alt1) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:157:7: DOC_COMMENT
{
DOC_COMMENT1=(Token)match(input,DOC_COMMENT,FOLLOW_DOC_COMMENT_in_grammarSpec402);
stream_DOC_COMMENT.add(DOC_COMMENT1);
}
break;
}
pushFollow(FOLLOW_grammarType_in_grammarSpec433);
grammarType2=grammarType();
state._fsp--;
stream_grammarType.add(grammarType2.getTree());
pushFollow(FOLLOW_id_in_grammarSpec435);
id3=id();
state._fsp--;
stream_id.add(id3.getTree());
SEMI4=(Token)match(input,SEMI,FOLLOW_SEMI_in_grammarSpec437);
stream_SEMI.add(SEMI4);
pushFollow(FOLLOW_sync_in_grammarSpec475);
sync5=sync();
state._fsp--;
stream_sync.add(sync5.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:175:12: ( prequelConstruct sync )*
loop2:
while (true) {
int alt2=2;
int LA2_0 = input.LA(1);
if ( (LA2_0==AT||LA2_0==IMPORT||LA2_0==OPTIONS||LA2_0==TOKENS_SPEC) ) {
alt2=1;
}
switch (alt2) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:175:14: prequelConstruct sync
{
pushFollow(FOLLOW_prequelConstruct_in_grammarSpec479);
prequelConstruct6=prequelConstruct();
state._fsp--;
stream_prequelConstruct.add(prequelConstruct6.getTree());
pushFollow(FOLLOW_sync_in_grammarSpec481);
sync7=sync();
state._fsp--;
stream_sync.add(sync7.getTree());
}
break;
default :
break loop2;
}
}
pushFollow(FOLLOW_rules_in_grammarSpec506);
rules8=rules();
state._fsp--;
stream_rules.add(rules8.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:183:4: ( modeSpec )*
loop3:
while (true) {
int alt3=2;
int LA3_0 = input.LA(1);
if ( (LA3_0==MODE) ) {
alt3=1;
}
switch (alt3) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:183:4: modeSpec
{
pushFollow(FOLLOW_modeSpec_in_grammarSpec512);
modeSpec9=modeSpec();
state._fsp--;
stream_modeSpec.add(modeSpec9.getTree());
}
break;
default :
break loop3;
}
}
EOF10=(Token)match(input,EOF,FOLLOW_EOF_in_grammarSpec550);
stream_EOF.add(EOF10);
// AST REWRITE
// elements: DOC_COMMENT, prequelConstruct, id, modeSpec, rules, 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();
// 196:7: -> ^( grammarType id ( DOC_COMMENT )? ( prequelConstruct )* rules ( modeSpec )* )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:196:10: ^( grammarType id ( DOC_COMMENT )? ( 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:198:14: ( DOC_COMMENT )?
if ( stream_DOC_COMMENT.hasNext() ) {
adaptor.addChild(root_1, stream_DOC_COMMENT.nextNode());
}
stream_DOC_COMMENT.reset();
// org\\antlr\\v4\\parse\\ANTLRParser.g:199: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:201: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:205: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:211: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:211: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:211: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 alt4=4;
switch ( input.LA(1) ) {
case LEXER:
{
alt4=1;
}
break;
case PARSER:
{
alt4=2;
}
break;
case GRAMMAR:
{
alt4=3;
}
break;
case TREE_GRAMMAR:
{
alt4=4;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 4, 0, input);
throw nvae;
}
switch (alt4) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:211:9: t= LEXER g= GRAMMAR
{
t=(Token)match(input,LEXER,FOLLOW_LEXER_in_grammarType740);
stream_LEXER.add(t);
g=(Token)match(input,GRAMMAR,FOLLOW_GRAMMAR_in_grammarType744);
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();
// 211: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:213:6: t= PARSER g= GRAMMAR
{
t=(Token)match(input,PARSER,FOLLOW_PARSER_in_grammarType767);
stream_PARSER.add(t);
g=(Token)match(input,GRAMMAR,FOLLOW_GRAMMAR_in_grammarType771);
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();
// 213: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:216:6: g= GRAMMAR
{
g=(Token)match(input,GRAMMAR,FOLLOW_GRAMMAR_in_grammarType792);
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();
// 216: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:217:7: tg= TREE_GRAMMAR
{
tg=(Token)match(input,TREE_GRAMMAR,FOLLOW_TREE_GRAMMAR_in_grammarType819);
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:225:1: prequelConstruct : ( optionsSpec | delegateGrammars | tokensSpec | 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 optionsSpec11 =null;
ParserRuleReturnScope delegateGrammars12 =null;
ParserRuleReturnScope tokensSpec13 =null;
ParserRuleReturnScope action14 =null;
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:226:2: ( optionsSpec | delegateGrammars | tokensSpec | action )
int alt5=4;
switch ( input.LA(1) ) {
case OPTIONS:
{
alt5=1;
}
break;
case IMPORT:
{
alt5=2;
}
break;
case TOKENS_SPEC:
{
alt5=3;
}
break;
case AT:
{
alt5=4;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 5, 0, input);
throw nvae;
}
switch (alt5) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:227:4: optionsSpec
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_optionsSpec_in_prequelConstruct845);
optionsSpec11=optionsSpec();
state._fsp--;
adaptor.addChild(root_0, optionsSpec11.getTree());
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:231:7: delegateGrammars
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_delegateGrammars_in_prequelConstruct868);
delegateGrammars12=delegateGrammars();
state._fsp--;
adaptor.addChild(root_0, delegateGrammars12.getTree());
}
break;
case 3 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:238:7: tokensSpec
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_tokensSpec_in_prequelConstruct912);
tokensSpec13=tokensSpec();
state._fsp--;
adaptor.addChild(root_0, tokensSpec13.getTree());
}
break;
case 4 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:244:7: action
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_action_in_prequelConstruct949);
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:248: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:249:2: ( OPTIONS ( option SEMI )* RBRACE -> ^( OPTIONS[$OPTIONS, \"OPTIONS\"] ( option )* ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:249:4: OPTIONS ( option SEMI )* RBRACE
{
OPTIONS15=(Token)match(input,OPTIONS,FOLLOW_OPTIONS_in_optionsSpec964);
stream_OPTIONS.add(OPTIONS15);
// org\\antlr\\v4\\parse\\ANTLRParser.g:249:12: ( option SEMI )*
loop6:
while (true) {
int alt6=2;
int LA6_0 = input.LA(1);
if ( (LA6_0==RULE_REF||LA6_0==TOKEN_REF) ) {
alt6=1;
}
switch (alt6) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:249:13: option SEMI
{
pushFollow(FOLLOW_option_in_optionsSpec967);
option16=option();
state._fsp--;
stream_option.add(option16.getTree());
SEMI17=(Token)match(input,SEMI,FOLLOW_SEMI_in_optionsSpec969);
stream_SEMI.add(SEMI17);
}
break;
default :
break loop6;
}
}
RBRACE18=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_optionsSpec973);
stream_RBRACE.add(RBRACE18);
// AST REWRITE
// elements: option, OPTIONS
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 249:34: -> ^( OPTIONS[$OPTIONS, \"OPTIONS\"] ( option )* )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:249: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:249: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:252: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:253:5: ( id ASSIGN ^ optionValue )
// org\\antlr\\v4\\parse\\ANTLRParser.g:253:9: id ASSIGN ^ optionValue
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_id_in_option1002);
id19=id();
state._fsp--;
adaptor.addChild(root_0, id19.getTree());
ASSIGN20=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_option1004);
ASSIGN20_tree = (GrammarAST)adaptor.create(ASSIGN20);
root_0 = (GrammarAST)adaptor.becomeRoot(ASSIGN20_tree, root_0);
pushFollow(FOLLOW_optionValue_in_option1007);
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:261: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:262:5: ( qid | STRING_LITERAL | ACTION | INT )
int alt7=4;
switch ( input.LA(1) ) {
case RULE_REF:
case TOKEN_REF:
{
alt7=1;
}
break;
case STRING_LITERAL:
{
alt7=2;
}
break;
case ACTION:
{
alt7=3;
}
break;
case INT:
{
alt7=4;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 7, 0, input);
throw nvae;
}
switch (alt7) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:265:7: qid
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_qid_in_optionValue1050);
qid22=qid();
state._fsp--;
adaptor.addChild(root_0, qid22.getTree());
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:266:7: STRING_LITERAL
{
root_0 = (GrammarAST)adaptor.nil();
STRING_LITERAL23=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_optionValue1058);
STRING_LITERAL23_tree = (GrammarAST)adaptor.create(STRING_LITERAL23);
adaptor.addChild(root_0, STRING_LITERAL23_tree);
}
break;
case 3 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:267:4: ACTION
{
root_0 = (GrammarAST)adaptor.nil();
ACTION24=(Token)match(input,ACTION,FOLLOW_ACTION_in_optionValue1063);
ACTION24_tree = new ActionAST(ACTION24) ;
adaptor.addChild(root_0, ACTION24_tree);
}
break;
case 4 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:268:7: INT
{
root_0 = (GrammarAST)adaptor.nil();
INT25=(Token)match(input,INT,FOLLOW_INT_in_optionValue1074);
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:273: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:274:2: ( IMPORT delegateGrammar ( COMMA delegateGrammar )* SEMI -> ^( IMPORT ( delegateGrammar )+ ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:274:4: IMPORT delegateGrammar ( COMMA delegateGrammar )* SEMI
{
IMPORT26=(Token)match(input,IMPORT,FOLLOW_IMPORT_in_delegateGrammars1090);
stream_IMPORT.add(IMPORT26);
pushFollow(FOLLOW_delegateGrammar_in_delegateGrammars1092);
delegateGrammar27=delegateGrammar();
state._fsp--;
stream_delegateGrammar.add(delegateGrammar27.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:274:27: ( COMMA delegateGrammar )*
loop8:
while (true) {
int alt8=2;
int LA8_0 = input.LA(1);
if ( (LA8_0==COMMA) ) {
alt8=1;
}
switch (alt8) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:274:28: COMMA delegateGrammar
{
COMMA28=(Token)match(input,COMMA,FOLLOW_COMMA_in_delegateGrammars1095);
stream_COMMA.add(COMMA28);
pushFollow(FOLLOW_delegateGrammar_in_delegateGrammars1097);
delegateGrammar29=delegateGrammar();
state._fsp--;
stream_delegateGrammar.add(delegateGrammar29.getTree());
}
break;
default :
break loop8;
}
}
SEMI30=(Token)match(input,SEMI,FOLLOW_SEMI_in_delegateGrammars1101);
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();
// 274:57: -> ^( IMPORT ( delegateGrammar )+ )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:274: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:279: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:280:5: ( id ASSIGN ^ id | id )
int alt9=2;
int LA9_0 = input.LA(1);
if ( (LA9_0==RULE_REF) ) {
int LA9_1 = input.LA(2);
if ( (LA9_1==ASSIGN) ) {
alt9=1;
}
else if ( (LA9_1==COMMA||LA9_1==SEMI) ) {
alt9=2;
}
else {
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 9, 1, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
else if ( (LA9_0==TOKEN_REF) ) {
int LA9_2 = input.LA(2);
if ( (LA9_2==ASSIGN) ) {
alt9=1;
}
else if ( (LA9_2==COMMA||LA9_2==SEMI) ) {
alt9=2;
}
else {
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 9, 2, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
else {
NoViableAltException nvae =
new NoViableAltException("", 9, 0, input);
throw nvae;
}
switch (alt9) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:280:9: id ASSIGN ^ id
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_id_in_delegateGrammar1128);
id31=id();
state._fsp--;
adaptor.addChild(root_0, id31.getTree());
ASSIGN32=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_delegateGrammar1130);
ASSIGN32_tree = (GrammarAST)adaptor.create(ASSIGN32);
root_0 = (GrammarAST)adaptor.becomeRoot(ASSIGN32_tree, root_0);
pushFollow(FOLLOW_id_in_delegateGrammar1133);
id33=id();
state._fsp--;
adaptor.addChild(root_0, id33.getTree());
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:281:9: id
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_id_in_delegateGrammar1143);
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:284: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:285:2: ( TOKENS_SPEC id ( COMMA id )* ( COMMA )? RBRACE -> ^( TOKENS_SPEC ( id )+ ) | TOKENS_SPEC RBRACE ->| TOKENS_SPEC ^ ( v3tokenSpec )+ RBRACE !)
int alt13=3;
int LA13_0 = input.LA(1);
if ( (LA13_0==TOKENS_SPEC) ) {
switch ( input.LA(2) ) {
case RBRACE:
{
alt13=2;
}
break;
case RULE_REF:
{
int LA13_3 = input.LA(3);
if ( (LA13_3==COMMA||LA13_3==RBRACE) ) {
alt13=1;
}
else if ( (LA13_3==ASSIGN||LA13_3==SEMI) ) {
alt13=3;
}
else {
int nvaeMark = input.mark();
try {
for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) {
input.consume();
}
NoViableAltException nvae =
new NoViableAltException("", 13, 3, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case TOKEN_REF:
{
int LA13_4 = input.LA(3);
if ( (LA13_4==COMMA||LA13_4==RBRACE) ) {
alt13=1;
}
else if ( (LA13_4==ASSIGN||LA13_4==SEMI) ) {
alt13=3;
}
else {
int nvaeMark = input.mark();
try {
for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) {
input.consume();
}
NoViableAltException nvae =
new NoViableAltException("", 13, 4, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
default:
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 13, 1, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
else {
NoViableAltException nvae =
new NoViableAltException("", 13, 0, input);
throw nvae;
}
switch (alt13) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:285:4: TOKENS_SPEC id ( COMMA id )* ( COMMA )? RBRACE
{
TOKENS_SPEC35=(Token)match(input,TOKENS_SPEC,FOLLOW_TOKENS_SPEC_in_tokensSpec1157);
stream_TOKENS_SPEC.add(TOKENS_SPEC35);
pushFollow(FOLLOW_id_in_tokensSpec1159);
id36=id();
state._fsp--;
stream_id.add(id36.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:285:19: ( COMMA id )*
loop10:
while (true) {
int alt10=2;
int LA10_0 = input.LA(1);
if ( (LA10_0==COMMA) ) {
int LA10_1 = input.LA(2);
if ( (LA10_1==RULE_REF||LA10_1==TOKEN_REF) ) {
alt10=1;
}
}
switch (alt10) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:285:20: COMMA id
{
COMMA37=(Token)match(input,COMMA,FOLLOW_COMMA_in_tokensSpec1162);
stream_COMMA.add(COMMA37);
pushFollow(FOLLOW_id_in_tokensSpec1164);
id38=id();
state._fsp--;
stream_id.add(id38.getTree());
}
break;
default :
break loop10;
}
}
// org\\antlr\\v4\\parse\\ANTLRParser.g:285:31: ( COMMA )?
int alt11=2;
int LA11_0 = input.LA(1);
if ( (LA11_0==COMMA) ) {
alt11=1;
}
switch (alt11) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:285:31: COMMA
{
COMMA39=(Token)match(input,COMMA,FOLLOW_COMMA_in_tokensSpec1168);
stream_COMMA.add(COMMA39);
}
break;
}
RBRACE40=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_tokensSpec1171);
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();
// 285:45: -> ^( TOKENS_SPEC ( id )+ )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:285: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:286:7: TOKENS_SPEC RBRACE
{
TOKENS_SPEC41=(Token)match(input,TOKENS_SPEC,FOLLOW_TOKENS_SPEC_in_tokensSpec1188);
stream_TOKENS_SPEC.add(TOKENS_SPEC41);
RBRACE42=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_tokensSpec1190);
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();
// 286:26: ->
{
root_0 = null;
}
retval.tree = root_0;
}
break;
case 3 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:287:7: TOKENS_SPEC ^ ( v3tokenSpec )+ RBRACE !
{
root_0 = (GrammarAST)adaptor.nil();
TOKENS_SPEC43=(Token)match(input,TOKENS_SPEC,FOLLOW_TOKENS_SPEC_in_tokensSpec1200);
TOKENS_SPEC43_tree = (GrammarAST)adaptor.create(TOKENS_SPEC43);
root_0 = (GrammarAST)adaptor.becomeRoot(TOKENS_SPEC43_tree, root_0);
// org\\antlr\\v4\\parse\\ANTLRParser.g:287:20: ( v3tokenSpec )+
int cnt12=0;
loop12:
while (true) {
int alt12=2;
int LA12_0 = input.LA(1);
if ( (LA12_0==RULE_REF||LA12_0==TOKEN_REF) ) {
alt12=1;
}
switch (alt12) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:287:20: v3tokenSpec
{
pushFollow(FOLLOW_v3tokenSpec_in_tokensSpec1203);
v3tokenSpec44=v3tokenSpec();
state._fsp--;
adaptor.addChild(root_0, v3tokenSpec44.getTree());
}
break;
default :
if ( cnt12 >= 1 ) break loop12;
EarlyExitException eee = new EarlyExitException(12, input);
throw eee;
}
cnt12++;
}
RBRACE45=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_tokensSpec1206);
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:291: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:292:2: ( id ( ASSIGN lit= STRING_LITERAL -> id | -> id ) SEMI )
// org\\antlr\\v4\\parse\\ANTLRParser.g:292:4: id ( ASSIGN lit= STRING_LITERAL -> id | -> id ) SEMI
{
pushFollow(FOLLOW_id_in_v3tokenSpec1226);
id46=id();
state._fsp--;
stream_id.add(id46.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:293:3: ( ASSIGN lit= STRING_LITERAL -> id | -> id )
int alt14=2;
int LA14_0 = input.LA(1);
if ( (LA14_0==ASSIGN) ) {
alt14=1;
}
else if ( (LA14_0==SEMI) ) {
alt14=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 14, 0, input);
throw nvae;
}
switch (alt14) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:293:5: ASSIGN lit= STRING_LITERAL
{
ASSIGN47=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_v3tokenSpec1232);
stream_ASSIGN.add(ASSIGN47);
lit=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_v3tokenSpec1236);
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();
// 298:20: -> id
{
adaptor.addChild(root_0, stream_id.nextTree());
}
retval.tree = root_0;
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:299: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();
// 299:12: -> id
{
adaptor.addChild(root_0, stream_id.nextTree());
}
retval.tree = root_0;
}
break;
}
SEMI48=(Token)match(input,SEMI,FOLLOW_SEMI_in_v3tokenSpec1297);
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 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 AT49=null;
Token COLONCOLON51=null;
Token ACTION53=null;
ParserRuleReturnScope actionScopeName50 =null;
ParserRuleReturnScope id52 =null;
GrammarAST AT49_tree=null;
GrammarAST COLONCOLON51_tree=null;
GrammarAST ACTION53_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
{
AT49=(Token)match(input,AT,FOLLOW_AT_in_action1313);
stream_AT.add(AT49);
// org\\antlr\\v4\\parse\\ANTLRParser.g:309:7: ( actionScopeName COLONCOLON )?
int alt15=2;
switch ( input.LA(1) ) {
case RULE_REF:
{
int LA15_1 = input.LA(2);
if ( (LA15_1==COLONCOLON) ) {
alt15=1;
}
}
break;
case TOKEN_REF:
{
int LA15_2 = input.LA(2);
if ( (LA15_2==COLONCOLON) ) {
alt15=1;
}
}
break;
case LEXER:
case PARSER:
{
alt15=1;
}
break;
}
switch (alt15) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:309:8: actionScopeName COLONCOLON
{
pushFollow(FOLLOW_actionScopeName_in_action1316);
actionScopeName50=actionScopeName();
state._fsp--;
stream_actionScopeName.add(actionScopeName50.getTree());
COLONCOLON51=(Token)match(input,COLONCOLON,FOLLOW_COLONCOLON_in_action1318);
stream_COLONCOLON.add(COLONCOLON51);
}
break;
}
pushFollow(FOLLOW_id_in_action1322);
id52=id();
state._fsp--;
stream_id.add(id52.getTree());
ACTION53=(Token)match(input,ACTION,FOLLOW_ACTION_in_action1324);
stream_ACTION.add(ACTION53);
// AST REWRITE
// elements: actionScopeName, id, AT, ACTION
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 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 LEXER55=null;
Token PARSER56=null;
ParserRuleReturnScope id54 =null;
GrammarAST LEXER55_tree=null;
GrammarAST PARSER56_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 alt16=3;
switch ( input.LA(1) ) {
case RULE_REF:
case TOKEN_REF:
{
alt16=1;
}
break;
case LEXER:
{
alt16=2;
}
break;
case PARSER:
{
alt16=3;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 16, 0, input);
throw nvae;
}
switch (alt16) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:316:4: id
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_id_in_actionScopeName1353);
id54=id();
state._fsp--;
adaptor.addChild(root_0, id54.getTree());
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:317:4: LEXER
{
LEXER55=(Token)match(input,LEXER,FOLLOW_LEXER_in_actionScopeName1358);
stream_LEXER.add(LEXER55);
// 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, LEXER55));
}
retval.tree = root_0;
}
break;
case 3 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:318:9: PARSER
{
PARSER56=(Token)match(input,PARSER,FOLLOW_PARSER_in_actionScopeName1373);
stream_PARSER.add(PARSER56);
// 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, PARSER56));
}
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 MODE57=null;
Token SEMI59=null;
ParserRuleReturnScope id58 =null;
ParserRuleReturnScope sync60 =null;
ParserRuleReturnScope lexerRule61 =null;
ParserRuleReturnScope sync62 =null;
GrammarAST MODE57_tree=null;
GrammarAST SEMI59_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 )*
{
MODE57=(Token)match(input,MODE,FOLLOW_MODE_in_modeSpec1392);
stream_MODE.add(MODE57);
pushFollow(FOLLOW_id_in_modeSpec1394);
id58=id();
state._fsp--;
stream_id.add(id58.getTree());
SEMI59=(Token)match(input,SEMI,FOLLOW_SEMI_in_modeSpec1396);
stream_SEMI.add(SEMI59);
pushFollow(FOLLOW_sync_in_modeSpec1398);
sync60=sync();
state._fsp--;
stream_sync.add(sync60.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:322:25: ( lexerRule sync )*
loop17:
while (true) {
int alt17=2;
int LA17_0 = input.LA(1);
if ( (LA17_0==DOC_COMMENT||LA17_0==FRAGMENT||LA17_0==TOKEN_REF) ) {
alt17=1;
}
switch (alt17) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:322:26: lexerRule sync
{
pushFollow(FOLLOW_lexerRule_in_modeSpec1401);
lexerRule61=lexerRule();
state._fsp--;
stream_lexerRule.add(lexerRule61.getTree());
pushFollow(FOLLOW_sync_in_modeSpec1403);
sync62=sync();
state._fsp--;
stream_sync.add(sync62.getTree());
}
break;
default :
break loop17;
}
}
// AST REWRITE
// elements: id, lexerRule, MODE
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 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 sync63 =null;
ParserRuleReturnScope rule64 =null;
ParserRuleReturnScope sync65 =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_rules1434);
sync63=sync();
state._fsp--;
stream_sync.add(sync63.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:326:12: ( rule sync )*
loop18:
while (true) {
int alt18=2;
int LA18_0 = input.LA(1);
if ( (LA18_0==DOC_COMMENT||LA18_0==FRAGMENT||LA18_0==RULE_REF||LA18_0==TOKEN_REF) ) {
alt18=1;
}
switch (alt18) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:326:13: rule sync
{
pushFollow(FOLLOW_rule_in_rules1437);
rule64=rule();
state._fsp--;
stream_rule.add(rule64.getTree());
pushFollow(FOLLOW_sync_in_rules1439);
sync65=sync();
state._fsp--;
stream_sync.add(sync65.getTree());
}
break;
default :
break loop18;
}
}
// 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 parserRule66 =null;
ParserRuleReturnScope lexerRule67 =null;
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:345:5: ( parserRule | lexerRule )
int alt19=2;
switch ( input.LA(1) ) {
case DOC_COMMENT:
{
int LA19_1 = input.LA(2);
if ( (LA19_1==RULE_REF) ) {
alt19=1;
}
else if ( (LA19_1==FRAGMENT||LA19_1==TOKEN_REF) ) {
alt19=2;
}
else {
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 19, 1, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case RULE_REF:
{
alt19=1;
}
break;
case FRAGMENT:
case TOKEN_REF:
{
alt19=2;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 19, 0, input);
throw nvae;
}
switch (alt19) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:345:7: parserRule
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_parserRule_in_rule1501);
parserRule66=parserRule();
state._fsp--;
adaptor.addChild(root_0, parserRule66.getTree());
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:346:4: lexerRule
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_lexerRule_in_rule1506);
lexerRule67=lexerRule();
state._fsp--;
adaptor.addChild(root_0, lexerRule67.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 : ( DOC_COMMENT )? RULE_REF ( ARG_ACTION )? ( ruleReturns )? ( throwsSpec )? ( localsSpec )? rulePrequels COLON ruleBlock SEMI exceptionGroup -> ^( RULE RULE_REF ( DOC_COMMENT )? ( 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 DOC_COMMENT68=null;
Token RULE_REF69=null;
Token ARG_ACTION70=null;
Token COLON75=null;
Token SEMI77=null;
ParserRuleReturnScope ruleReturns71 =null;
ParserRuleReturnScope throwsSpec72 =null;
ParserRuleReturnScope localsSpec73 =null;
ParserRuleReturnScope rulePrequels74 =null;
ParserRuleReturnScope ruleBlock76 =null;
ParserRuleReturnScope exceptionGroup78 =null;
GrammarAST DOC_COMMENT68_tree=null;
GrammarAST RULE_REF69_tree=null;
GrammarAST ARG_ACTION70_tree=null;
GrammarAST COLON75_tree=null;
GrammarAST SEMI77_tree=null;
RewriteRuleTokenStream stream_DOC_COMMENT=new RewriteRuleTokenStream(adaptor,"token DOC_COMMENT");
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: ( ( DOC_COMMENT )? RULE_REF ( ARG_ACTION )? ( ruleReturns )? ( throwsSpec )? ( localsSpec )? rulePrequels COLON ruleBlock SEMI exceptionGroup -> ^( RULE RULE_REF ( DOC_COMMENT )? ( ARG_ACTION )? ( ruleReturns )? ( throwsSpec )? ( localsSpec )? ( rulePrequels )? ruleBlock ( exceptionGroup )* ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:368:7: ( DOC_COMMENT )? RULE_REF ( ARG_ACTION )? ( ruleReturns )? ( throwsSpec )? ( localsSpec )? rulePrequels COLON ruleBlock SEMI exceptionGroup
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:368:7: ( DOC_COMMENT )?
int alt20=2;
int LA20_0 = input.LA(1);
if ( (LA20_0==DOC_COMMENT) ) {
alt20=1;
}
switch (alt20) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:368:7: DOC_COMMENT
{
DOC_COMMENT68=(Token)match(input,DOC_COMMENT,FOLLOW_DOC_COMMENT_in_parserRule1546);
stream_DOC_COMMENT.add(DOC_COMMENT68);
}
break;
}
RULE_REF69=(Token)match(input,RULE_REF,FOLLOW_RULE_REF_in_parserRule1569);
stream_RULE_REF.add(RULE_REF69);
// org\\antlr\\v4\\parse\\ANTLRParser.g:382:4: ( ARG_ACTION )?
int alt21=2;
int LA21_0 = input.LA(1);
if ( (LA21_0==ARG_ACTION) ) {
alt21=1;
}
switch (alt21) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:382:4: ARG_ACTION
{
ARG_ACTION70=(Token)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_parserRule1599);
stream_ARG_ACTION.add(ARG_ACTION70);
}
break;
}
// org\\antlr\\v4\\parse\\ANTLRParser.g:384:4: ( ruleReturns )?
int alt22=2;
int LA22_0 = input.LA(1);
if ( (LA22_0==RETURNS) ) {
alt22=1;
}
switch (alt22) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:384:4: ruleReturns
{
pushFollow(FOLLOW_ruleReturns_in_parserRule1606);
ruleReturns71=ruleReturns();
state._fsp--;
stream_ruleReturns.add(ruleReturns71.getTree());
}
break;
}
// org\\antlr\\v4\\parse\\ANTLRParser.g:386:4: ( throwsSpec )?
int alt23=2;
int LA23_0 = input.LA(1);
if ( (LA23_0==THROWS) ) {
alt23=1;
}
switch (alt23) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:386:4: throwsSpec
{
pushFollow(FOLLOW_throwsSpec_in_parserRule1613);
throwsSpec72=throwsSpec();
state._fsp--;
stream_throwsSpec.add(throwsSpec72.getTree());
}
break;
}
// org\\antlr\\v4\\parse\\ANTLRParser.g:388:4: ( localsSpec )?
int alt24=2;
int LA24_0 = input.LA(1);
if ( (LA24_0==LOCALS) ) {
alt24=1;
}
switch (alt24) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:388:4: localsSpec
{
pushFollow(FOLLOW_localsSpec_in_parserRule1620);
localsSpec73=localsSpec();
state._fsp--;
stream_localsSpec.add(localsSpec73.getTree());
}
break;
}
pushFollow(FOLLOW_rulePrequels_in_parserRule1658);
rulePrequels74=rulePrequels();
state._fsp--;
stream_rulePrequels.add(rulePrequels74.getTree());
COLON75=(Token)match(input,COLON,FOLLOW_COLON_in_parserRule1667);
stream_COLON.add(COLON75);
pushFollow(FOLLOW_ruleBlock_in_parserRule1690);
ruleBlock76=ruleBlock();
state._fsp--;
stream_ruleBlock.add(ruleBlock76.getTree());
SEMI77=(Token)match(input,SEMI,FOLLOW_SEMI_in_parserRule1699);
stream_SEMI.add(SEMI77);
pushFollow(FOLLOW_exceptionGroup_in_parserRule1708);
exceptionGroup78=exceptionGroup();
state._fsp--;
stream_exceptionGroup.add(exceptionGroup78.getTree());
// AST REWRITE
// elements: DOC_COMMENT, ruleReturns, ARG_ACTION, localsSpec, rulePrequels, RULE_REF, exceptionGroup, throwsSpec, ruleBlock
// 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();
// 415:7: -> ^( RULE RULE_REF ( DOC_COMMENT )? ( ARG_ACTION )? ( ruleReturns )? ( throwsSpec )? ( localsSpec )? ( rulePrequels )? ruleBlock ( exceptionGroup )* )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:415:10: ^( RULE RULE_REF ( DOC_COMMENT )? ( 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:415:36: ( DOC_COMMENT )?
if ( stream_DOC_COMMENT.hasNext() ) {
adaptor.addChild(root_1, stream_DOC_COMMENT.nextNode());
}
stream_DOC_COMMENT.reset();
// org\\antlr\\v4\\parse\\ANTLRParser.g:415:49: ( 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:416:9: ( ruleReturns )?
if ( stream_ruleReturns.hasNext() ) {
adaptor.addChild(root_1, stream_ruleReturns.nextTree());
}
stream_ruleReturns.reset();
// org\\antlr\\v4\\parse\\ANTLRParser.g:416:22: ( throwsSpec )?
if ( stream_throwsSpec.hasNext() ) {
adaptor.addChild(root_1, stream_throwsSpec.nextTree());
}
stream_throwsSpec.reset();
// org\\antlr\\v4\\parse\\ANTLRParser.g:416:34: ( localsSpec )?
if ( stream_localsSpec.hasNext() ) {
adaptor.addChild(root_1, stream_localsSpec.nextTree());
}
stream_localsSpec.reset();
// org\\antlr\\v4\\parse\\ANTLRParser.g:416: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:416: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:426: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 exceptionHandler79 =null;
ParserRuleReturnScope finallyClause80 =null;
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:427:5: ( ( exceptionHandler )* ( finallyClause )? )
// org\\antlr\\v4\\parse\\ANTLRParser.g:427:7: ( exceptionHandler )* ( finallyClause )?
{
root_0 = (GrammarAST)adaptor.nil();
// org\\antlr\\v4\\parse\\ANTLRParser.g:427:7: ( exceptionHandler )*
loop25:
while (true) {
int alt25=2;
int LA25_0 = input.LA(1);
if ( (LA25_0==CATCH) ) {
alt25=1;
}
switch (alt25) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:427:7: exceptionHandler
{
pushFollow(FOLLOW_exceptionHandler_in_exceptionGroup1794);
exceptionHandler79=exceptionHandler();
state._fsp--;
adaptor.addChild(root_0, exceptionHandler79.getTree());
}
break;
default :
break loop25;
}
}
// org\\antlr\\v4\\parse\\ANTLRParser.g:427:25: ( finallyClause )?
int alt26=2;
int LA26_0 = input.LA(1);
if ( (LA26_0==FINALLY) ) {
alt26=1;
}
switch (alt26) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:427:25: finallyClause
{
pushFollow(FOLLOW_finallyClause_in_exceptionGroup1797);
finallyClause80=finallyClause();
state._fsp--;
adaptor.addChild(root_0, finallyClause80.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:432: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 CATCH81=null;
Token ARG_ACTION82=null;
Token ACTION83=null;
GrammarAST CATCH81_tree=null;
GrammarAST ARG_ACTION82_tree=null;
GrammarAST ACTION83_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:433:2: ( CATCH ARG_ACTION ACTION -> ^( CATCH ARG_ACTION ACTION ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:433:4: CATCH ARG_ACTION ACTION
{
CATCH81=(Token)match(input,CATCH,FOLLOW_CATCH_in_exceptionHandler1814);
stream_CATCH.add(CATCH81);
ARG_ACTION82=(Token)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_exceptionHandler1816);
stream_ARG_ACTION.add(ARG_ACTION82);
ACTION83=(Token)match(input,ACTION,FOLLOW_ACTION_in_exceptionHandler1818);
stream_ACTION.add(ACTION83);
// AST REWRITE
// elements: ARG_ACTION, ACTION, CATCH
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 433:28: -> ^( CATCH ARG_ACTION ACTION )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:433: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:436: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 FINALLY84=null;
Token ACTION85=null;
GrammarAST FINALLY84_tree=null;
GrammarAST ACTION85_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:437:2: ( FINALLY ACTION -> ^( FINALLY ACTION ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:437:4: FINALLY ACTION
{
FINALLY84=(Token)match(input,FINALLY,FOLLOW_FINALLY_in_finallyClause1845);
stream_FINALLY.add(FINALLY84);
ACTION85=(Token)match(input,ACTION,FOLLOW_ACTION_in_finallyClause1847);
stream_ACTION.add(ACTION85);
// AST REWRITE
// elements: ACTION, FINALLY
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 437:19: -> ^( FINALLY ACTION )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:437: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:440: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 sync86 =null;
ParserRuleReturnScope rulePrequel87 =null;
ParserRuleReturnScope sync88 =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:443:2: ( sync ( rulePrequel sync )* -> ( rulePrequel )* )
// org\\antlr\\v4\\parse\\ANTLRParser.g:443:4: sync ( rulePrequel sync )*
{
pushFollow(FOLLOW_sync_in_rulePrequels1879);
sync86=sync();
state._fsp--;
stream_sync.add(sync86.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:443:9: ( rulePrequel sync )*
loop27:
while (true) {
int alt27=2;
int LA27_0 = input.LA(1);
if ( (LA27_0==AT||LA27_0==OPTIONS) ) {
alt27=1;
}
switch (alt27) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:443:10: rulePrequel sync
{
pushFollow(FOLLOW_rulePrequel_in_rulePrequels1882);
rulePrequel87=rulePrequel();
state._fsp--;
stream_rulePrequel.add(rulePrequel87.getTree());
pushFollow(FOLLOW_sync_in_rulePrequels1884);
sync88=sync();
state._fsp--;
stream_sync.add(sync88.getTree());
}
break;
default :
break loop27;
}
}
// 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();
// 443:29: -> ( rulePrequel )*
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:443: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:449: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 optionsSpec89 =null;
ParserRuleReturnScope ruleAction90 =null;
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:450:5: ( optionsSpec | ruleAction )
int alt28=2;
int LA28_0 = input.LA(1);
if ( (LA28_0==OPTIONS) ) {
alt28=1;
}
else if ( (LA28_0==AT) ) {
alt28=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 28, 0, input);
throw nvae;
}
switch (alt28) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:450:7: optionsSpec
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_optionsSpec_in_rulePrequel1908);
optionsSpec89=optionsSpec();
state._fsp--;
adaptor.addChild(root_0, optionsSpec89.getTree());
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:451:7: ruleAction
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_ruleAction_in_rulePrequel1916);
ruleAction90=ruleAction();
state._fsp--;
adaptor.addChild(root_0, ruleAction90.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:460: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 RETURNS91=null;
Token ARG_ACTION92=null;
GrammarAST RETURNS91_tree=null;
GrammarAST ARG_ACTION92_tree=null;
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:461:2: ( RETURNS ^ ARG_ACTION )
// org\\antlr\\v4\\parse\\ANTLRParser.g:461:4: RETURNS ^ ARG_ACTION
{
root_0 = (GrammarAST)adaptor.nil();
RETURNS91=(Token)match(input,RETURNS,FOLLOW_RETURNS_in_ruleReturns1936);
RETURNS91_tree = (GrammarAST)adaptor.create(RETURNS91);
root_0 = (GrammarAST)adaptor.becomeRoot(RETURNS91_tree, root_0);
ARG_ACTION92=(Token)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_ruleReturns1939);
ARG_ACTION92_tree = new ActionAST(ARG_ACTION92) ;
adaptor.addChild(root_0, ARG_ACTION92_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:475: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 THROWS93=null;
Token COMMA95=null;
ParserRuleReturnScope qid94 =null;
ParserRuleReturnScope qid96 =null;
GrammarAST THROWS93_tree=null;
GrammarAST COMMA95_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:476:5: ( THROWS qid ( COMMA qid )* -> ^( THROWS ( qid )+ ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:476:7: THROWS qid ( COMMA qid )*
{
THROWS93=(Token)match(input,THROWS,FOLLOW_THROWS_in_throwsSpec1967);
stream_THROWS.add(THROWS93);
pushFollow(FOLLOW_qid_in_throwsSpec1969);
qid94=qid();
state._fsp--;
stream_qid.add(qid94.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:476:18: ( COMMA qid )*
loop29:
while (true) {
int alt29=2;
int LA29_0 = input.LA(1);
if ( (LA29_0==COMMA) ) {
alt29=1;
}
switch (alt29) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:476:19: COMMA qid
{
COMMA95=(Token)match(input,COMMA,FOLLOW_COMMA_in_throwsSpec1972);
stream_COMMA.add(COMMA95);
pushFollow(FOLLOW_qid_in_throwsSpec1974);
qid96=qid();
state._fsp--;
stream_qid.add(qid96.getTree());
}
break;
default :
break loop29;
}
}
// AST REWRITE
// elements: THROWS, qid
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 476:31: -> ^( THROWS ( qid )+ )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:476: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:480: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 LOCALS97=null;
Token ARG_ACTION98=null;
GrammarAST LOCALS97_tree=null;
GrammarAST ARG_ACTION98_tree=null;
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:480:12: ( LOCALS ^ ARG_ACTION )
// org\\antlr\\v4\\parse\\ANTLRParser.g:480:14: LOCALS ^ ARG_ACTION
{
root_0 = (GrammarAST)adaptor.nil();
LOCALS97=(Token)match(input,LOCALS,FOLLOW_LOCALS_in_localsSpec1999);
LOCALS97_tree = (GrammarAST)adaptor.create(LOCALS97);
root_0 = (GrammarAST)adaptor.becomeRoot(LOCALS97_tree, root_0);
ARG_ACTION98=(Token)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_localsSpec2002);
ARG_ACTION98_tree = new ActionAST(ARG_ACTION98) ;
adaptor.addChild(root_0, ARG_ACTION98_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:491: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 AT99=null;
Token ACTION101=null;
ParserRuleReturnScope id100 =null;
GrammarAST AT99_tree=null;
GrammarAST ACTION101_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:492:2: ( AT id ACTION -> ^( AT id ACTION ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:492:4: AT id ACTION
{
AT99=(Token)match(input,AT,FOLLOW_AT_in_ruleAction2025);
stream_AT.add(AT99);
pushFollow(FOLLOW_id_in_ruleAction2027);
id100=id();
state._fsp--;
stream_id.add(id100.getTree());
ACTION101=(Token)match(input,ACTION,FOLLOW_ACTION_in_ruleAction2029);
stream_ACTION.add(ACTION101);
// 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();
// 492:17: -> ^( AT id ACTION )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:492: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:501: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 ruleAltList102 =null;
RewriteRuleSubtreeStream stream_ruleAltList=new RewriteRuleSubtreeStream(adaptor,"rule ruleAltList");
Token colon = input.LT(-1);
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:503:5: ( ruleAltList -> ^( BLOCK[colon,\"BLOCK\"] ruleAltList ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:503:7: ruleAltList
{
pushFollow(FOLLOW_ruleAltList_in_ruleBlock2067);
ruleAltList102=ruleAltList();
state._fsp--;
stream_ruleAltList.add(ruleAltList102.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();
// 503:19: -> ^( BLOCK[colon,\"BLOCK\"] ruleAltList )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:503: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:510: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 OR104=null;
ParserRuleReturnScope labeledAlt103 =null;
ParserRuleReturnScope labeledAlt105 =null;
GrammarAST OR104_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:511:2: ( labeledAlt ( OR labeledAlt )* -> ( labeledAlt )+ )
// org\\antlr\\v4\\parse\\ANTLRParser.g:511:4: labeledAlt ( OR labeledAlt )*
{
pushFollow(FOLLOW_labeledAlt_in_ruleAltList2103);
labeledAlt103=labeledAlt();
state._fsp--;
stream_labeledAlt.add(labeledAlt103.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:511:15: ( OR labeledAlt )*
loop30:
while (true) {
int alt30=2;
int LA30_0 = input.LA(1);
if ( (LA30_0==OR) ) {
alt30=1;
}
switch (alt30) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:511:16: OR labeledAlt
{
OR104=(Token)match(input,OR,FOLLOW_OR_in_ruleAltList2106);
stream_OR.add(OR104);
pushFollow(FOLLOW_labeledAlt_in_ruleAltList2108);
labeledAlt105=labeledAlt();
state._fsp--;
stream_labeledAlt.add(labeledAlt105.getTree());
}
break;
default :
break loop30;
}
}
// 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();
// 511: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:514: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 POUND107=null;
ParserRuleReturnScope alternative106 =null;
ParserRuleReturnScope id108 =null;
GrammarAST POUND107_tree=null;
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:515:2: ( alternative ( POUND ! id !)? )
// org\\antlr\\v4\\parse\\ANTLRParser.g:515:4: alternative ( POUND ! id !)?
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_alternative_in_labeledAlt2126);
alternative106=alternative();
state._fsp--;
adaptor.addChild(root_0, alternative106.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:516:3: ( POUND ! id !)?
int alt31=2;
int LA31_0 = input.LA(1);
if ( (LA31_0==POUND) ) {
alt31=1;
}
switch (alt31) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:516:5: POUND ! id !
{
POUND107=(Token)match(input,POUND,FOLLOW_POUND_in_labeledAlt2132);
pushFollow(FOLLOW_id_in_labeledAlt2135);
id108=id();
state._fsp--;
((AltAST)(alternative106!=null?((GrammarAST)alternative106.getTree()):null)).altLabel=(id108!=null?((GrammarAST)id108.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:520:1: lexerRule : ( DOC_COMMENT )? ( FRAGMENT )? TOKEN_REF COLON lexerRuleBlock SEMI -> ^( RULE TOKEN_REF ( DOC_COMMENT )? ( ^( 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 DOC_COMMENT109=null;
Token FRAGMENT110=null;
Token TOKEN_REF111=null;
Token COLON112=null;
Token SEMI114=null;
ParserRuleReturnScope lexerRuleBlock113 =null;
GrammarAST DOC_COMMENT109_tree=null;
GrammarAST FRAGMENT110_tree=null;
GrammarAST TOKEN_REF111_tree=null;
GrammarAST COLON112_tree=null;
GrammarAST SEMI114_tree=null;
RewriteRuleTokenStream stream_DOC_COMMENT=new RewriteRuleTokenStream(adaptor,"token DOC_COMMENT");
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:525:5: ( ( DOC_COMMENT )? ( FRAGMENT )? TOKEN_REF COLON lexerRuleBlock SEMI -> ^( RULE TOKEN_REF ( DOC_COMMENT )? ( ^( RULEMODIFIERS FRAGMENT ) )? lexerRuleBlock ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:525:7: ( DOC_COMMENT )? ( FRAGMENT )? TOKEN_REF COLON lexerRuleBlock SEMI
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:525:7: ( DOC_COMMENT )?
int alt32=2;
int LA32_0 = input.LA(1);
if ( (LA32_0==DOC_COMMENT) ) {
alt32=1;
}
switch (alt32) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:525:7: DOC_COMMENT
{
DOC_COMMENT109=(Token)match(input,DOC_COMMENT,FOLLOW_DOC_COMMENT_in_lexerRule2167);
stream_DOC_COMMENT.add(DOC_COMMENT109);
}
break;
}
// org\\antlr\\v4\\parse\\ANTLRParser.g:525:20: ( 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:525:20: FRAGMENT
{
FRAGMENT110=(Token)match(input,FRAGMENT,FOLLOW_FRAGMENT_in_lexerRule2170);
stream_FRAGMENT.add(FRAGMENT110);
}
break;
}
TOKEN_REF111=(Token)match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_lexerRule2176);
stream_TOKEN_REF.add(TOKEN_REF111);
COLON112=(Token)match(input,COLON,FOLLOW_COLON_in_lexerRule2178);
stream_COLON.add(COLON112);
pushFollow(FOLLOW_lexerRuleBlock_in_lexerRule2180);
lexerRuleBlock113=lexerRuleBlock();
state._fsp--;
stream_lexerRuleBlock.add(lexerRuleBlock113.getTree());
SEMI114=(Token)match(input,SEMI,FOLLOW_SEMI_in_lexerRule2182);
stream_SEMI.add(SEMI114);
// AST REWRITE
// elements: DOC_COMMENT, TOKEN_REF, FRAGMENT, lexerRuleBlock
// 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();
// 527:7: -> ^( RULE TOKEN_REF ( DOC_COMMENT )? ( ^( RULEMODIFIERS FRAGMENT ) )? lexerRuleBlock )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:527:10: ^( RULE TOKEN_REF ( DOC_COMMENT )? ( ^( 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:527:37: ( DOC_COMMENT )?
if ( stream_DOC_COMMENT.hasNext() ) {
adaptor.addChild(root_1, stream_DOC_COMMENT.nextNode());
}
stream_DOC_COMMENT.reset();
// org\\antlr\\v4\\parse\\ANTLRParser.g:528:9: ( ^( RULEMODIFIERS FRAGMENT ) )?
if ( stream_FRAGMENT.hasNext() ) {
// org\\antlr\\v4\\parse\\ANTLRParser.g:528: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:532: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 lexerAltList115 =null;
RewriteRuleSubtreeStream stream_lexerAltList=new RewriteRuleSubtreeStream(adaptor,"rule lexerAltList");
Token colon = input.LT(-1);
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:534:5: ( lexerAltList -> ^( BLOCK[colon,\"BLOCK\"] lexerAltList ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:534:7: lexerAltList
{
pushFollow(FOLLOW_lexerAltList_in_lexerRuleBlock2249);
lexerAltList115=lexerAltList();
state._fsp--;
stream_lexerAltList.add(lexerAltList115.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();
// 534:20: -> ^( BLOCK[colon,\"BLOCK\"] lexerAltList )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:534: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:541: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 OR117=null;
ParserRuleReturnScope lexerAlt116 =null;
ParserRuleReturnScope lexerAlt118 =null;
GrammarAST OR117_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:542:2: ( lexerAlt ( OR lexerAlt )* -> ( lexerAlt )+ )
// org\\antlr\\v4\\parse\\ANTLRParser.g:542:4: lexerAlt ( OR lexerAlt )*
{
pushFollow(FOLLOW_lexerAlt_in_lexerAltList2285);
lexerAlt116=lexerAlt();
state._fsp--;
stream_lexerAlt.add(lexerAlt116.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:542: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:542:14: OR lexerAlt
{
OR117=(Token)match(input,OR,FOLLOW_OR_in_lexerAltList2288);
stream_OR.add(OR117);
pushFollow(FOLLOW_lexerAlt_in_lexerAltList2290);
lexerAlt118=lexerAlt();
state._fsp--;
stream_lexerAlt.add(lexerAlt118.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();
// 542: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:545:1: lexerAlt : ( lexerElements ( lexerCommands -> ^( LEXER_ALT_ACTION lexerElements lexerCommands ) | -> lexerElements ) | -> ^( ALT EPSILON ) );
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 lexerElements119 =null;
ParserRuleReturnScope lexerCommands120 =null;
RewriteRuleSubtreeStream stream_lexerElements=new RewriteRuleSubtreeStream(adaptor,"rule lexerElements");
RewriteRuleSubtreeStream stream_lexerCommands=new RewriteRuleSubtreeStream(adaptor,"rule lexerCommands");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:546:2: ( lexerElements ( lexerCommands -> ^( LEXER_ALT_ACTION lexerElements lexerCommands ) | -> lexerElements ) | -> ^( ALT EPSILON ) )
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;
}
else if ( (LA36_0==OR||LA36_0==RPAREN||LA36_0==SEMI) ) {
alt36=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 36, 0, input);
throw nvae;
}
switch (alt36) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:546:4: lexerElements ( lexerCommands -> ^( LEXER_ALT_ACTION lexerElements lexerCommands ) | -> lexerElements )
{
pushFollow(FOLLOW_lexerElements_in_lexerAlt2308);
lexerElements119=lexerElements();
state._fsp--;
stream_lexerElements.add(lexerElements119.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:547: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:547:5: lexerCommands
{
pushFollow(FOLLOW_lexerCommands_in_lexerAlt2314);
lexerCommands120=lexerCommands();
state._fsp--;
stream_lexerCommands.add(lexerCommands120.getTree());
// AST REWRITE
// elements: lexerCommands, lexerElements
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 547:19: -> ^( LEXER_ALT_ACTION lexerElements lexerCommands )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:547: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:548: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();
// 548:9: -> lexerElements
{
adaptor.addChild(root_0, stream_lexerElements.nextTree());
}
retval.tree = root_0;
}
break;
}
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:550:9:
{
// 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();
// 550:9: -> ^( ALT EPSILON )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:550:12: ^( 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 "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:553:1: lexerElements : ( lexerElement )+ -> ^( ALT ( lexerElement )+ ) ;
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 lexerElement121 =null;
RewriteRuleSubtreeStream stream_lexerElement=new RewriteRuleSubtreeStream(adaptor,"rule lexerElement");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:554:5: ( ( lexerElement )+ -> ^( ALT ( lexerElement )+ ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:554:7: ( lexerElement )+
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:554:7: ( lexerElement )+
int cnt37=0;
loop37:
while (true) {
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;
}
switch (alt37) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:554:7: lexerElement
{
pushFollow(FOLLOW_lexerElement_in_lexerElements2377);
lexerElement121=lexerElement();
state._fsp--;
stream_lexerElement.add(lexerElement121.getTree());
}
break;
default :
if ( cnt37 >= 1 ) break loop37;
EarlyExitException eee = new EarlyExitException(37, input);
throw eee;
}
cnt37++;
}
// 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();
// 554:21: -> ^( ALT ( lexerElement )+ )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:554: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;
}
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:557: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 labeledLexerElement122 =null;
ParserRuleReturnScope ebnfSuffix123 =null;
ParserRuleReturnScope lexerAtom124 =null;
ParserRuleReturnScope ebnfSuffix125 =null;
ParserRuleReturnScope lexerBlock126 =null;
ParserRuleReturnScope ebnfSuffix127 =null;
ParserRuleReturnScope actionElement128 =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:563: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:563:4: labeledLexerElement ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[$labeledLexerElement.start,\"BLOCK\"] ^( ALT labeledLexerElement ) ) ) | -> labeledLexerElement )
{
pushFollow(FOLLOW_labeledLexerElement_in_lexerElement2414);
labeledLexerElement122=labeledLexerElement();
state._fsp--;
stream_labeledLexerElement.add(labeledLexerElement122.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:564: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:564:5: ebnfSuffix
{
pushFollow(FOLLOW_ebnfSuffix_in_lexerElement2420);
ebnfSuffix123=ebnfSuffix();
state._fsp--;
stream_ebnfSuffix.add(ebnfSuffix123.getTree());
// AST REWRITE
// elements: ebnfSuffix, labeledLexerElement
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 564:16: -> ^( ebnfSuffix ^( BLOCK[$labeledLexerElement.start,\"BLOCK\"] ^( ALT labeledLexerElement ) ) )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:564: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:564:33: ^( BLOCK[$labeledLexerElement.start,\"BLOCK\"] ^( ALT labeledLexerElement ) )
{
GrammarAST root_2 = (GrammarAST)adaptor.nil();
root_2 = (GrammarAST)adaptor.becomeRoot(new BlockAST(BLOCK, (labeledLexerElement122!=null?(labeledLexerElement122.start):null), "BLOCK"), root_2);
// org\\antlr\\v4\\parse\\ANTLRParser.g:564: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:565: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();
// 565:8: -> labeledLexerElement
{
adaptor.addChild(root_0, stream_labeledLexerElement.nextTree());
}
retval.tree = root_0;
}
break;
}
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:567:4: lexerAtom ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[$lexerAtom.start,\"BLOCK\"] ^( ALT lexerAtom ) ) ) | -> lexerAtom )
{
pushFollow(FOLLOW_lexerAtom_in_lexerElement2466);
lexerAtom124=lexerAtom();
state._fsp--;
stream_lexerAtom.add(lexerAtom124.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:568: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:568:5: ebnfSuffix
{
pushFollow(FOLLOW_ebnfSuffix_in_lexerElement2472);
ebnfSuffix125=ebnfSuffix();
state._fsp--;
stream_ebnfSuffix.add(ebnfSuffix125.getTree());
// AST REWRITE
// elements: lexerAtom, ebnfSuffix
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 568:16: -> ^( ebnfSuffix ^( BLOCK[$lexerAtom.start,\"BLOCK\"] ^( ALT lexerAtom ) ) )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:568: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:568:33: ^( BLOCK[$lexerAtom.start,\"BLOCK\"] ^( ALT lexerAtom ) )
{
GrammarAST root_2 = (GrammarAST)adaptor.nil();
root_2 = (GrammarAST)adaptor.becomeRoot(new BlockAST(BLOCK, (lexerAtom124!=null?(lexerAtom124.start):null), "BLOCK"), root_2);
// org\\antlr\\v4\\parse\\ANTLRParser.g:568: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:569: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();
// 569:8: -> lexerAtom
{
adaptor.addChild(root_0, stream_lexerAtom.nextTree());
}
retval.tree = root_0;
}
break;
}
}
break;
case 3 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:571:4: lexerBlock ( ebnfSuffix -> ^( ebnfSuffix lexerBlock ) | -> lexerBlock )
{
pushFollow(FOLLOW_lexerBlock_in_lexerElement2518);
lexerBlock126=lexerBlock();
state._fsp--;
stream_lexerBlock.add(lexerBlock126.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:572: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:572:5: ebnfSuffix
{
pushFollow(FOLLOW_ebnfSuffix_in_lexerElement2524);
ebnfSuffix127=ebnfSuffix();
state._fsp--;
stream_ebnfSuffix.add(ebnfSuffix127.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();
// 572:16: -> ^( ebnfSuffix lexerBlock )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:572: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:573: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();
// 573:8: -> lexerBlock
{
adaptor.addChild(root_0, stream_lexerBlock.nextTree());
}
retval.tree = root_0;
}
break;
}
}
break;
case 4 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:575:4: actionElement
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_actionElement_in_lexerElement2552);
actionElement128=actionElement();
state._fsp--;
adaptor.addChild(root_0, actionElement128.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:608: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 id129 =null;
ParserRuleReturnScope lexerAtom130 =null;
ParserRuleReturnScope lexerBlock131 =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:609:2: ( id (ass= ASSIGN |ass= PLUS_ASSIGN ) ( lexerAtom -> ^( $ass id lexerAtom ) | lexerBlock -> ^( $ass id lexerBlock ) ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:609:4: id (ass= ASSIGN |ass= PLUS_ASSIGN ) ( lexerAtom -> ^( $ass id lexerAtom ) | lexerBlock -> ^( $ass id lexerBlock ) )
{
pushFollow(FOLLOW_id_in_labeledLexerElement2582);
id129=id();
state._fsp--;
stream_id.add(id129.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:609: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:609:8: ass= ASSIGN
{
ass=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_labeledLexerElement2587);
stream_ASSIGN.add(ass);
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:609:19: ass= PLUS_ASSIGN
{
ass=(Token)match(input,PLUS_ASSIGN,FOLLOW_PLUS_ASSIGN_in_labeledLexerElement2591);
stream_PLUS_ASSIGN.add(ass);
}
break;
}
// org\\antlr\\v4\\parse\\ANTLRParser.g:610: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:610:5: lexerAtom
{
pushFollow(FOLLOW_lexerAtom_in_labeledLexerElement2598);
lexerAtom130=lexerAtom();
state._fsp--;
stream_lexerAtom.add(lexerAtom130.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();
// 610:15: -> ^( $ass id lexerAtom )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:610: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:611:5: lexerBlock
{
pushFollow(FOLLOW_lexerBlock_in_labeledLexerElement2615);
lexerBlock131=lexerBlock();
state._fsp--;
stream_lexerBlock.add(lexerBlock131.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();
// 611:16: -> ^( $ass id lexerBlock )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:611: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:616: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 LPAREN132=null;
Token COLON134=null;
Token RPAREN136=null;
ParserRuleReturnScope optionsSpec133 =null;
ParserRuleReturnScope lexerAltList135 =null;
GrammarAST LPAREN132_tree=null;
GrammarAST COLON134_tree=null;
GrammarAST RPAREN136_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:623:3: ( LPAREN ( optionsSpec COLON )? lexerAltList RPAREN -> ^( BLOCK[$LPAREN,\"BLOCK\"] ( optionsSpec )? lexerAltList ) )
// org\\antlr\\v4\\parse\\ANTLRParser.g:623:5: LPAREN ( optionsSpec COLON )? lexerAltList RPAREN
{
LPAREN132=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_lexerBlock2648);
stream_LPAREN.add(LPAREN132);
// org\\antlr\\v4\\parse\\ANTLRParser.g:624: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:624:11: optionsSpec COLON
{
pushFollow(FOLLOW_optionsSpec_in_lexerBlock2660);
optionsSpec133=optionsSpec();
state._fsp--;
stream_optionsSpec.add(optionsSpec133.getTree());
COLON134=(Token)match(input,COLON,FOLLOW_COLON_in_lexerBlock2662);
stream_COLON.add(COLON134);
}
break;
}
pushFollow(FOLLOW_lexerAltList_in_lexerBlock2675);
lexerAltList135=lexerAltList();
state._fsp--;
stream_lexerAltList.add(lexerAltList135.getTree());
RPAREN136=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_lexerBlock2685);
stream_RPAREN.add(RPAREN136);
// 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();
// 627:7: -> ^( BLOCK[$LPAREN,\"BLOCK\"] ( optionsSpec )? lexerAltList )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:627:10: ^( BLOCK[$LPAREN,\"BLOCK\"] ( optionsSpec )? lexerAltList )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot(new BlockAST(BLOCK, LPAREN132, "BLOCK"), root_1);
// org\\antlr\\v4\\parse\\ANTLRParser.g:627: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:631: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 RARROW137=null;
Token COMMA139=null;
ParserRuleReturnScope lexerCommand138 =null;
ParserRuleReturnScope lexerCommand140 =null;
GrammarAST RARROW137_tree=null;
GrammarAST COMMA139_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:632:2: ( RARROW lexerCommand ( COMMA lexerCommand )* -> ( lexerCommand )+ )
// org\\antlr\\v4\\parse\\ANTLRParser.g:632:4: RARROW lexerCommand ( COMMA lexerCommand )*
{
RARROW137=(Token)match(input,RARROW,FOLLOW_RARROW_in_lexerCommands2722);
stream_RARROW.add(RARROW137);
pushFollow(FOLLOW_lexerCommand_in_lexerCommands2724);
lexerCommand138=lexerCommand();
state._fsp--;
stream_lexerCommand.add(lexerCommand138.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:632: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:632:25: COMMA lexerCommand
{
COMMA139=(Token)match(input,COMMA,FOLLOW_COMMA_in_lexerCommands2727);
stream_COMMA.add(COMMA139);
pushFollow(FOLLOW_lexerCommand_in_lexerCommands2729);
lexerCommand140=lexerCommand();
state._fsp--;
stream_lexerCommand.add(lexerCommand140.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();
// 632: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:635: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 LPAREN142=null;
Token RPAREN144=null;
ParserRuleReturnScope lexerCommandName141 =null;
ParserRuleReturnScope lexerCommandExpr143 =null;
ParserRuleReturnScope lexerCommandName145 =null;
GrammarAST LPAREN142_tree=null;
GrammarAST RPAREN144_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:636: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:636:4: lexerCommandName LPAREN lexerCommandExpr RPAREN
{
pushFollow(FOLLOW_lexerCommandName_in_lexerCommand2747);
lexerCommandName141=lexerCommandName();
state._fsp--;
stream_lexerCommandName.add(lexerCommandName141.getTree());
LPAREN142=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_lexerCommand2749);
stream_LPAREN.add(LPAREN142);
pushFollow(FOLLOW_lexerCommandExpr_in_lexerCommand2751);
lexerCommandExpr143=lexerCommandExpr();
state._fsp--;
stream_lexerCommandExpr.add(lexerCommandExpr143.getTree());
RPAREN144=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_lexerCommand2753);
stream_RPAREN.add(RPAREN144);
// AST REWRITE
// elements: lexerCommandName, lexerCommandExpr
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 636:52: -> ^( LEXER_ACTION_CALL lexerCommandName lexerCommandExpr )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:636: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:637:4: lexerCommandName
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_lexerCommandName_in_lexerCommand2768);
lexerCommandName145=lexerCommandName();
state._fsp--;
adaptor.addChild(root_0, lexerCommandName145.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:640: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 INT147=null;
ParserRuleReturnScope id146 =null;
GrammarAST INT147_tree=null;
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:641: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:641:4: id
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_id_in_lexerCommandExpr2779);
id146=id();
state._fsp--;
adaptor.addChild(root_0, id146.getTree());
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:642:4: INT
{
root_0 = (GrammarAST)adaptor.nil();
INT147=(Token)match(input,INT,FOLLOW_INT_in_lexerCommandExpr2784);
INT147_tree = (GrammarAST)adaptor.create(INT147);
adaptor.addChild(root_0, INT147_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:645: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 MODE149=null;
ParserRuleReturnScope id148 =null;
GrammarAST MODE149_tree=null;
RewriteRuleTokenStream stream_MODE=new RewriteRuleTokenStream(adaptor,"token MODE");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:646: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:646:17: id
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_id_in_lexerCommandName2808);
id148=id();
state._fsp--;
adaptor.addChild(root_0, id148.getTree());
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:647:17: MODE
{
MODE149=(Token)match(input,MODE,FOLLOW_MODE_in_lexerCommandName2826);
stream_MODE.add(MODE149);
// 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();
// 647:25: -> ID[$MODE]
{
adaptor.addChild(root_0, (GrammarAST)adaptor.create(ID, MODE149));
}
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:650: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 OR151=null;
ParserRuleReturnScope alternative150 =null;
ParserRuleReturnScope alternative152 =null;
GrammarAST OR151_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:651:5: ( alternative ( OR alternative )* -> ( alternative )+ )
// org\\antlr\\v4\\parse\\ANTLRParser.g:651:7: alternative ( OR alternative )*
{
pushFollow(FOLLOW_alternative_in_altList2854);
alternative150=alternative();
state._fsp--;
stream_alternative.add(alternative150.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:651: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:651:20: OR alternative
{
OR151=(Token)match(input,OR,FOLLOW_OR_in_altList2857);
stream_OR.add(OR151);
pushFollow(FOLLOW_alternative_in_altList2859);
alternative152=alternative();
state._fsp--;
stream_alternative.add(alternative152.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();
// 651: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:656:1: alternative : ( elements -> elements | -> ^( ALT 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;
ParserRuleReturnScope elements153 =null;
RewriteRuleSubtreeStream stream_elements=new RewriteRuleSubtreeStream(adaptor,"rule elements");
paraphrases.push("matching alternative");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:659:5: ( elements -> elements | -> ^( ALT EPSILON ) )
int alt50=2;
int LA50_0 = input.LA(1);
if ( (LA50_0==ACTION||LA50_0==DOT||LA50_0==LPAREN||LA50_0==NOT||LA50_0==RULE_REF||LA50_0==SEMPRED||LA50_0==STRING_LITERAL||LA50_0==TOKEN_REF) ) {
alt50=1;
}
else if ( (LA50_0==EOF||LA50_0==OR||LA50_0==POUND||LA50_0==RPAREN||LA50_0==SEMI) ) {
alt50=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 50, 0, input);
throw nvae;
}
switch (alt50) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:659:7: elements
{
pushFollow(FOLLOW_elements_in_alternative2895);
elements153=elements();
state._fsp--;
stream_elements.add(elements153.getTree());
// AST REWRITE
// elements: 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();
// 659:16: -> elements
{
adaptor.addChild(root_0, stream_elements.nextTree());
}
retval.tree = root_0;
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:660:10:
{
// 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();
// 660:10: -> ^( ALT EPSILON )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:660:13: ^( 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);
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 "alternative"
public static class elements_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "elements"
// org\\antlr\\v4\\parse\\ANTLRParser.g:663:1: elements : (e+= element )+ -> ^( ALT ( $e)+ ) ;
public final ANTLRParser.elements_return elements() throws RecognitionException {
ANTLRParser.elements_return retval = new ANTLRParser.elements_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
List