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 13:51:54
/*
[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: rules, id, DOC_COMMENT, modeSpec, grammarType, prequelConstruct
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 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: delegateGrammar, IMPORT
// 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 )* RBRACE -> ^( TOKENS_SPEC ( id )+ ) | TOKENS_SPEC RBRACE ->| TOKENS_SPEC ^ ( v3tokenSpec )+ RBRACE !);
public final ANTLRParser.tokensSpec_return tokensSpec() throws RecognitionException {
ANTLRParser.tokensSpec_return retval = new ANTLRParser.tokensSpec_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
Token TOKENS_SPEC35=null;
Token COMMA37=null;
Token RBRACE39=null;
Token TOKENS_SPEC40=null;
Token RBRACE41=null;
Token TOKENS_SPEC42=null;
Token RBRACE44=null;
ParserRuleReturnScope id36 =null;
ParserRuleReturnScope id38 =null;
ParserRuleReturnScope v3tokenSpec43 =null;
GrammarAST TOKENS_SPEC35_tree=null;
GrammarAST COMMA37_tree=null;
GrammarAST RBRACE39_tree=null;
GrammarAST TOKENS_SPEC40_tree=null;
GrammarAST RBRACE41_tree=null;
GrammarAST TOKENS_SPEC42_tree=null;
GrammarAST RBRACE44_tree=null;
RewriteRuleTokenStream stream_RBRACE=new RewriteRuleTokenStream(adaptor,"token RBRACE");
RewriteRuleTokenStream stream_TOKENS_SPEC=new RewriteRuleTokenStream(adaptor,"token TOKENS_SPEC");
RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
RewriteRuleSubtreeStream stream_id=new RewriteRuleSubtreeStream(adaptor,"rule id");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:285:2: ( TOKENS_SPEC id ( COMMA id )* RBRACE -> ^( TOKENS_SPEC ( id )+ ) | TOKENS_SPEC RBRACE ->| TOKENS_SPEC ^ ( v3tokenSpec )+ RBRACE !)
int alt12=3;
int LA12_0 = input.LA(1);
if ( (LA12_0==TOKENS_SPEC) ) {
switch ( input.LA(2) ) {
case RBRACE:
{
alt12=2;
}
break;
case RULE_REF:
{
int LA12_3 = input.LA(3);
if ( (LA12_3==COMMA||LA12_3==RBRACE) ) {
alt12=1;
}
else if ( (LA12_3==ASSIGN||LA12_3==SEMI) ) {
alt12=3;
}
else {
int nvaeMark = input.mark();
try {
for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) {
input.consume();
}
NoViableAltException nvae =
new NoViableAltException("", 12, 3, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case TOKEN_REF:
{
int LA12_4 = input.LA(3);
if ( (LA12_4==COMMA||LA12_4==RBRACE) ) {
alt12=1;
}
else if ( (LA12_4==ASSIGN||LA12_4==SEMI) ) {
alt12=3;
}
else {
int nvaeMark = input.mark();
try {
for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) {
input.consume();
}
NoViableAltException nvae =
new NoViableAltException("", 12, 4, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
default:
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 12, 1, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
else {
NoViableAltException nvae =
new NoViableAltException("", 12, 0, input);
throw nvae;
}
switch (alt12) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:285:4: TOKENS_SPEC id ( COMMA id )* 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) ) {
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;
}
}
RBRACE39=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_tokensSpec1168);
stream_RBRACE.add(RBRACE39);
// 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:38: -> ^( TOKENS_SPEC ( id )+ )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:285:41: ^( TOKENS_SPEC ( id )+ )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot(stream_TOKENS_SPEC.nextNode(), root_1);
if ( !(stream_id.hasNext()) ) {
throw new RewriteEarlyExitException();
}
while ( stream_id.hasNext() ) {
adaptor.addChild(root_1, stream_id.nextTree());
}
stream_id.reset();
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:286:7: TOKENS_SPEC RBRACE
{
TOKENS_SPEC40=(Token)match(input,TOKENS_SPEC,FOLLOW_TOKENS_SPEC_in_tokensSpec1185);
stream_TOKENS_SPEC.add(TOKENS_SPEC40);
RBRACE41=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_tokensSpec1187);
stream_RBRACE.add(RBRACE41);
// AST REWRITE
// elements:
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 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_SPEC42=(Token)match(input,TOKENS_SPEC,FOLLOW_TOKENS_SPEC_in_tokensSpec1197);
TOKENS_SPEC42_tree = (GrammarAST)adaptor.create(TOKENS_SPEC42);
root_0 = (GrammarAST)adaptor.becomeRoot(TOKENS_SPEC42_tree, root_0);
// org\\antlr\\v4\\parse\\ANTLRParser.g:287:20: ( v3tokenSpec )+
int cnt11=0;
loop11:
while (true) {
int alt11=2;
int LA11_0 = input.LA(1);
if ( (LA11_0==RULE_REF||LA11_0==TOKEN_REF) ) {
alt11=1;
}
switch (alt11) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:287:20: v3tokenSpec
{
pushFollow(FOLLOW_v3tokenSpec_in_tokensSpec1200);
v3tokenSpec43=v3tokenSpec();
state._fsp--;
adaptor.addChild(root_0, v3tokenSpec43.getTree());
}
break;
default :
if ( cnt11 >= 1 ) break loop11;
EarlyExitException eee = new EarlyExitException(11, input);
throw eee;
}
cnt11++;
}
RBRACE44=(Token)match(input,RBRACE,FOLLOW_RBRACE_in_tokensSpec1203);
grammarError(ErrorType.V3_TOKENS_SYNTAX, TOKENS_SPEC42);
}
break;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "tokensSpec"
public static class v3tokenSpec_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "v3tokenSpec"
// org\\antlr\\v4\\parse\\ANTLRParser.g: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 ASSIGN46=null;
Token SEMI47=null;
ParserRuleReturnScope id45 =null;
GrammarAST lit_tree=null;
GrammarAST ASSIGN46_tree=null;
GrammarAST SEMI47_tree=null;
RewriteRuleTokenStream stream_STRING_LITERAL=new RewriteRuleTokenStream(adaptor,"token STRING_LITERAL");
RewriteRuleTokenStream stream_SEMI=new RewriteRuleTokenStream(adaptor,"token SEMI");
RewriteRuleTokenStream stream_ASSIGN=new RewriteRuleTokenStream(adaptor,"token ASSIGN");
RewriteRuleSubtreeStream stream_id=new RewriteRuleSubtreeStream(adaptor,"rule id");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g: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_v3tokenSpec1223);
id45=id();
state._fsp--;
stream_id.add(id45.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:293:3: ( ASSIGN lit= STRING_LITERAL -> id | -> id )
int alt13=2;
int LA13_0 = input.LA(1);
if ( (LA13_0==ASSIGN) ) {
alt13=1;
}
else if ( (LA13_0==SEMI) ) {
alt13=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 13, 0, input);
throw nvae;
}
switch (alt13) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:293:5: ASSIGN lit= STRING_LITERAL
{
ASSIGN46=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_v3tokenSpec1229);
stream_ASSIGN.add(ASSIGN46);
lit=(Token)match(input,STRING_LITERAL,FOLLOW_STRING_LITERAL_in_v3tokenSpec1233);
stream_STRING_LITERAL.add(lit);
grammarError(ErrorType.V3_ASSIGN_IN_TOKENS, (id45!=null?(id45.start):null),
(id45!=null?input.toString(id45.start,id45.stop):null), lit.getText());
// AST REWRITE
// elements: id
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 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;
}
SEMI47=(Token)match(input,SEMI,FOLLOW_SEMI_in_v3tokenSpec1294);
stream_SEMI.add(SEMI47);
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "v3tokenSpec"
public static class 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 AT48=null;
Token COLONCOLON50=null;
Token ACTION52=null;
ParserRuleReturnScope actionScopeName49 =null;
ParserRuleReturnScope id51 =null;
GrammarAST AT48_tree=null;
GrammarAST COLONCOLON50_tree=null;
GrammarAST ACTION52_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
{
AT48=(Token)match(input,AT,FOLLOW_AT_in_action1310);
stream_AT.add(AT48);
// org\\antlr\\v4\\parse\\ANTLRParser.g:309:7: ( actionScopeName COLONCOLON )?
int alt14=2;
switch ( input.LA(1) ) {
case RULE_REF:
{
int LA14_1 = input.LA(2);
if ( (LA14_1==COLONCOLON) ) {
alt14=1;
}
}
break;
case TOKEN_REF:
{
int LA14_2 = input.LA(2);
if ( (LA14_2==COLONCOLON) ) {
alt14=1;
}
}
break;
case LEXER:
case PARSER:
{
alt14=1;
}
break;
}
switch (alt14) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:309:8: actionScopeName COLONCOLON
{
pushFollow(FOLLOW_actionScopeName_in_action1313);
actionScopeName49=actionScopeName();
state._fsp--;
stream_actionScopeName.add(actionScopeName49.getTree());
COLONCOLON50=(Token)match(input,COLONCOLON,FOLLOW_COLONCOLON_in_action1315);
stream_COLONCOLON.add(COLONCOLON50);
}
break;
}
pushFollow(FOLLOW_id_in_action1319);
id51=id();
state._fsp--;
stream_id.add(id51.getTree());
ACTION52=(Token)match(input,ACTION,FOLLOW_ACTION_in_action1321);
stream_ACTION.add(ACTION52);
// AST REWRITE
// elements: actionScopeName, ACTION, AT, 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();
// 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 LEXER54=null;
Token PARSER55=null;
ParserRuleReturnScope id53 =null;
GrammarAST LEXER54_tree=null;
GrammarAST PARSER55_tree=null;
RewriteRuleTokenStream stream_PARSER=new RewriteRuleTokenStream(adaptor,"token PARSER");
RewriteRuleTokenStream stream_LEXER=new RewriteRuleTokenStream(adaptor,"token LEXER");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:316:2: ( id | LEXER -> ID[$LEXER] | PARSER -> ID[$PARSER] )
int alt15=3;
switch ( input.LA(1) ) {
case RULE_REF:
case TOKEN_REF:
{
alt15=1;
}
break;
case LEXER:
{
alt15=2;
}
break;
case PARSER:
{
alt15=3;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 15, 0, input);
throw nvae;
}
switch (alt15) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:316:4: id
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_id_in_actionScopeName1350);
id53=id();
state._fsp--;
adaptor.addChild(root_0, id53.getTree());
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:317:4: LEXER
{
LEXER54=(Token)match(input,LEXER,FOLLOW_LEXER_in_actionScopeName1355);
stream_LEXER.add(LEXER54);
// 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, LEXER54));
}
retval.tree = root_0;
}
break;
case 3 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:318:9: PARSER
{
PARSER55=(Token)match(input,PARSER,FOLLOW_PARSER_in_actionScopeName1370);
stream_PARSER.add(PARSER55);
// 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, PARSER55));
}
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 MODE56=null;
Token SEMI58=null;
ParserRuleReturnScope id57 =null;
ParserRuleReturnScope sync59 =null;
ParserRuleReturnScope lexerRule60 =null;
ParserRuleReturnScope sync61 =null;
GrammarAST MODE56_tree=null;
GrammarAST SEMI58_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 )*
{
MODE56=(Token)match(input,MODE,FOLLOW_MODE_in_modeSpec1389);
stream_MODE.add(MODE56);
pushFollow(FOLLOW_id_in_modeSpec1391);
id57=id();
state._fsp--;
stream_id.add(id57.getTree());
SEMI58=(Token)match(input,SEMI,FOLLOW_SEMI_in_modeSpec1393);
stream_SEMI.add(SEMI58);
pushFollow(FOLLOW_sync_in_modeSpec1395);
sync59=sync();
state._fsp--;
stream_sync.add(sync59.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:322:25: ( lexerRule sync )*
loop16:
while (true) {
int alt16=2;
int LA16_0 = input.LA(1);
if ( (LA16_0==DOC_COMMENT||LA16_0==FRAGMENT||LA16_0==TOKEN_REF) ) {
alt16=1;
}
switch (alt16) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:322:26: lexerRule sync
{
pushFollow(FOLLOW_lexerRule_in_modeSpec1398);
lexerRule60=lexerRule();
state._fsp--;
stream_lexerRule.add(lexerRule60.getTree());
pushFollow(FOLLOW_sync_in_modeSpec1400);
sync61=sync();
state._fsp--;
stream_sync.add(sync61.getTree());
}
break;
default :
break loop16;
}
}
// AST REWRITE
// elements: MODE, id, lexerRule
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 322:44: -> ^( MODE id ( lexerRule )* )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:322:47: ^( MODE id ( lexerRule )* )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot(stream_MODE.nextNode(), root_1);
adaptor.addChild(root_1, stream_id.nextTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:322:57: ( lexerRule )*
while ( stream_lexerRule.hasNext() ) {
adaptor.addChild(root_1, stream_lexerRule.nextTree());
}
stream_lexerRule.reset();
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "modeSpec"
public static class rules_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "rules"
// org\\antlr\\v4\\parse\\ANTLRParser.g:325:1: rules : sync ( rule sync )* -> ^( RULES ( rule )* ) ;
public final ANTLRParser.rules_return rules() throws RecognitionException {
ANTLRParser.rules_return retval = new ANTLRParser.rules_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
ParserRuleReturnScope sync62 =null;
ParserRuleReturnScope rule63 =null;
ParserRuleReturnScope sync64 =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_rules1431);
sync62=sync();
state._fsp--;
stream_sync.add(sync62.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:326:12: ( rule sync )*
loop17:
while (true) {
int alt17=2;
int LA17_0 = input.LA(1);
if ( (LA17_0==DOC_COMMENT||LA17_0==FRAGMENT||LA17_0==RULE_REF||LA17_0==TOKEN_REF) ) {
alt17=1;
}
switch (alt17) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:326:13: rule sync
{
pushFollow(FOLLOW_rule_in_rules1434);
rule63=rule();
state._fsp--;
stream_rule.add(rule63.getTree());
pushFollow(FOLLOW_sync_in_rules1436);
sync64=sync();
state._fsp--;
stream_sync.add(sync64.getTree());
}
break;
default :
break loop17;
}
}
// AST REWRITE
// elements: rule
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 330:7: -> ^( RULES ( rule )* )
{
// org\\antlr\\v4\\parse\\ANTLRParser.g:330:9: ^( RULES ( rule )* )
{
GrammarAST root_1 = (GrammarAST)adaptor.nil();
root_1 = (GrammarAST)adaptor.becomeRoot((GrammarAST)adaptor.create(RULES, "RULES"), root_1);
// org\\antlr\\v4\\parse\\ANTLRParser.g:330:17: ( rule )*
while ( stream_rule.hasNext() ) {
adaptor.addChild(root_1, stream_rule.nextTree());
}
stream_rule.reset();
adaptor.addChild(root_0, root_1);
}
}
retval.tree = root_0;
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "rules"
public static class sync_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "sync"
// org\\antlr\\v4\\parse\\ANTLRParser.g:333:1: sync :;
public final ANTLRParser.sync_return sync() throws RecognitionException {
ANTLRParser.sync_return retval = new ANTLRParser.sync_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
BitSet followSet = computeErrorRecoverySet();
if ( input.LA(1)!=Token.EOF && !followSet.member(input.LA(1)) ) {
reportError(new NoViableAltException("",0,0,input));
beginResync();
consumeUntil(input, followSet);
endResync();
}
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:342:3: ()
// org\\antlr\\v4\\parse\\ANTLRParser.g:343:2:
{
root_0 = (GrammarAST)adaptor.nil();
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "sync"
public static class rule_return extends ParserRuleReturnScope {
GrammarAST tree;
@Override
public GrammarAST getTree() { return tree; }
};
// $ANTLR start "rule"
// org\\antlr\\v4\\parse\\ANTLRParser.g:345:1: rule : ( parserRule | lexerRule );
public final ANTLRParser.rule_return rule() throws RecognitionException {
ANTLRParser.rule_return retval = new ANTLRParser.rule_return();
retval.start = input.LT(1);
GrammarAST root_0 = null;
ParserRuleReturnScope parserRule65 =null;
ParserRuleReturnScope lexerRule66 =null;
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:345:5: ( parserRule | lexerRule )
int alt18=2;
switch ( input.LA(1) ) {
case DOC_COMMENT:
{
int LA18_1 = input.LA(2);
if ( (LA18_1==RULE_REF) ) {
alt18=1;
}
else if ( (LA18_1==FRAGMENT||LA18_1==TOKEN_REF) ) {
alt18=2;
}
else {
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 18, 1, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case RULE_REF:
{
alt18=1;
}
break;
case FRAGMENT:
case TOKEN_REF:
{
alt18=2;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 18, 0, input);
throw nvae;
}
switch (alt18) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:345:7: parserRule
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_parserRule_in_rule1498);
parserRule65=parserRule();
state._fsp--;
adaptor.addChild(root_0, parserRule65.getTree());
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:346:4: lexerRule
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_lexerRule_in_rule1503);
lexerRule66=lexerRule();
state._fsp--;
adaptor.addChild(root_0, lexerRule66.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_COMMENT67=null;
Token RULE_REF68=null;
Token ARG_ACTION69=null;
Token COLON74=null;
Token SEMI76=null;
ParserRuleReturnScope ruleReturns70 =null;
ParserRuleReturnScope throwsSpec71 =null;
ParserRuleReturnScope localsSpec72 =null;
ParserRuleReturnScope rulePrequels73 =null;
ParserRuleReturnScope ruleBlock75 =null;
ParserRuleReturnScope exceptionGroup77 =null;
GrammarAST DOC_COMMENT67_tree=null;
GrammarAST RULE_REF68_tree=null;
GrammarAST ARG_ACTION69_tree=null;
GrammarAST COLON74_tree=null;
GrammarAST SEMI76_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 alt19=2;
int LA19_0 = input.LA(1);
if ( (LA19_0==DOC_COMMENT) ) {
alt19=1;
}
switch (alt19) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:368:7: DOC_COMMENT
{
DOC_COMMENT67=(Token)match(input,DOC_COMMENT,FOLLOW_DOC_COMMENT_in_parserRule1543);
stream_DOC_COMMENT.add(DOC_COMMENT67);
}
break;
}
RULE_REF68=(Token)match(input,RULE_REF,FOLLOW_RULE_REF_in_parserRule1566);
stream_RULE_REF.add(RULE_REF68);
// org\\antlr\\v4\\parse\\ANTLRParser.g:382:4: ( ARG_ACTION )?
int alt20=2;
int LA20_0 = input.LA(1);
if ( (LA20_0==ARG_ACTION) ) {
alt20=1;
}
switch (alt20) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:382:4: ARG_ACTION
{
ARG_ACTION69=(Token)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_parserRule1596);
stream_ARG_ACTION.add(ARG_ACTION69);
}
break;
}
// org\\antlr\\v4\\parse\\ANTLRParser.g:384:4: ( ruleReturns )?
int alt21=2;
int LA21_0 = input.LA(1);
if ( (LA21_0==RETURNS) ) {
alt21=1;
}
switch (alt21) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:384:4: ruleReturns
{
pushFollow(FOLLOW_ruleReturns_in_parserRule1603);
ruleReturns70=ruleReturns();
state._fsp--;
stream_ruleReturns.add(ruleReturns70.getTree());
}
break;
}
// org\\antlr\\v4\\parse\\ANTLRParser.g:386:4: ( throwsSpec )?
int alt22=2;
int LA22_0 = input.LA(1);
if ( (LA22_0==THROWS) ) {
alt22=1;
}
switch (alt22) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:386:4: throwsSpec
{
pushFollow(FOLLOW_throwsSpec_in_parserRule1610);
throwsSpec71=throwsSpec();
state._fsp--;
stream_throwsSpec.add(throwsSpec71.getTree());
}
break;
}
// org\\antlr\\v4\\parse\\ANTLRParser.g:388:4: ( localsSpec )?
int alt23=2;
int LA23_0 = input.LA(1);
if ( (LA23_0==LOCALS) ) {
alt23=1;
}
switch (alt23) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:388:4: localsSpec
{
pushFollow(FOLLOW_localsSpec_in_parserRule1617);
localsSpec72=localsSpec();
state._fsp--;
stream_localsSpec.add(localsSpec72.getTree());
}
break;
}
pushFollow(FOLLOW_rulePrequels_in_parserRule1655);
rulePrequels73=rulePrequels();
state._fsp--;
stream_rulePrequels.add(rulePrequels73.getTree());
COLON74=(Token)match(input,COLON,FOLLOW_COLON_in_parserRule1664);
stream_COLON.add(COLON74);
pushFollow(FOLLOW_ruleBlock_in_parserRule1687);
ruleBlock75=ruleBlock();
state._fsp--;
stream_ruleBlock.add(ruleBlock75.getTree());
SEMI76=(Token)match(input,SEMI,FOLLOW_SEMI_in_parserRule1696);
stream_SEMI.add(SEMI76);
pushFollow(FOLLOW_exceptionGroup_in_parserRule1705);
exceptionGroup77=exceptionGroup();
state._fsp--;
stream_exceptionGroup.add(exceptionGroup77.getTree());
// AST REWRITE
// elements: DOC_COMMENT, rulePrequels, ruleBlock, throwsSpec, ruleReturns, RULE_REF, exceptionGroup, ARG_ACTION, localsSpec
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 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 exceptionHandler78 =null;
ParserRuleReturnScope finallyClause79 =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 )*
loop24:
while (true) {
int alt24=2;
int LA24_0 = input.LA(1);
if ( (LA24_0==CATCH) ) {
alt24=1;
}
switch (alt24) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:427:7: exceptionHandler
{
pushFollow(FOLLOW_exceptionHandler_in_exceptionGroup1791);
exceptionHandler78=exceptionHandler();
state._fsp--;
adaptor.addChild(root_0, exceptionHandler78.getTree());
}
break;
default :
break loop24;
}
}
// org\\antlr\\v4\\parse\\ANTLRParser.g:427:25: ( finallyClause )?
int alt25=2;
int LA25_0 = input.LA(1);
if ( (LA25_0==FINALLY) ) {
alt25=1;
}
switch (alt25) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:427:25: finallyClause
{
pushFollow(FOLLOW_finallyClause_in_exceptionGroup1794);
finallyClause79=finallyClause();
state._fsp--;
adaptor.addChild(root_0, finallyClause79.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 CATCH80=null;
Token ARG_ACTION81=null;
Token ACTION82=null;
GrammarAST CATCH80_tree=null;
GrammarAST ARG_ACTION81_tree=null;
GrammarAST ACTION82_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
{
CATCH80=(Token)match(input,CATCH,FOLLOW_CATCH_in_exceptionHandler1811);
stream_CATCH.add(CATCH80);
ARG_ACTION81=(Token)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_exceptionHandler1813);
stream_ARG_ACTION.add(ARG_ACTION81);
ACTION82=(Token)match(input,ACTION,FOLLOW_ACTION_in_exceptionHandler1815);
stream_ACTION.add(ACTION82);
// AST REWRITE
// elements: ARG_ACTION, CATCH, 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();
// 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 FINALLY83=null;
Token ACTION84=null;
GrammarAST FINALLY83_tree=null;
GrammarAST ACTION84_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
{
FINALLY83=(Token)match(input,FINALLY,FOLLOW_FINALLY_in_finallyClause1842);
stream_FINALLY.add(FINALLY83);
ACTION84=(Token)match(input,ACTION,FOLLOW_ACTION_in_finallyClause1844);
stream_ACTION.add(ACTION84);
// 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 sync85 =null;
ParserRuleReturnScope rulePrequel86 =null;
ParserRuleReturnScope sync87 =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_rulePrequels1876);
sync85=sync();
state._fsp--;
stream_sync.add(sync85.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:443:9: ( rulePrequel sync )*
loop26:
while (true) {
int alt26=2;
int LA26_0 = input.LA(1);
if ( (LA26_0==AT||LA26_0==OPTIONS) ) {
alt26=1;
}
switch (alt26) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:443:10: rulePrequel sync
{
pushFollow(FOLLOW_rulePrequel_in_rulePrequels1879);
rulePrequel86=rulePrequel();
state._fsp--;
stream_rulePrequel.add(rulePrequel86.getTree());
pushFollow(FOLLOW_sync_in_rulePrequels1881);
sync87=sync();
state._fsp--;
stream_sync.add(sync87.getTree());
}
break;
default :
break loop26;
}
}
// 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 optionsSpec88 =null;
ParserRuleReturnScope ruleAction89 =null;
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:450:5: ( optionsSpec | ruleAction )
int alt27=2;
int LA27_0 = input.LA(1);
if ( (LA27_0==OPTIONS) ) {
alt27=1;
}
else if ( (LA27_0==AT) ) {
alt27=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 27, 0, input);
throw nvae;
}
switch (alt27) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:450:7: optionsSpec
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_optionsSpec_in_rulePrequel1905);
optionsSpec88=optionsSpec();
state._fsp--;
adaptor.addChild(root_0, optionsSpec88.getTree());
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:451:7: ruleAction
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_ruleAction_in_rulePrequel1913);
ruleAction89=ruleAction();
state._fsp--;
adaptor.addChild(root_0, ruleAction89.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 RETURNS90=null;
Token ARG_ACTION91=null;
GrammarAST RETURNS90_tree=null;
GrammarAST ARG_ACTION91_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();
RETURNS90=(Token)match(input,RETURNS,FOLLOW_RETURNS_in_ruleReturns1933);
RETURNS90_tree = (GrammarAST)adaptor.create(RETURNS90);
root_0 = (GrammarAST)adaptor.becomeRoot(RETURNS90_tree, root_0);
ARG_ACTION91=(Token)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_ruleReturns1936);
ARG_ACTION91_tree = new ActionAST(ARG_ACTION91) ;
adaptor.addChild(root_0, ARG_ACTION91_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 THROWS92=null;
Token COMMA94=null;
ParserRuleReturnScope qid93 =null;
ParserRuleReturnScope qid95 =null;
GrammarAST THROWS92_tree=null;
GrammarAST COMMA94_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 )*
{
THROWS92=(Token)match(input,THROWS,FOLLOW_THROWS_in_throwsSpec1964);
stream_THROWS.add(THROWS92);
pushFollow(FOLLOW_qid_in_throwsSpec1966);
qid93=qid();
state._fsp--;
stream_qid.add(qid93.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:476:18: ( COMMA qid )*
loop28:
while (true) {
int alt28=2;
int LA28_0 = input.LA(1);
if ( (LA28_0==COMMA) ) {
alt28=1;
}
switch (alt28) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:476:19: COMMA qid
{
COMMA94=(Token)match(input,COMMA,FOLLOW_COMMA_in_throwsSpec1969);
stream_COMMA.add(COMMA94);
pushFollow(FOLLOW_qid_in_throwsSpec1971);
qid95=qid();
state._fsp--;
stream_qid.add(qid95.getTree());
}
break;
default :
break loop28;
}
}
// 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 LOCALS96=null;
Token ARG_ACTION97=null;
GrammarAST LOCALS96_tree=null;
GrammarAST ARG_ACTION97_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();
LOCALS96=(Token)match(input,LOCALS,FOLLOW_LOCALS_in_localsSpec1996);
LOCALS96_tree = (GrammarAST)adaptor.create(LOCALS96);
root_0 = (GrammarAST)adaptor.becomeRoot(LOCALS96_tree, root_0);
ARG_ACTION97=(Token)match(input,ARG_ACTION,FOLLOW_ARG_ACTION_in_localsSpec1999);
ARG_ACTION97_tree = new ActionAST(ARG_ACTION97) ;
adaptor.addChild(root_0, ARG_ACTION97_tree);
}
retval.stop = input.LT(-1);
retval.tree = (GrammarAST)adaptor.rulePostProcessing(root_0);
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
}
catch (RecognitionException re) {
reportError(re);
recover(input,re);
retval.tree = (GrammarAST)adaptor.errorNode(input, retval.start, input.LT(-1), re);
}
finally {
// do for sure before leaving
}
return retval;
}
// $ANTLR end "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 AT98=null;
Token ACTION100=null;
ParserRuleReturnScope id99 =null;
GrammarAST AT98_tree=null;
GrammarAST ACTION100_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
{
AT98=(Token)match(input,AT,FOLLOW_AT_in_ruleAction2022);
stream_AT.add(AT98);
pushFollow(FOLLOW_id_in_ruleAction2024);
id99=id();
state._fsp--;
stream_id.add(id99.getTree());
ACTION100=(Token)match(input,ACTION,FOLLOW_ACTION_in_ruleAction2026);
stream_ACTION.add(ACTION100);
// AST REWRITE
// elements: AT, id, ACTION
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 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 ruleAltList101 =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_ruleBlock2064);
ruleAltList101=ruleAltList();
state._fsp--;
stream_ruleAltList.add(ruleAltList101.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 OR103=null;
ParserRuleReturnScope labeledAlt102 =null;
ParserRuleReturnScope labeledAlt104 =null;
GrammarAST OR103_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_ruleAltList2100);
labeledAlt102=labeledAlt();
state._fsp--;
stream_labeledAlt.add(labeledAlt102.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:511:15: ( OR labeledAlt )*
loop29:
while (true) {
int alt29=2;
int LA29_0 = input.LA(1);
if ( (LA29_0==OR) ) {
alt29=1;
}
switch (alt29) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:511:16: OR labeledAlt
{
OR103=(Token)match(input,OR,FOLLOW_OR_in_ruleAltList2103);
stream_OR.add(OR103);
pushFollow(FOLLOW_labeledAlt_in_ruleAltList2105);
labeledAlt104=labeledAlt();
state._fsp--;
stream_labeledAlt.add(labeledAlt104.getTree());
}
break;
default :
break loop29;
}
}
// 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 POUND106=null;
ParserRuleReturnScope alternative105 =null;
ParserRuleReturnScope id107 =null;
GrammarAST POUND106_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_labeledAlt2123);
alternative105=alternative();
state._fsp--;
adaptor.addChild(root_0, alternative105.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:516:3: ( POUND ! id !)?
int alt30=2;
int LA30_0 = input.LA(1);
if ( (LA30_0==POUND) ) {
alt30=1;
}
switch (alt30) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:516:5: POUND ! id !
{
POUND106=(Token)match(input,POUND,FOLLOW_POUND_in_labeledAlt2129);
pushFollow(FOLLOW_id_in_labeledAlt2132);
id107=id();
state._fsp--;
((AltAST)(alternative105!=null?((GrammarAST)alternative105.getTree()):null)).altLabel=(id107!=null?((GrammarAST)id107.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_COMMENT108=null;
Token FRAGMENT109=null;
Token TOKEN_REF110=null;
Token COLON111=null;
Token SEMI113=null;
ParserRuleReturnScope lexerRuleBlock112 =null;
GrammarAST DOC_COMMENT108_tree=null;
GrammarAST FRAGMENT109_tree=null;
GrammarAST TOKEN_REF110_tree=null;
GrammarAST COLON111_tree=null;
GrammarAST SEMI113_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 alt31=2;
int LA31_0 = input.LA(1);
if ( (LA31_0==DOC_COMMENT) ) {
alt31=1;
}
switch (alt31) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:525:7: DOC_COMMENT
{
DOC_COMMENT108=(Token)match(input,DOC_COMMENT,FOLLOW_DOC_COMMENT_in_lexerRule2164);
stream_DOC_COMMENT.add(DOC_COMMENT108);
}
break;
}
// org\\antlr\\v4\\parse\\ANTLRParser.g:525:20: ( FRAGMENT )?
int alt32=2;
int LA32_0 = input.LA(1);
if ( (LA32_0==FRAGMENT) ) {
alt32=1;
}
switch (alt32) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:525:20: FRAGMENT
{
FRAGMENT109=(Token)match(input,FRAGMENT,FOLLOW_FRAGMENT_in_lexerRule2167);
stream_FRAGMENT.add(FRAGMENT109);
}
break;
}
TOKEN_REF110=(Token)match(input,TOKEN_REF,FOLLOW_TOKEN_REF_in_lexerRule2173);
stream_TOKEN_REF.add(TOKEN_REF110);
COLON111=(Token)match(input,COLON,FOLLOW_COLON_in_lexerRule2175);
stream_COLON.add(COLON111);
pushFollow(FOLLOW_lexerRuleBlock_in_lexerRule2177);
lexerRuleBlock112=lexerRuleBlock();
state._fsp--;
stream_lexerRuleBlock.add(lexerRuleBlock112.getTree());
SEMI113=(Token)match(input,SEMI,FOLLOW_SEMI_in_lexerRule2179);
stream_SEMI.add(SEMI113);
// AST REWRITE
// elements: lexerRuleBlock, FRAGMENT, TOKEN_REF, DOC_COMMENT
// 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 lexerAltList114 =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_lexerRuleBlock2246);
lexerAltList114=lexerAltList();
state._fsp--;
stream_lexerAltList.add(lexerAltList114.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 OR116=null;
ParserRuleReturnScope lexerAlt115 =null;
ParserRuleReturnScope lexerAlt117 =null;
GrammarAST OR116_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_lexerAltList2282);
lexerAlt115=lexerAlt();
state._fsp--;
stream_lexerAlt.add(lexerAlt115.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:542:13: ( OR lexerAlt )*
loop33:
while (true) {
int alt33=2;
int LA33_0 = input.LA(1);
if ( (LA33_0==OR) ) {
alt33=1;
}
switch (alt33) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:542:14: OR lexerAlt
{
OR116=(Token)match(input,OR,FOLLOW_OR_in_lexerAltList2285);
stream_OR.add(OR116);
pushFollow(FOLLOW_lexerAlt_in_lexerAltList2287);
lexerAlt117=lexerAlt();
state._fsp--;
stream_lexerAlt.add(lexerAlt117.getTree());
}
break;
default :
break loop33;
}
}
// 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 lexerElements118 =null;
ParserRuleReturnScope lexerCommands119 =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 alt35=2;
int LA35_0 = input.LA(1);
if ( (LA35_0==ACTION||LA35_0==DOT||LA35_0==LEXER_CHAR_SET||LA35_0==LPAREN||LA35_0==NOT||LA35_0==RULE_REF||LA35_0==SEMPRED||LA35_0==STRING_LITERAL||LA35_0==TOKEN_REF) ) {
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:546:4: lexerElements ( lexerCommands -> ^( LEXER_ALT_ACTION lexerElements lexerCommands ) | -> lexerElements )
{
pushFollow(FOLLOW_lexerElements_in_lexerAlt2305);
lexerElements118=lexerElements();
state._fsp--;
stream_lexerElements.add(lexerElements118.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:547:3: ( lexerCommands -> ^( LEXER_ALT_ACTION lexerElements lexerCommands ) | -> lexerElements )
int alt34=2;
int LA34_0 = input.LA(1);
if ( (LA34_0==RARROW) ) {
alt34=1;
}
else if ( (LA34_0==OR||LA34_0==RPAREN||LA34_0==SEMI) ) {
alt34=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 34, 0, input);
throw nvae;
}
switch (alt34) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:547:5: lexerCommands
{
pushFollow(FOLLOW_lexerCommands_in_lexerAlt2311);
lexerCommands119=lexerCommands();
state._fsp--;
stream_lexerCommands.add(lexerCommands119.getTree());
// AST REWRITE
// elements: lexerElements, lexerCommands
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 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 lexerElement120 =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 cnt36=0;
loop36:
while (true) {
int alt36=2;
int LA36_0 = input.LA(1);
if ( (LA36_0==ACTION||LA36_0==DOT||LA36_0==LEXER_CHAR_SET||LA36_0==LPAREN||LA36_0==NOT||LA36_0==RULE_REF||LA36_0==SEMPRED||LA36_0==STRING_LITERAL||LA36_0==TOKEN_REF) ) {
alt36=1;
}
switch (alt36) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:554:7: lexerElement
{
pushFollow(FOLLOW_lexerElement_in_lexerElements2374);
lexerElement120=lexerElement();
state._fsp--;
stream_lexerElement.add(lexerElement120.getTree());
}
break;
default :
if ( cnt36 >= 1 ) break loop36;
EarlyExitException eee = new EarlyExitException(36, input);
throw eee;
}
cnt36++;
}
// AST REWRITE
// elements: lexerElement
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 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 labeledLexerElement121 =null;
ParserRuleReturnScope ebnfSuffix122 =null;
ParserRuleReturnScope lexerAtom123 =null;
ParserRuleReturnScope ebnfSuffix124 =null;
ParserRuleReturnScope lexerBlock125 =null;
ParserRuleReturnScope ebnfSuffix126 =null;
ParserRuleReturnScope actionElement127 =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 alt40=4;
switch ( input.LA(1) ) {
case RULE_REF:
{
int LA40_1 = input.LA(2);
if ( (LA40_1==ASSIGN||LA40_1==PLUS_ASSIGN) ) {
alt40=1;
}
else if ( (LA40_1==ACTION||LA40_1==DOT||LA40_1==LEXER_CHAR_SET||LA40_1==LPAREN||LA40_1==NOT||LA40_1==OR||LA40_1==PLUS||LA40_1==QUESTION||LA40_1==RARROW||(LA40_1 >= RPAREN && LA40_1 <= SEMPRED)||(LA40_1 >= STAR && LA40_1 <= STRING_LITERAL)||LA40_1==TOKEN_REF) ) {
alt40=2;
}
else {
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 40, 1, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case TOKEN_REF:
{
int LA40_2 = input.LA(2);
if ( (LA40_2==ASSIGN||LA40_2==PLUS_ASSIGN) ) {
alt40=1;
}
else if ( (LA40_2==ACTION||LA40_2==DOT||LA40_2==LEXER_CHAR_SET||(LA40_2 >= LPAREN && LA40_2 <= LT)||LA40_2==NOT||LA40_2==OR||LA40_2==PLUS||LA40_2==QUESTION||LA40_2==RARROW||(LA40_2 >= RPAREN && LA40_2 <= SEMPRED)||(LA40_2 >= STAR && LA40_2 <= STRING_LITERAL)||LA40_2==TOKEN_REF) ) {
alt40=2;
}
else {
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 40, 2, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case DOT:
case LEXER_CHAR_SET:
case NOT:
case STRING_LITERAL:
{
alt40=2;
}
break;
case LPAREN:
{
alt40=3;
}
break;
case ACTION:
case SEMPRED:
{
alt40=4;
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 40, 0, input);
throw nvae;
}
switch (alt40) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:563:4: labeledLexerElement ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[$labeledLexerElement.start,\"BLOCK\"] ^( ALT labeledLexerElement ) ) ) | -> labeledLexerElement )
{
pushFollow(FOLLOW_labeledLexerElement_in_lexerElement2411);
labeledLexerElement121=labeledLexerElement();
state._fsp--;
stream_labeledLexerElement.add(labeledLexerElement121.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:564:3: ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[$labeledLexerElement.start,\"BLOCK\"] ^( ALT labeledLexerElement ) ) ) | -> labeledLexerElement )
int alt37=2;
int LA37_0 = input.LA(1);
if ( (LA37_0==PLUS||LA37_0==QUESTION||LA37_0==STAR) ) {
alt37=1;
}
else if ( (LA37_0==ACTION||LA37_0==DOT||LA37_0==LEXER_CHAR_SET||LA37_0==LPAREN||LA37_0==NOT||LA37_0==OR||LA37_0==RARROW||(LA37_0 >= RPAREN && LA37_0 <= SEMPRED)||LA37_0==STRING_LITERAL||LA37_0==TOKEN_REF) ) {
alt37=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 37, 0, input);
throw nvae;
}
switch (alt37) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:564:5: ebnfSuffix
{
pushFollow(FOLLOW_ebnfSuffix_in_lexerElement2417);
ebnfSuffix122=ebnfSuffix();
state._fsp--;
stream_ebnfSuffix.add(ebnfSuffix122.getTree());
// AST REWRITE
// elements: labeledLexerElement, ebnfSuffix
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 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, (labeledLexerElement121!=null?(labeledLexerElement121.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_lexerElement2463);
lexerAtom123=lexerAtom();
state._fsp--;
stream_lexerAtom.add(lexerAtom123.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:568:3: ( ebnfSuffix -> ^( ebnfSuffix ^( BLOCK[$lexerAtom.start,\"BLOCK\"] ^( ALT lexerAtom ) ) ) | -> lexerAtom )
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:568:5: ebnfSuffix
{
pushFollow(FOLLOW_ebnfSuffix_in_lexerElement2469);
ebnfSuffix124=ebnfSuffix();
state._fsp--;
stream_ebnfSuffix.add(ebnfSuffix124.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, (lexerAtom123!=null?(lexerAtom123.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_lexerElement2515);
lexerBlock125=lexerBlock();
state._fsp--;
stream_lexerBlock.add(lexerBlock125.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:572:3: ( ebnfSuffix -> ^( ebnfSuffix lexerBlock ) | -> lexerBlock )
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:572:5: ebnfSuffix
{
pushFollow(FOLLOW_ebnfSuffix_in_lexerElement2521);
ebnfSuffix126=ebnfSuffix();
state._fsp--;
stream_ebnfSuffix.add(ebnfSuffix126.getTree());
// AST REWRITE
// elements: lexerBlock, ebnfSuffix
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 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_lexerElement2549);
actionElement127=actionElement();
state._fsp--;
adaptor.addChild(root_0, actionElement127.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 id128 =null;
ParserRuleReturnScope lexerAtom129 =null;
ParserRuleReturnScope lexerBlock130 =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_labeledLexerElement2579);
id128=id();
state._fsp--;
stream_id.add(id128.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:609:7: (ass= ASSIGN |ass= PLUS_ASSIGN )
int alt41=2;
int LA41_0 = input.LA(1);
if ( (LA41_0==ASSIGN) ) {
alt41=1;
}
else if ( (LA41_0==PLUS_ASSIGN) ) {
alt41=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 41, 0, input);
throw nvae;
}
switch (alt41) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:609:8: ass= ASSIGN
{
ass=(Token)match(input,ASSIGN,FOLLOW_ASSIGN_in_labeledLexerElement2584);
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_labeledLexerElement2588);
stream_PLUS_ASSIGN.add(ass);
}
break;
}
// org\\antlr\\v4\\parse\\ANTLRParser.g:610:3: ( lexerAtom -> ^( $ass id lexerAtom ) | lexerBlock -> ^( $ass id lexerBlock ) )
int alt42=2;
int LA42_0 = input.LA(1);
if ( (LA42_0==DOT||LA42_0==LEXER_CHAR_SET||LA42_0==NOT||LA42_0==RULE_REF||LA42_0==STRING_LITERAL||LA42_0==TOKEN_REF) ) {
alt42=1;
}
else if ( (LA42_0==LPAREN) ) {
alt42=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 42, 0, input);
throw nvae;
}
switch (alt42) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:610:5: lexerAtom
{
pushFollow(FOLLOW_lexerAtom_in_labeledLexerElement2595);
lexerAtom129=lexerAtom();
state._fsp--;
stream_lexerAtom.add(lexerAtom129.getTree());
// AST REWRITE
// elements: lexerAtom, id, ass
// 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_labeledLexerElement2612);
lexerBlock130=lexerBlock();
state._fsp--;
stream_lexerBlock.add(lexerBlock130.getTree());
// AST REWRITE
// elements: ass, id, lexerBlock
// token labels: ass
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleTokenStream stream_ass=new RewriteRuleTokenStream(adaptor,"token ass",ass);
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 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 LPAREN131=null;
Token COLON133=null;
Token RPAREN135=null;
ParserRuleReturnScope optionsSpec132 =null;
ParserRuleReturnScope lexerAltList134 =null;
GrammarAST LPAREN131_tree=null;
GrammarAST COLON133_tree=null;
GrammarAST RPAREN135_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
{
LPAREN131=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_lexerBlock2645);
stream_LPAREN.add(LPAREN131);
// org\\antlr\\v4\\parse\\ANTLRParser.g:624:9: ( optionsSpec COLON )?
int alt43=2;
int LA43_0 = input.LA(1);
if ( (LA43_0==OPTIONS) ) {
alt43=1;
}
switch (alt43) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:624:11: optionsSpec COLON
{
pushFollow(FOLLOW_optionsSpec_in_lexerBlock2657);
optionsSpec132=optionsSpec();
state._fsp--;
stream_optionsSpec.add(optionsSpec132.getTree());
COLON133=(Token)match(input,COLON,FOLLOW_COLON_in_lexerBlock2659);
stream_COLON.add(COLON133);
}
break;
}
pushFollow(FOLLOW_lexerAltList_in_lexerBlock2672);
lexerAltList134=lexerAltList();
state._fsp--;
stream_lexerAltList.add(lexerAltList134.getTree());
RPAREN135=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_lexerBlock2682);
stream_RPAREN.add(RPAREN135);
// AST REWRITE
// elements: optionsSpec, lexerAltList
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 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, LPAREN131, "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 RARROW136=null;
Token COMMA138=null;
ParserRuleReturnScope lexerCommand137 =null;
ParserRuleReturnScope lexerCommand139 =null;
GrammarAST RARROW136_tree=null;
GrammarAST COMMA138_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 )*
{
RARROW136=(Token)match(input,RARROW,FOLLOW_RARROW_in_lexerCommands2719);
stream_RARROW.add(RARROW136);
pushFollow(FOLLOW_lexerCommand_in_lexerCommands2721);
lexerCommand137=lexerCommand();
state._fsp--;
stream_lexerCommand.add(lexerCommand137.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:632:24: ( COMMA lexerCommand )*
loop44:
while (true) {
int alt44=2;
int LA44_0 = input.LA(1);
if ( (LA44_0==COMMA) ) {
alt44=1;
}
switch (alt44) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:632:25: COMMA lexerCommand
{
COMMA138=(Token)match(input,COMMA,FOLLOW_COMMA_in_lexerCommands2724);
stream_COMMA.add(COMMA138);
pushFollow(FOLLOW_lexerCommand_in_lexerCommands2726);
lexerCommand139=lexerCommand();
state._fsp--;
stream_lexerCommand.add(lexerCommand139.getTree());
}
break;
default :
break loop44;
}
}
// 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 LPAREN141=null;
Token RPAREN143=null;
ParserRuleReturnScope lexerCommandName140 =null;
ParserRuleReturnScope lexerCommandExpr142 =null;
ParserRuleReturnScope lexerCommandName144 =null;
GrammarAST LPAREN141_tree=null;
GrammarAST RPAREN143_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 alt45=2;
switch ( input.LA(1) ) {
case RULE_REF:
{
int LA45_1 = input.LA(2);
if ( (LA45_1==LPAREN) ) {
alt45=1;
}
else if ( (LA45_1==COMMA||LA45_1==OR||LA45_1==RPAREN||LA45_1==SEMI) ) {
alt45=2;
}
else {
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 45, 1, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case TOKEN_REF:
{
int LA45_2 = input.LA(2);
if ( (LA45_2==LPAREN) ) {
alt45=1;
}
else if ( (LA45_2==COMMA||LA45_2==OR||LA45_2==RPAREN||LA45_2==SEMI) ) {
alt45=2;
}
else {
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 45, 2, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
case MODE:
{
int LA45_3 = input.LA(2);
if ( (LA45_3==LPAREN) ) {
alt45=1;
}
else if ( (LA45_3==COMMA||LA45_3==OR||LA45_3==RPAREN||LA45_3==SEMI) ) {
alt45=2;
}
else {
int nvaeMark = input.mark();
try {
input.consume();
NoViableAltException nvae =
new NoViableAltException("", 45, 3, input);
throw nvae;
} finally {
input.rewind(nvaeMark);
}
}
}
break;
default:
NoViableAltException nvae =
new NoViableAltException("", 45, 0, input);
throw nvae;
}
switch (alt45) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:636:4: lexerCommandName LPAREN lexerCommandExpr RPAREN
{
pushFollow(FOLLOW_lexerCommandName_in_lexerCommand2744);
lexerCommandName140=lexerCommandName();
state._fsp--;
stream_lexerCommandName.add(lexerCommandName140.getTree());
LPAREN141=(Token)match(input,LPAREN,FOLLOW_LPAREN_in_lexerCommand2746);
stream_LPAREN.add(LPAREN141);
pushFollow(FOLLOW_lexerCommandExpr_in_lexerCommand2748);
lexerCommandExpr142=lexerCommandExpr();
state._fsp--;
stream_lexerCommandExpr.add(lexerCommandExpr142.getTree());
RPAREN143=(Token)match(input,RPAREN,FOLLOW_RPAREN_in_lexerCommand2750);
stream_RPAREN.add(RPAREN143);
// AST REWRITE
// elements: lexerCommandExpr, lexerCommandName
// token labels:
// rule labels: retval
// token list labels:
// rule list labels:
// wildcard labels:
retval.tree = root_0;
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.getTree():null);
root_0 = (GrammarAST)adaptor.nil();
// 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_lexerCommand2765);
lexerCommandName144=lexerCommandName();
state._fsp--;
adaptor.addChild(root_0, lexerCommandName144.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 INT146=null;
ParserRuleReturnScope id145 =null;
GrammarAST INT146_tree=null;
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:641:2: ( id | INT )
int alt46=2;
int LA46_0 = input.LA(1);
if ( (LA46_0==RULE_REF||LA46_0==TOKEN_REF) ) {
alt46=1;
}
else if ( (LA46_0==INT) ) {
alt46=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 46, 0, input);
throw nvae;
}
switch (alt46) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:641:4: id
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_id_in_lexerCommandExpr2776);
id145=id();
state._fsp--;
adaptor.addChild(root_0, id145.getTree());
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:642:4: INT
{
root_0 = (GrammarAST)adaptor.nil();
INT146=(Token)match(input,INT,FOLLOW_INT_in_lexerCommandExpr2781);
INT146_tree = (GrammarAST)adaptor.create(INT146);
adaptor.addChild(root_0, INT146_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 MODE148=null;
ParserRuleReturnScope id147 =null;
GrammarAST MODE148_tree=null;
RewriteRuleTokenStream stream_MODE=new RewriteRuleTokenStream(adaptor,"token MODE");
try {
// org\\antlr\\v4\\parse\\ANTLRParser.g:646:9: ( id | MODE -> ID[$MODE] )
int alt47=2;
int LA47_0 = input.LA(1);
if ( (LA47_0==RULE_REF||LA47_0==TOKEN_REF) ) {
alt47=1;
}
else if ( (LA47_0==MODE) ) {
alt47=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 47, 0, input);
throw nvae;
}
switch (alt47) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:646:17: id
{
root_0 = (GrammarAST)adaptor.nil();
pushFollow(FOLLOW_id_in_lexerCommandName2805);
id147=id();
state._fsp--;
adaptor.addChild(root_0, id147.getTree());
}
break;
case 2 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:647:17: MODE
{
MODE148=(Token)match(input,MODE,FOLLOW_MODE_in_lexerCommandName2823);
stream_MODE.add(MODE148);
// 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, MODE148));
}
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 OR150=null;
ParserRuleReturnScope alternative149 =null;
ParserRuleReturnScope alternative151 =null;
GrammarAST OR150_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_altList2851);
alternative149=alternative();
state._fsp--;
stream_alternative.add(alternative149.getTree());
// org\\antlr\\v4\\parse\\ANTLRParser.g:651:19: ( OR alternative )*
loop48:
while (true) {
int alt48=2;
int LA48_0 = input.LA(1);
if ( (LA48_0==OR) ) {
alt48=1;
}
switch (alt48) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:651:20: OR alternative
{
OR150=(Token)match(input,OR,FOLLOW_OR_in_altList2854);
stream_OR.add(OR150);
pushFollow(FOLLOW_alternative_in_altList2856);
alternative151=alternative();
state._fsp--;
stream_alternative.add(alternative151.getTree());
}
break;
default :
break loop48;
}
}
// 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 elements152 =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 alt49=2;
int LA49_0 = input.LA(1);
if ( (LA49_0==ACTION||LA49_0==DOT||LA49_0==LPAREN||LA49_0==NOT||LA49_0==RULE_REF||LA49_0==SEMPRED||LA49_0==STRING_LITERAL||LA49_0==TOKEN_REF) ) {
alt49=1;
}
else if ( (LA49_0==EOF||LA49_0==OR||LA49_0==POUND||LA49_0==RPAREN||LA49_0==SEMI) ) {
alt49=2;
}
else {
NoViableAltException nvae =
new NoViableAltException("", 49, 0, input);
throw nvae;
}
switch (alt49) {
case 1 :
// org\\antlr\\v4\\parse\\ANTLRParser.g:659:7: elements
{
pushFollow(FOLLOW_elements_in_alternative2892);
elements152=elements();
state._fsp--;
stream_elements.add(elements152.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 © 2015 - 2025 Weber Informatics LLC | Privacy Policy