Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
net.hasor.dataql.parser.DataQLParser Maven / Gradle / Ivy
// Generated from net/hasor/dataql/parser/DataQLParser.g4 by ANTLR 4.9.1
package net.hasor.dataql.parser;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class DataQLParser extends Parser {
static { RuntimeMetaData.checkVersion("4.9.1", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
WS=1, COMMENT1=2, COMMENT2=3, EOL=4, AT=5, OPEN_TAG=6, IF=7, ELSE=8, RETURN=9,
THROW=10, ASSERT=11, EXIT=12, VAR=13, RUN=14, HINT=15, IMPORT=16, TRUE=17,
FALSE=18, NULL=19, AS=20, PLUS=21, MINUS=22, MUL=23, DIV=24, DIV2=25,
MOD=26, LBT=27, RBT=28, AND=29, OR=30, NOT=31, XOR=32, LSHIFT=33, RSHIFT=34,
RSHIFT2=35, GT=36, GE=37, LT=38, LE=39, EQ=40, NE=41, SC_OR=42, SC_AND=43,
COMMA=44, COLON=45, ASS=46, DOT=47, LSBT=48, RSBT=49, OCBR=50, CCBR=51,
ROU=52, QUE=53, SEM=54, CONVER=55, LAMBDA=56, STRING=57, HEX_NUM=58, OCT_NUM=59,
BIT_NUM=60, INTEGER_NUM=61, DECIMAL_NUM=62, IDENTIFIER=63, CLOS_TAG=64,
CHAR=65;
public static final int
RULE_rootInstSet = 0, RULE_hintInst = 1, RULE_importInst = 2, RULE_blockSet = 3,
RULE_ifInst = 4, RULE_breakInst = 5, RULE_lambdaDef = 6, RULE_varInst = 7,
RULE_runInst = 8, RULE_assertInst = 9, RULE_anyObject = 10, RULE_routeMapping = 11,
RULE_routeConver = 12, RULE_routeNameSet = 13, RULE_routeName = 14, RULE_routeSubscript = 15,
RULE_funcCall = 16, RULE_funcCallResult = 17, RULE_objectValue = 18, RULE_objectKeyValue = 19,
RULE_listValue = 20, RULE_primitiveValue = 21, RULE_expr = 22, RULE_extBlock = 23,
RULE_extParams = 24;
private static String[] makeRuleNames() {
return new String[] {
"rootInstSet", "hintInst", "importInst", "blockSet", "ifInst", "breakInst",
"lambdaDef", "varInst", "runInst", "assertInst", "anyObject", "routeMapping",
"routeConver", "routeNameSet", "routeName", "routeSubscript", "funcCall",
"funcCallResult", "objectValue", "objectKeyValue", "listValue", "primitiveValue",
"expr", "extBlock", "extParams"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, null, null, null, null, "'@@'", "'<%'", "'if'", "'else'", "'return'",
"'throw'", "'assert'", "'exit'", "'var'", "'run'", "'hint'", "'import'",
"'true'", "'false'", "'null'", "'as'", "'+'", "'-'", "'*'", "'/'", "'\\'",
"'%'", "'('", "')'", "'&'", "'|'", "'!'", "'^'", "'<<'", "'>>'", "'>>>'",
"'>'", "'>='", "'<'", "'<='", "'=='", "'!='", "'||'", "'&&'", "','",
"':'", "'='", "'.'", "'['", "']'", "'{'", "'}'", null, "'?'", "';'",
"'=>'", "'->'", null, null, null, null, null, null, null, "'%>'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, "WS", "COMMENT1", "COMMENT2", "EOL", "AT", "OPEN_TAG", "IF", "ELSE",
"RETURN", "THROW", "ASSERT", "EXIT", "VAR", "RUN", "HINT", "IMPORT",
"TRUE", "FALSE", "NULL", "AS", "PLUS", "MINUS", "MUL", "DIV", "DIV2",
"MOD", "LBT", "RBT", "AND", "OR", "NOT", "XOR", "LSHIFT", "RSHIFT", "RSHIFT2",
"GT", "GE", "LT", "LE", "EQ", "NE", "SC_OR", "SC_AND", "COMMA", "COLON",
"ASS", "DOT", "LSBT", "RSBT", "OCBR", "CCBR", "ROU", "QUE", "SEM", "CONVER",
"LAMBDA", "STRING", "HEX_NUM", "OCT_NUM", "BIT_NUM", "INTEGER_NUM", "DECIMAL_NUM",
"IDENTIFIER", "CLOS_TAG", "CHAR"
};
}
private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
/**
* @deprecated Use {@link #VOCABULARY} instead.
*/
@Deprecated
public static final String[] tokenNames;
static {
tokenNames = new String[_SYMBOLIC_NAMES.length];
for (int i = 0; i < tokenNames.length; i++) {
tokenNames[i] = VOCABULARY.getLiteralName(i);
if (tokenNames[i] == null) {
tokenNames[i] = VOCABULARY.getSymbolicName(i);
}
if (tokenNames[i] == null) {
tokenNames[i] = "";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "DataQLParser.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public DataQLParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class RootInstSetContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(DataQLParser.EOF, 0); }
public List hintInst() {
return getRuleContexts(HintInstContext.class);
}
public HintInstContext hintInst(int i) {
return getRuleContext(HintInstContext.class,i);
}
public List importInst() {
return getRuleContexts(ImportInstContext.class);
}
public ImportInstContext importInst(int i) {
return getRuleContext(ImportInstContext.class,i);
}
public List blockSet() {
return getRuleContexts(BlockSetContext.class);
}
public BlockSetContext blockSet(int i) {
return getRuleContext(BlockSetContext.class,i);
}
public RootInstSetContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rootInstSet; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterRootInstSet(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitRootInstSet(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitRootInstSet(this);
else return visitor.visitChildren(this);
}
}
public final RootInstSetContext rootInstSet() throws RecognitionException {
RootInstSetContext _localctx = new RootInstSetContext(_ctx, getState());
enterRule(_localctx, 0, RULE_rootInstSet);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(53);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==HINT) {
{
{
setState(50);
hintInst();
}
}
setState(55);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(59);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==IMPORT) {
{
{
setState(56);
importInst();
}
}
setState(61);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(63);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(62);
blockSet();
}
}
setState(65);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IF) | (1L << RETURN) | (1L << THROW) | (1L << ASSERT) | (1L << EXIT) | (1L << VAR) | (1L << RUN) | (1L << OCBR))) != 0) );
setState(67);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HintInstContext extends ParserRuleContext {
public TerminalNode HINT() { return getToken(DataQLParser.HINT, 0); }
public TerminalNode IDENTIFIER() { return getToken(DataQLParser.IDENTIFIER, 0); }
public TerminalNode ASS() { return getToken(DataQLParser.ASS, 0); }
public PrimitiveValueContext primitiveValue() {
return getRuleContext(PrimitiveValueContext.class,0);
}
public TerminalNode SEM() { return getToken(DataQLParser.SEM, 0); }
public HintInstContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hintInst; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterHintInst(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitHintInst(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitHintInst(this);
else return visitor.visitChildren(this);
}
}
public final HintInstContext hintInst() throws RecognitionException {
HintInstContext _localctx = new HintInstContext(_ctx, getState());
enterRule(_localctx, 2, RULE_hintInst);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(69);
match(HINT);
setState(70);
match(IDENTIFIER);
setState(71);
match(ASS);
setState(72);
primitiveValue();
setState(74);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SEM) {
{
setState(73);
match(SEM);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ImportInstContext extends ParserRuleContext {
public TerminalNode IMPORT() { return getToken(DataQLParser.IMPORT, 0); }
public TerminalNode STRING() { return getToken(DataQLParser.STRING, 0); }
public TerminalNode AS() { return getToken(DataQLParser.AS, 0); }
public TerminalNode IDENTIFIER() { return getToken(DataQLParser.IDENTIFIER, 0); }
public TerminalNode ROU() { return getToken(DataQLParser.ROU, 0); }
public TerminalNode SEM() { return getToken(DataQLParser.SEM, 0); }
public ImportInstContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_importInst; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterImportInst(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitImportInst(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitImportInst(this);
else return visitor.visitChildren(this);
}
}
public final ImportInstContext importInst() throws RecognitionException {
ImportInstContext _localctx = new ImportInstContext(_ctx, getState());
enterRule(_localctx, 4, RULE_importInst);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(76);
match(IMPORT);
setState(78);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ROU) {
{
setState(77);
match(ROU);
}
}
setState(80);
match(STRING);
setState(81);
match(AS);
setState(82);
match(IDENTIFIER);
setState(84);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SEM) {
{
setState(83);
match(SEM);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BlockSetContext extends ParserRuleContext {
public BlockSetContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_blockSet; }
public BlockSetContext() { }
public void copyFrom(BlockSetContext ctx) {
super.copyFrom(ctx);
}
}
public static class SingleInstContext extends BlockSetContext {
public RunInstContext runInst() {
return getRuleContext(RunInstContext.class,0);
}
public VarInstContext varInst() {
return getRuleContext(VarInstContext.class,0);
}
public IfInstContext ifInst() {
return getRuleContext(IfInstContext.class,0);
}
public BreakInstContext breakInst() {
return getRuleContext(BreakInstContext.class,0);
}
public AssertInstContext assertInst() {
return getRuleContext(AssertInstContext.class,0);
}
public TerminalNode SEM() { return getToken(DataQLParser.SEM, 0); }
public SingleInstContext(BlockSetContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterSingleInst(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitSingleInst(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitSingleInst(this);
else return visitor.visitChildren(this);
}
}
public static class MultipleInstContext extends BlockSetContext {
public TerminalNode OCBR() { return getToken(DataQLParser.OCBR, 0); }
public TerminalNode CCBR() { return getToken(DataQLParser.CCBR, 0); }
public List hintInst() {
return getRuleContexts(HintInstContext.class);
}
public HintInstContext hintInst(int i) {
return getRuleContext(HintInstContext.class,i);
}
public List runInst() {
return getRuleContexts(RunInstContext.class);
}
public RunInstContext runInst(int i) {
return getRuleContext(RunInstContext.class,i);
}
public List varInst() {
return getRuleContexts(VarInstContext.class);
}
public VarInstContext varInst(int i) {
return getRuleContext(VarInstContext.class,i);
}
public List ifInst() {
return getRuleContexts(IfInstContext.class);
}
public IfInstContext ifInst(int i) {
return getRuleContext(IfInstContext.class,i);
}
public List breakInst() {
return getRuleContexts(BreakInstContext.class);
}
public BreakInstContext breakInst(int i) {
return getRuleContext(BreakInstContext.class,i);
}
public List assertInst() {
return getRuleContexts(AssertInstContext.class);
}
public AssertInstContext assertInst(int i) {
return getRuleContext(AssertInstContext.class,i);
}
public List SEM() { return getTokens(DataQLParser.SEM); }
public TerminalNode SEM(int i) {
return getToken(DataQLParser.SEM, i);
}
public MultipleInstContext(BlockSetContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterMultipleInst(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitMultipleInst(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitMultipleInst(this);
else return visitor.visitChildren(this);
}
}
public final BlockSetContext blockSet() throws RecognitionException {
BlockSetContext _localctx = new BlockSetContext(_ctx, getState());
enterRule(_localctx, 6, RULE_blockSet);
int _la;
try {
setState(119);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OCBR:
_localctx = new MultipleInstContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(86);
match(OCBR);
setState(90);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==HINT) {
{
{
setState(87);
hintInst();
}
}
setState(92);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(105);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IF) | (1L << RETURN) | (1L << THROW) | (1L << ASSERT) | (1L << EXIT) | (1L << VAR) | (1L << RUN))) != 0)) {
{
{
setState(98);
_errHandler.sync(this);
switch (_input.LA(1)) {
case RUN:
{
setState(93);
runInst();
}
break;
case VAR:
{
setState(94);
varInst();
}
break;
case IF:
{
setState(95);
ifInst();
}
break;
case RETURN:
case THROW:
case EXIT:
{
setState(96);
breakInst();
}
break;
case ASSERT:
{
setState(97);
assertInst();
}
break;
default:
throw new NoViableAltException(this);
}
setState(101);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SEM) {
{
setState(100);
match(SEM);
}
}
}
}
setState(107);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(108);
match(CCBR);
}
break;
case IF:
case RETURN:
case THROW:
case ASSERT:
case EXIT:
case VAR:
case RUN:
_localctx = new SingleInstContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(114);
_errHandler.sync(this);
switch (_input.LA(1)) {
case RUN:
{
setState(109);
runInst();
}
break;
case VAR:
{
setState(110);
varInst();
}
break;
case IF:
{
setState(111);
ifInst();
}
break;
case RETURN:
case THROW:
case EXIT:
{
setState(112);
breakInst();
}
break;
case ASSERT:
{
setState(113);
assertInst();
}
break;
default:
throw new NoViableAltException(this);
}
setState(117);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
case 1:
{
setState(116);
match(SEM);
}
break;
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IfInstContext extends ParserRuleContext {
public List IF() { return getTokens(DataQLParser.IF); }
public TerminalNode IF(int i) {
return getToken(DataQLParser.IF, i);
}
public List LBT() { return getTokens(DataQLParser.LBT); }
public TerminalNode LBT(int i) {
return getToken(DataQLParser.LBT, i);
}
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public List RBT() { return getTokens(DataQLParser.RBT); }
public TerminalNode RBT(int i) {
return getToken(DataQLParser.RBT, i);
}
public List blockSet() {
return getRuleContexts(BlockSetContext.class);
}
public BlockSetContext blockSet(int i) {
return getRuleContext(BlockSetContext.class,i);
}
public List ELSE() { return getTokens(DataQLParser.ELSE); }
public TerminalNode ELSE(int i) {
return getToken(DataQLParser.ELSE, i);
}
public IfInstContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ifInst; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterIfInst(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitIfInst(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitIfInst(this);
else return visitor.visitChildren(this);
}
}
public final IfInstContext ifInst() throws RecognitionException {
IfInstContext _localctx = new IfInstContext(_ctx, getState());
enterRule(_localctx, 8, RULE_ifInst);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(121);
match(IF);
setState(122);
match(LBT);
setState(123);
expr(0);
setState(124);
match(RBT);
setState(125);
blockSet();
setState(135);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,13,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(126);
match(ELSE);
setState(127);
match(IF);
setState(128);
match(LBT);
setState(129);
expr(0);
setState(130);
match(RBT);
setState(131);
blockSet();
}
}
}
setState(137);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,13,_ctx);
}
setState(140);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
case 1:
{
setState(138);
match(ELSE);
setState(139);
blockSet();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BreakInstContext extends ParserRuleContext {
public AnyObjectContext anyObject() {
return getRuleContext(AnyObjectContext.class,0);
}
public TerminalNode RETURN() { return getToken(DataQLParser.RETURN, 0); }
public TerminalNode THROW() { return getToken(DataQLParser.THROW, 0); }
public TerminalNode EXIT() { return getToken(DataQLParser.EXIT, 0); }
public TerminalNode INTEGER_NUM() { return getToken(DataQLParser.INTEGER_NUM, 0); }
public TerminalNode COMMA() { return getToken(DataQLParser.COMMA, 0); }
public BreakInstContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_breakInst; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterBreakInst(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitBreakInst(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitBreakInst(this);
else return visitor.visitChildren(this);
}
}
public final BreakInstContext breakInst() throws RecognitionException {
BreakInstContext _localctx = new BreakInstContext(_ctx, getState());
enterRule(_localctx, 10, RULE_breakInst);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(142);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << RETURN) | (1L << THROW) | (1L << EXIT))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(145);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
case 1:
{
setState(143);
match(INTEGER_NUM);
setState(144);
match(COMMA);
}
break;
}
setState(147);
anyObject();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LambdaDefContext extends ParserRuleContext {
public TerminalNode LBT() { return getToken(DataQLParser.LBT, 0); }
public TerminalNode RBT() { return getToken(DataQLParser.RBT, 0); }
public TerminalNode LAMBDA() { return getToken(DataQLParser.LAMBDA, 0); }
public BlockSetContext blockSet() {
return getRuleContext(BlockSetContext.class,0);
}
public List IDENTIFIER() { return getTokens(DataQLParser.IDENTIFIER); }
public TerminalNode IDENTIFIER(int i) {
return getToken(DataQLParser.IDENTIFIER, i);
}
public List COMMA() { return getTokens(DataQLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(DataQLParser.COMMA, i);
}
public LambdaDefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lambdaDef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterLambdaDef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitLambdaDef(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitLambdaDef(this);
else return visitor.visitChildren(this);
}
}
public final LambdaDefContext lambdaDef() throws RecognitionException {
LambdaDefContext _localctx = new LambdaDefContext(_ctx, getState());
enterRule(_localctx, 12, RULE_lambdaDef);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(149);
match(LBT);
setState(158);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IDENTIFIER) {
{
setState(150);
match(IDENTIFIER);
setState(155);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(151);
match(COMMA);
setState(152);
match(IDENTIFIER);
}
}
setState(157);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(160);
match(RBT);
setState(161);
match(LAMBDA);
setState(162);
blockSet();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VarInstContext extends ParserRuleContext {
public TerminalNode VAR() { return getToken(DataQLParser.VAR, 0); }
public TerminalNode IDENTIFIER() { return getToken(DataQLParser.IDENTIFIER, 0); }
public TerminalNode ASS() { return getToken(DataQLParser.ASS, 0); }
public AnyObjectContext anyObject() {
return getRuleContext(AnyObjectContext.class,0);
}
public VarInstContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_varInst; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterVarInst(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitVarInst(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitVarInst(this);
else return visitor.visitChildren(this);
}
}
public final VarInstContext varInst() throws RecognitionException {
VarInstContext _localctx = new VarInstContext(_ctx, getState());
enterRule(_localctx, 14, RULE_varInst);
try {
enterOuterAlt(_localctx, 1);
{
setState(164);
match(VAR);
setState(165);
match(IDENTIFIER);
setState(166);
match(ASS);
setState(167);
anyObject();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RunInstContext extends ParserRuleContext {
public TerminalNode RUN() { return getToken(DataQLParser.RUN, 0); }
public AnyObjectContext anyObject() {
return getRuleContext(AnyObjectContext.class,0);
}
public RunInstContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_runInst; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterRunInst(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitRunInst(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitRunInst(this);
else return visitor.visitChildren(this);
}
}
public final RunInstContext runInst() throws RecognitionException {
RunInstContext _localctx = new RunInstContext(_ctx, getState());
enterRule(_localctx, 16, RULE_runInst);
try {
enterOuterAlt(_localctx, 1);
{
setState(169);
match(RUN);
setState(170);
anyObject();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AssertInstContext extends ParserRuleContext {
public TerminalNode ASSERT() { return getToken(DataQLParser.ASSERT, 0); }
public AnyObjectContext anyObject() {
return getRuleContext(AnyObjectContext.class,0);
}
public AssertInstContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assertInst; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterAssertInst(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitAssertInst(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitAssertInst(this);
else return visitor.visitChildren(this);
}
}
public final AssertInstContext assertInst() throws RecognitionException {
AssertInstContext _localctx = new AssertInstContext(_ctx, getState());
enterRule(_localctx, 18, RULE_assertInst);
try {
enterOuterAlt(_localctx, 1);
{
setState(172);
match(ASSERT);
setState(173);
anyObject();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AnyObjectContext extends ParserRuleContext {
public ExtBlockContext extBlock() {
return getRuleContext(ExtBlockContext.class,0);
}
public LambdaDefContext lambdaDef() {
return getRuleContext(LambdaDefContext.class,0);
}
public PrimitiveValueContext primitiveValue() {
return getRuleContext(PrimitiveValueContext.class,0);
}
public ObjectValueContext objectValue() {
return getRuleContext(ObjectValueContext.class,0);
}
public ListValueContext listValue() {
return getRuleContext(ListValueContext.class,0);
}
public FuncCallContext funcCall() {
return getRuleContext(FuncCallContext.class,0);
}
public RouteMappingContext routeMapping() {
return getRuleContext(RouteMappingContext.class,0);
}
public RouteConverContext routeConver() {
return getRuleContext(RouteConverContext.class,0);
}
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public AnyObjectContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_anyObject; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterAnyObject(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitAnyObject(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitAnyObject(this);
else return visitor.visitChildren(this);
}
}
public final AnyObjectContext anyObject() throws RecognitionException {
AnyObjectContext _localctx = new AnyObjectContext(_ctx, getState());
enterRule(_localctx, 20, RULE_anyObject);
try {
setState(184);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(175);
extBlock();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(176);
lambdaDef();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(177);
primitiveValue();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(178);
objectValue();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(179);
listValue();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(180);
funcCall();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(181);
routeMapping();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(182);
routeConver();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(183);
expr(0);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RouteMappingContext extends ParserRuleContext {
public RouteMappingContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_routeMapping; }
public RouteMappingContext() { }
public void copyFrom(RouteMappingContext ctx) {
super.copyFrom(ctx);
}
}
public static class ExprRouteContext extends RouteMappingContext {
public RouteNameSetContext routeNameSet() {
return getRuleContext(RouteNameSetContext.class,0);
}
public TerminalNode ROU() { return getToken(DataQLParser.ROU, 0); }
public ExprRouteContext(RouteMappingContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterExprRoute(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitExprRoute(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitExprRoute(this);
else return visitor.visitChildren(this);
}
}
public static class ParamRouteContext extends RouteMappingContext {
public TerminalNode ROU() { return getToken(DataQLParser.ROU, 0); }
public TerminalNode OCBR() { return getToken(DataQLParser.OCBR, 0); }
public TerminalNode CCBR() { return getToken(DataQLParser.CCBR, 0); }
public TerminalNode IDENTIFIER() { return getToken(DataQLParser.IDENTIFIER, 0); }
public TerminalNode STRING() { return getToken(DataQLParser.STRING, 0); }
public RouteSubscriptContext routeSubscript() {
return getRuleContext(RouteSubscriptContext.class,0);
}
public TerminalNode DOT() { return getToken(DataQLParser.DOT, 0); }
public RouteNameSetContext routeNameSet() {
return getRuleContext(RouteNameSetContext.class,0);
}
public ParamRouteContext(RouteMappingContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterParamRoute(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitParamRoute(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitParamRoute(this);
else return visitor.visitChildren(this);
}
}
public static class NameExprRouteContext extends RouteMappingContext {
public TerminalNode ROU() { return getToken(DataQLParser.ROU, 0); }
public RouteNameSetContext routeNameSet() {
return getRuleContext(RouteNameSetContext.class,0);
}
public TerminalNode DOT() { return getToken(DataQLParser.DOT, 0); }
public NameExprRouteContext(RouteMappingContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterNameExprRoute(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitNameExprRoute(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitNameExprRoute(this);
else return visitor.visitChildren(this);
}
}
public static class SubExprRouteContext extends RouteMappingContext {
public TerminalNode ROU() { return getToken(DataQLParser.ROU, 0); }
public List routeSubscript() {
return getRuleContexts(RouteSubscriptContext.class);
}
public RouteSubscriptContext routeSubscript(int i) {
return getRuleContext(RouteSubscriptContext.class,i);
}
public TerminalNode DOT() { return getToken(DataQLParser.DOT, 0); }
public RouteNameSetContext routeNameSet() {
return getRuleContext(RouteNameSetContext.class,0);
}
public SubExprRouteContext(RouteMappingContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterSubExprRoute(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitSubExprRoute(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitSubExprRoute(this);
else return visitor.visitChildren(this);
}
}
public final RouteMappingContext routeMapping() throws RecognitionException {
RouteMappingContext _localctx = new RouteMappingContext(_ctx, getState());
enterRule(_localctx, 22, RULE_routeMapping);
int _la;
try {
int _alt;
setState(222);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
case 1:
_localctx = new ParamRouteContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(186);
match(ROU);
setState(187);
match(OCBR);
setState(188);
_la = _input.LA(1);
if ( !(_la==STRING || _la==IDENTIFIER) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(189);
match(CCBR);
setState(191);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
case 1:
{
setState(190);
routeSubscript();
}
break;
}
setState(195);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
case 1:
{
setState(193);
match(DOT);
setState(194);
routeNameSet();
}
break;
}
}
break;
case 2:
_localctx = new SubExprRouteContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(197);
match(ROU);
setState(199);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(198);
routeSubscript();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(201);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,21,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
setState(205);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) {
case 1:
{
setState(203);
match(DOT);
setState(204);
routeNameSet();
}
break;
}
}
break;
case 3:
_localctx = new NameExprRouteContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(207);
match(ROU);
setState(209);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(208);
match(DOT);
}
}
setState(211);
routeNameSet();
}
break;
case 4:
_localctx = new ExprRouteContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(220);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) {
case 1:
{
{
setState(213);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ROU) {
{
setState(212);
match(ROU);
}
}
setState(215);
routeNameSet();
}
}
break;
case 2:
{
{
setState(216);
match(ROU);
setState(218);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
case 1:
{
setState(217);
routeNameSet();
}
break;
}
}
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RouteConverContext extends ParserRuleContext {
public RouteConverContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_routeConver; }
public RouteConverContext() { }
public void copyFrom(RouteConverContext ctx) {
super.copyFrom(ctx);
}
}
public static class ExprFmtRouteContext extends RouteConverContext {
public RouteMappingContext routeMapping() {
return getRuleContext(RouteMappingContext.class,0);
}
public TerminalNode CONVER() { return getToken(DataQLParser.CONVER, 0); }
public ObjectValueContext objectValue() {
return getRuleContext(ObjectValueContext.class,0);
}
public ListValueContext listValue() {
return getRuleContext(ListValueContext.class,0);
}
public ExprFmtRouteContext(RouteConverContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterExprFmtRoute(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitExprFmtRoute(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitExprFmtRoute(this);
else return visitor.visitChildren(this);
}
}
public final RouteConverContext routeConver() throws RecognitionException {
RouteConverContext _localctx = new RouteConverContext(_ctx, getState());
enterRule(_localctx, 24, RULE_routeConver);
try {
_localctx = new ExprFmtRouteContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(224);
routeMapping();
setState(225);
match(CONVER);
setState(228);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OCBR:
{
setState(226);
objectValue();
}
break;
case LSBT:
{
setState(227);
listValue();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RouteNameSetContext extends ParserRuleContext {
public List routeName() {
return getRuleContexts(RouteNameContext.class);
}
public RouteNameContext routeName(int i) {
return getRuleContext(RouteNameContext.class,i);
}
public List DOT() { return getTokens(DataQLParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(DataQLParser.DOT, i);
}
public RouteNameSetContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_routeNameSet; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterRouteNameSet(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitRouteNameSet(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitRouteNameSet(this);
else return visitor.visitChildren(this);
}
}
public final RouteNameSetContext routeNameSet() throws RecognitionException {
RouteNameSetContext _localctx = new RouteNameSetContext(_ctx, getState());
enterRule(_localctx, 26, RULE_routeNameSet);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(230);
routeName();
setState(235);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,29,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(231);
match(DOT);
setState(232);
routeName();
}
}
}
setState(237);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,29,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RouteNameContext extends ParserRuleContext {
public TerminalNode IDENTIFIER() { return getToken(DataQLParser.IDENTIFIER, 0); }
public List routeSubscript() {
return getRuleContexts(RouteSubscriptContext.class);
}
public RouteSubscriptContext routeSubscript(int i) {
return getRuleContext(RouteSubscriptContext.class,i);
}
public RouteNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_routeName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterRouteName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitRouteName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitRouteName(this);
else return visitor.visitChildren(this);
}
}
public final RouteNameContext routeName() throws RecognitionException {
RouteNameContext _localctx = new RouteNameContext(_ctx, getState());
enterRule(_localctx, 28, RULE_routeName);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(238);
match(IDENTIFIER);
setState(242);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,30,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(239);
routeSubscript();
}
}
}
setState(244);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,30,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RouteSubscriptContext extends ParserRuleContext {
public TerminalNode LSBT() { return getToken(DataQLParser.LSBT, 0); }
public TerminalNode RSBT() { return getToken(DataQLParser.RSBT, 0); }
public TerminalNode STRING() { return getToken(DataQLParser.STRING, 0); }
public TerminalNode INTEGER_NUM() { return getToken(DataQLParser.INTEGER_NUM, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public RouteSubscriptContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_routeSubscript; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterRouteSubscript(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitRouteSubscript(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitRouteSubscript(this);
else return visitor.visitChildren(this);
}
}
public final RouteSubscriptContext routeSubscript() throws RecognitionException {
RouteSubscriptContext _localctx = new RouteSubscriptContext(_ctx, getState());
enterRule(_localctx, 30, RULE_routeSubscript);
try {
enterOuterAlt(_localctx, 1);
{
setState(245);
match(LSBT);
setState(249);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
case 1:
{
setState(246);
match(STRING);
}
break;
case 2:
{
setState(247);
match(INTEGER_NUM);
}
break;
case 3:
{
setState(248);
expr(0);
}
break;
}
setState(251);
match(RSBT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FuncCallContext extends ParserRuleContext {
public RouteMappingContext routeMapping() {
return getRuleContext(RouteMappingContext.class,0);
}
public TerminalNode LBT() { return getToken(DataQLParser.LBT, 0); }
public TerminalNode RBT() { return getToken(DataQLParser.RBT, 0); }
public List anyObject() {
return getRuleContexts(AnyObjectContext.class);
}
public AnyObjectContext anyObject(int i) {
return getRuleContext(AnyObjectContext.class,i);
}
public FuncCallResultContext funcCallResult() {
return getRuleContext(FuncCallResultContext.class,0);
}
public List COMMA() { return getTokens(DataQLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(DataQLParser.COMMA, i);
}
public FuncCallContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_funcCall; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterFuncCall(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitFuncCall(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitFuncCall(this);
else return visitor.visitChildren(this);
}
}
public final FuncCallContext funcCall() throws RecognitionException {
FuncCallContext _localctx = new FuncCallContext(_ctx, getState());
enterRule(_localctx, 32, RULE_funcCall);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(253);
routeMapping();
setState(254);
match(LBT);
setState(263);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << AT) | (1L << TRUE) | (1L << FALSE) | (1L << NULL) | (1L << PLUS) | (1L << MINUS) | (1L << LBT) | (1L << NOT) | (1L << LSBT) | (1L << OCBR) | (1L << ROU) | (1L << STRING) | (1L << HEX_NUM) | (1L << OCT_NUM) | (1L << BIT_NUM) | (1L << INTEGER_NUM) | (1L << DECIMAL_NUM) | (1L << IDENTIFIER))) != 0)) {
{
setState(255);
anyObject();
setState(260);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(256);
match(COMMA);
setState(257);
anyObject();
}
}
setState(262);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(265);
match(RBT);
setState(267);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) {
case 1:
{
setState(266);
funcCallResult();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FuncCallResultContext extends ParserRuleContext {
public FuncCallResultContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_funcCallResult; }
public FuncCallResultContext() { }
public void copyFrom(FuncCallResultContext ctx) {
super.copyFrom(ctx);
}
}
public static class FuncCallResult_route2Context extends FuncCallResultContext {
public List routeSubscript() {
return getRuleContexts(RouteSubscriptContext.class);
}
public RouteSubscriptContext routeSubscript(int i) {
return getRuleContext(RouteSubscriptContext.class,i);
}
public TerminalNode DOT() { return getToken(DataQLParser.DOT, 0); }
public RouteNameSetContext routeNameSet() {
return getRuleContext(RouteNameSetContext.class,0);
}
public FuncCallResultContext funcCallResult() {
return getRuleContext(FuncCallResultContext.class,0);
}
public FuncCallResult_route2Context(FuncCallResultContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterFuncCallResult_route2(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitFuncCallResult_route2(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitFuncCallResult_route2(this);
else return visitor.visitChildren(this);
}
}
public static class FuncCallResult_convertContext extends FuncCallResultContext {
public TerminalNode CONVER() { return getToken(DataQLParser.CONVER, 0); }
public ObjectValueContext objectValue() {
return getRuleContext(ObjectValueContext.class,0);
}
public ListValueContext listValue() {
return getRuleContext(ListValueContext.class,0);
}
public FuncCallResult_convertContext(FuncCallResultContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterFuncCallResult_convert(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitFuncCallResult_convert(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitFuncCallResult_convert(this);
else return visitor.visitChildren(this);
}
}
public static class FuncCallResult_route1Context extends FuncCallResultContext {
public TerminalNode DOT() { return getToken(DataQLParser.DOT, 0); }
public RouteNameSetContext routeNameSet() {
return getRuleContext(RouteNameSetContext.class,0);
}
public FuncCallResultContext funcCallResult() {
return getRuleContext(FuncCallResultContext.class,0);
}
public List routeSubscript() {
return getRuleContexts(RouteSubscriptContext.class);
}
public RouteSubscriptContext routeSubscript(int i) {
return getRuleContext(RouteSubscriptContext.class,i);
}
public FuncCallResult_route1Context(FuncCallResultContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterFuncCallResult_route1(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitFuncCallResult_route1(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitFuncCallResult_route1(this);
else return visitor.visitChildren(this);
}
}
public static class FuncCallResult_callContext extends FuncCallResultContext {
public TerminalNode LBT() { return getToken(DataQLParser.LBT, 0); }
public TerminalNode RBT() { return getToken(DataQLParser.RBT, 0); }
public List anyObject() {
return getRuleContexts(AnyObjectContext.class);
}
public AnyObjectContext anyObject(int i) {
return getRuleContext(AnyObjectContext.class,i);
}
public FuncCallResultContext funcCallResult() {
return getRuleContext(FuncCallResultContext.class,0);
}
public List COMMA() { return getTokens(DataQLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(DataQLParser.COMMA, i);
}
public FuncCallResult_callContext(FuncCallResultContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterFuncCallResult_call(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitFuncCallResult_call(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitFuncCallResult_call(this);
else return visitor.visitChildren(this);
}
}
public final FuncCallResultContext funcCallResult() throws RecognitionException {
FuncCallResultContext _localctx = new FuncCallResultContext(_ctx, getState());
enterRule(_localctx, 34, RULE_funcCallResult);
int _la;
try {
int _alt;
setState(313);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
case 1:
_localctx = new FuncCallResult_route1Context(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(274);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LSBT) {
{
setState(270);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(269);
routeSubscript();
}
}
setState(272);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==LSBT );
}
}
setState(276);
match(DOT);
setState(277);
routeNameSet();
setState(279);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) {
case 1:
{
setState(278);
funcCallResult();
}
break;
}
}
break;
case 2:
_localctx = new FuncCallResult_route2Context(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(282);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(281);
routeSubscript();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(284);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,38,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
setState(288);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) {
case 1:
{
setState(286);
match(DOT);
setState(287);
routeNameSet();
}
break;
}
setState(291);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
case 1:
{
setState(290);
funcCallResult();
}
break;
}
}
break;
case 3:
_localctx = new FuncCallResult_convertContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(293);
match(CONVER);
setState(296);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OCBR:
{
setState(294);
objectValue();
}
break;
case LSBT:
{
setState(295);
listValue();
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 4:
_localctx = new FuncCallResult_callContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(298);
match(LBT);
setState(307);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << AT) | (1L << TRUE) | (1L << FALSE) | (1L << NULL) | (1L << PLUS) | (1L << MINUS) | (1L << LBT) | (1L << NOT) | (1L << LSBT) | (1L << OCBR) | (1L << ROU) | (1L << STRING) | (1L << HEX_NUM) | (1L << OCT_NUM) | (1L << BIT_NUM) | (1L << INTEGER_NUM) | (1L << DECIMAL_NUM) | (1L << IDENTIFIER))) != 0)) {
{
setState(299);
anyObject();
setState(304);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(300);
match(COMMA);
setState(301);
anyObject();
}
}
setState(306);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(309);
match(RBT);
setState(311);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) {
case 1:
{
setState(310);
funcCallResult();
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ObjectValueContext extends ParserRuleContext {
public TerminalNode OCBR() { return getToken(DataQLParser.OCBR, 0); }
public TerminalNode CCBR() { return getToken(DataQLParser.CCBR, 0); }
public List objectKeyValue() {
return getRuleContexts(ObjectKeyValueContext.class);
}
public ObjectKeyValueContext objectKeyValue(int i) {
return getRuleContext(ObjectKeyValueContext.class,i);
}
public List COMMA() { return getTokens(DataQLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(DataQLParser.COMMA, i);
}
public ObjectValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_objectValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterObjectValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitObjectValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitObjectValue(this);
else return visitor.visitChildren(this);
}
}
public final ObjectValueContext objectValue() throws RecognitionException {
ObjectValueContext _localctx = new ObjectValueContext(_ctx, getState());
enterRule(_localctx, 36, RULE_objectValue);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(315);
match(OCBR);
setState(317);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==STRING) {
{
setState(316);
objectKeyValue();
}
}
setState(323);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(319);
match(COMMA);
setState(320);
objectKeyValue();
}
}
setState(325);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(326);
match(CCBR);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ObjectKeyValueContext extends ParserRuleContext {
public TerminalNode STRING() { return getToken(DataQLParser.STRING, 0); }
public TerminalNode COLON() { return getToken(DataQLParser.COLON, 0); }
public AnyObjectContext anyObject() {
return getRuleContext(AnyObjectContext.class,0);
}
public ObjectKeyValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_objectKeyValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterObjectKeyValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitObjectKeyValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitObjectKeyValue(this);
else return visitor.visitChildren(this);
}
}
public final ObjectKeyValueContext objectKeyValue() throws RecognitionException {
ObjectKeyValueContext _localctx = new ObjectKeyValueContext(_ctx, getState());
enterRule(_localctx, 38, RULE_objectKeyValue);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(328);
match(STRING);
setState(331);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(329);
match(COLON);
setState(330);
anyObject();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ListValueContext extends ParserRuleContext {
public TerminalNode LSBT() { return getToken(DataQLParser.LSBT, 0); }
public TerminalNode RSBT() { return getToken(DataQLParser.RSBT, 0); }
public List anyObject() {
return getRuleContexts(AnyObjectContext.class);
}
public AnyObjectContext anyObject(int i) {
return getRuleContext(AnyObjectContext.class,i);
}
public List COMMA() { return getTokens(DataQLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(DataQLParser.COMMA, i);
}
public ListValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_listValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterListValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitListValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitListValue(this);
else return visitor.visitChildren(this);
}
}
public final ListValueContext listValue() throws RecognitionException {
ListValueContext _localctx = new ListValueContext(_ctx, getState());
enterRule(_localctx, 40, RULE_listValue);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(333);
match(LSBT);
setState(335);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << AT) | (1L << TRUE) | (1L << FALSE) | (1L << NULL) | (1L << PLUS) | (1L << MINUS) | (1L << LBT) | (1L << NOT) | (1L << LSBT) | (1L << OCBR) | (1L << ROU) | (1L << STRING) | (1L << HEX_NUM) | (1L << OCT_NUM) | (1L << BIT_NUM) | (1L << INTEGER_NUM) | (1L << DECIMAL_NUM) | (1L << IDENTIFIER))) != 0)) {
{
setState(334);
anyObject();
}
}
setState(341);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(337);
match(COMMA);
setState(338);
anyObject();
}
}
setState(343);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(344);
match(RSBT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrimitiveValueContext extends ParserRuleContext {
public PrimitiveValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primitiveValue; }
public PrimitiveValueContext() { }
public void copyFrom(PrimitiveValueContext ctx) {
super.copyFrom(ctx);
}
}
public static class StringValueContext extends PrimitiveValueContext {
public TerminalNode STRING() { return getToken(DataQLParser.STRING, 0); }
public StringValueContext(PrimitiveValueContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterStringValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitStringValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitStringValue(this);
else return visitor.visitChildren(this);
}
}
public static class BooleanValueContext extends PrimitiveValueContext {
public TerminalNode TRUE() { return getToken(DataQLParser.TRUE, 0); }
public TerminalNode FALSE() { return getToken(DataQLParser.FALSE, 0); }
public BooleanValueContext(PrimitiveValueContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterBooleanValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitBooleanValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitBooleanValue(this);
else return visitor.visitChildren(this);
}
}
public static class NumberValueContext extends PrimitiveValueContext {
public TerminalNode DECIMAL_NUM() { return getToken(DataQLParser.DECIMAL_NUM, 0); }
public TerminalNode INTEGER_NUM() { return getToken(DataQLParser.INTEGER_NUM, 0); }
public TerminalNode HEX_NUM() { return getToken(DataQLParser.HEX_NUM, 0); }
public TerminalNode OCT_NUM() { return getToken(DataQLParser.OCT_NUM, 0); }
public TerminalNode BIT_NUM() { return getToken(DataQLParser.BIT_NUM, 0); }
public NumberValueContext(PrimitiveValueContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterNumberValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitNumberValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitNumberValue(this);
else return visitor.visitChildren(this);
}
}
public static class NullValueContext extends PrimitiveValueContext {
public TerminalNode NULL() { return getToken(DataQLParser.NULL, 0); }
public NullValueContext(PrimitiveValueContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterNullValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitNullValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitNullValue(this);
else return visitor.visitChildren(this);
}
}
public final PrimitiveValueContext primitiveValue() throws RecognitionException {
PrimitiveValueContext _localctx = new PrimitiveValueContext(_ctx, getState());
enterRule(_localctx, 42, RULE_primitiveValue);
int _la;
try {
setState(350);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING:
_localctx = new StringValueContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(346);
match(STRING);
}
break;
case NULL:
_localctx = new NullValueContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(347);
match(NULL);
}
break;
case TRUE:
case FALSE:
_localctx = new BooleanValueContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(348);
_la = _input.LA(1);
if ( !(_la==TRUE || _la==FALSE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case HEX_NUM:
case OCT_NUM:
case BIT_NUM:
case INTEGER_NUM:
case DECIMAL_NUM:
_localctx = new NumberValueContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(349);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << HEX_NUM) | (1L << OCT_NUM) | (1L << BIT_NUM) | (1L << INTEGER_NUM) | (1L << DECIMAL_NUM))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExprContext extends ParserRuleContext {
public ExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr; }
public ExprContext() { }
public void copyFrom(ExprContext ctx) {
super.copyFrom(ctx);
}
}
public static class DyadicExpr_DContext extends ExprContext {
public Token bop;
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode GT() { return getToken(DataQLParser.GT, 0); }
public TerminalNode GE() { return getToken(DataQLParser.GE, 0); }
public TerminalNode NE() { return getToken(DataQLParser.NE, 0); }
public TerminalNode EQ() { return getToken(DataQLParser.EQ, 0); }
public TerminalNode LE() { return getToken(DataQLParser.LE, 0); }
public TerminalNode LT() { return getToken(DataQLParser.LT, 0); }
public DyadicExpr_DContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterDyadicExpr_D(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitDyadicExpr_D(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitDyadicExpr_D(this);
else return visitor.visitChildren(this);
}
}
public static class UnaryExprContext extends ExprContext {
public Token prefix;
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode PLUS() { return getToken(DataQLParser.PLUS, 0); }
public TerminalNode MINUS() { return getToken(DataQLParser.MINUS, 0); }
public TerminalNode NOT() { return getToken(DataQLParser.NOT, 0); }
public UnaryExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterUnaryExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitUnaryExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitUnaryExpr(this);
else return visitor.visitChildren(this);
}
}
public static class DyadicExpr_EContext extends ExprContext {
public Token bop;
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode SC_OR() { return getToken(DataQLParser.SC_OR, 0); }
public TerminalNode SC_AND() { return getToken(DataQLParser.SC_AND, 0); }
public DyadicExpr_EContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterDyadicExpr_E(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitDyadicExpr_E(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitDyadicExpr_E(this);
else return visitor.visitChildren(this);
}
}
public static class DyadicExpr_BContext extends ExprContext {
public Token bop;
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode PLUS() { return getToken(DataQLParser.PLUS, 0); }
public TerminalNode MINUS() { return getToken(DataQLParser.MINUS, 0); }
public DyadicExpr_BContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterDyadicExpr_B(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitDyadicExpr_B(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitDyadicExpr_B(this);
else return visitor.visitChildren(this);
}
}
public static class TernaryExprContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode QUE() { return getToken(DataQLParser.QUE, 0); }
public TerminalNode COLON() { return getToken(DataQLParser.COLON, 0); }
public TernaryExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterTernaryExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitTernaryExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitTernaryExpr(this);
else return visitor.visitChildren(this);
}
}
public static class DyadicExpr_CContext extends ExprContext {
public Token bop;
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode AND() { return getToken(DataQLParser.AND, 0); }
public TerminalNode OR() { return getToken(DataQLParser.OR, 0); }
public TerminalNode XOR() { return getToken(DataQLParser.XOR, 0); }
public TerminalNode LSHIFT() { return getToken(DataQLParser.LSHIFT, 0); }
public TerminalNode RSHIFT() { return getToken(DataQLParser.RSHIFT, 0); }
public TerminalNode RSHIFT2() { return getToken(DataQLParser.RSHIFT2, 0); }
public DyadicExpr_CContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterDyadicExpr_C(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitDyadicExpr_C(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitDyadicExpr_C(this);
else return visitor.visitChildren(this);
}
}
public static class DyadicExpr_AContext extends ExprContext {
public Token bop;
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode MUL() { return getToken(DataQLParser.MUL, 0); }
public TerminalNode DIV() { return getToken(DataQLParser.DIV, 0); }
public TerminalNode DIV2() { return getToken(DataQLParser.DIV2, 0); }
public TerminalNode MOD() { return getToken(DataQLParser.MOD, 0); }
public DyadicExpr_AContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterDyadicExpr_A(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitDyadicExpr_A(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitDyadicExpr_A(this);
else return visitor.visitChildren(this);
}
}
public static class AtomExprContext extends ExprContext {
public PrimitiveValueContext primitiveValue() {
return getRuleContext(PrimitiveValueContext.class,0);
}
public FuncCallContext funcCall() {
return getRuleContext(FuncCallContext.class,0);
}
public RouteMappingContext routeMapping() {
return getRuleContext(RouteMappingContext.class,0);
}
public AtomExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterAtomExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitAtomExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitAtomExpr(this);
else return visitor.visitChildren(this);
}
}
public static class PrivilegeExprContext extends ExprContext {
public TerminalNode LBT() { return getToken(DataQLParser.LBT, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode RBT() { return getToken(DataQLParser.RBT, 0); }
public PrivilegeExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterPrivilegeExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitPrivilegeExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitPrivilegeExpr(this);
else return visitor.visitChildren(this);
}
}
public final ExprContext expr() throws RecognitionException {
return expr(0);
}
private ExprContext expr(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ExprContext _localctx = new ExprContext(_ctx, _parentState);
ExprContext _prevctx = _localctx;
int _startState = 44;
enterRecursionRule(_localctx, 44, RULE_expr, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(364);
_errHandler.sync(this);
switch (_input.LA(1)) {
case TRUE:
case FALSE:
case NULL:
case ROU:
case STRING:
case HEX_NUM:
case OCT_NUM:
case BIT_NUM:
case INTEGER_NUM:
case DECIMAL_NUM:
case IDENTIFIER:
{
_localctx = new AtomExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(356);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) {
case 1:
{
setState(353);
primitiveValue();
}
break;
case 2:
{
setState(354);
funcCall();
}
break;
case 3:
{
setState(355);
routeMapping();
}
break;
}
}
break;
case LBT:
{
_localctx = new PrivilegeExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(358);
match(LBT);
setState(359);
expr(0);
setState(360);
match(RBT);
}
break;
case PLUS:
case MINUS:
case NOT:
{
_localctx = new UnaryExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(362);
((UnaryExprContext)_localctx).prefix = _input.LT(1);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PLUS) | (1L << MINUS) | (1L << NOT))) != 0)) ) {
((UnaryExprContext)_localctx).prefix = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(363);
expr(7);
}
break;
default:
throw new NoViableAltException(this);
}
_ctx.stop = _input.LT(-1);
setState(389);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,55,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(387);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,54,_ctx) ) {
case 1:
{
_localctx = new DyadicExpr_AContext(new ExprContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(366);
if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
setState(367);
((DyadicExpr_AContext)_localctx).bop = _input.LT(1);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << MUL) | (1L << DIV) | (1L << DIV2) | (1L << MOD))) != 0)) ) {
((DyadicExpr_AContext)_localctx).bop = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(368);
expr(7);
}
break;
case 2:
{
_localctx = new DyadicExpr_BContext(new ExprContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(369);
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
setState(370);
((DyadicExpr_BContext)_localctx).bop = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==PLUS || _la==MINUS) ) {
((DyadicExpr_BContext)_localctx).bop = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(371);
expr(6);
}
break;
case 3:
{
_localctx = new DyadicExpr_CContext(new ExprContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(372);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(373);
((DyadicExpr_CContext)_localctx).bop = _input.LT(1);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << AND) | (1L << OR) | (1L << XOR) | (1L << LSHIFT) | (1L << RSHIFT) | (1L << RSHIFT2))) != 0)) ) {
((DyadicExpr_CContext)_localctx).bop = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(374);
expr(5);
}
break;
case 4:
{
_localctx = new DyadicExpr_DContext(new ExprContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(375);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(376);
((DyadicExpr_DContext)_localctx).bop = _input.LT(1);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << GT) | (1L << GE) | (1L << LT) | (1L << LE) | (1L << EQ) | (1L << NE))) != 0)) ) {
((DyadicExpr_DContext)_localctx).bop = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(377);
expr(4);
}
break;
case 5:
{
_localctx = new DyadicExpr_EContext(new ExprContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(378);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(379);
((DyadicExpr_EContext)_localctx).bop = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==SC_OR || _la==SC_AND) ) {
((DyadicExpr_EContext)_localctx).bop = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(380);
expr(3);
}
break;
case 6:
{
_localctx = new TernaryExprContext(new ExprContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(381);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(382);
match(QUE);
setState(383);
expr(0);
setState(384);
match(COLON);
setState(385);
expr(1);
}
break;
}
}
}
setState(391);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,55,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class ExtBlockContext extends ParserRuleContext {
public TerminalNode AT() { return getToken(DataQLParser.AT, 0); }
public TerminalNode IDENTIFIER() { return getToken(DataQLParser.IDENTIFIER, 0); }
public TerminalNode LBT() { return getToken(DataQLParser.LBT, 0); }
public TerminalNode RBT() { return getToken(DataQLParser.RBT, 0); }
public TerminalNode OPEN_TAG() { return getToken(DataQLParser.OPEN_TAG, 0); }
public TerminalNode CLOS_TAG() { return getToken(DataQLParser.CLOS_TAG, 0); }
public TerminalNode LSBT() { return getToken(DataQLParser.LSBT, 0); }
public TerminalNode RSBT() { return getToken(DataQLParser.RSBT, 0); }
public ExtParamsContext extParams() {
return getRuleContext(ExtParamsContext.class,0);
}
public List CHAR() { return getTokens(DataQLParser.CHAR); }
public TerminalNode CHAR(int i) {
return getToken(DataQLParser.CHAR, i);
}
public ExtBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_extBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterExtBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitExtBlock(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitExtBlock(this);
else return visitor.visitChildren(this);
}
}
public final ExtBlockContext extBlock() throws RecognitionException {
ExtBlockContext _localctx = new ExtBlockContext(_ctx, getState());
enterRule(_localctx, 46, RULE_extBlock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(392);
match(AT);
setState(393);
match(IDENTIFIER);
setState(396);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LSBT) {
{
setState(394);
match(LSBT);
setState(395);
match(RSBT);
}
}
setState(398);
match(LBT);
setState(400);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IDENTIFIER) {
{
setState(399);
extParams();
}
}
setState(402);
match(RBT);
setState(403);
match(OPEN_TAG);
setState(407);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==CHAR) {
{
{
setState(404);
match(CHAR);
}
}
setState(409);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(410);
match(CLOS_TAG);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExtParamsContext extends ParserRuleContext {
public List IDENTIFIER() { return getTokens(DataQLParser.IDENTIFIER); }
public TerminalNode IDENTIFIER(int i) {
return getToken(DataQLParser.IDENTIFIER, i);
}
public List COMMA() { return getTokens(DataQLParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(DataQLParser.COMMA, i);
}
public ExtParamsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_extParams; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).enterExtParams(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof DataQLParserListener ) ((DataQLParserListener)listener).exitExtParams(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof DataQLParserVisitor ) return ((DataQLParserVisitor)visitor).visitExtParams(this);
else return visitor.visitChildren(this);
}
}
public final ExtParamsContext extParams() throws RecognitionException {
ExtParamsContext _localctx = new ExtParamsContext(_ctx, getState());
enterRule(_localctx, 48, RULE_extParams);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(412);
match(IDENTIFIER);
setState(417);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(413);
match(COMMA);
setState(414);
match(IDENTIFIER);
}
}
setState(419);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
switch (ruleIndex) {
case 22:
return expr_sempred((ExprContext)_localctx, predIndex);
}
return true;
}
private boolean expr_sempred(ExprContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return precpred(_ctx, 6);
case 1:
return precpred(_ctx, 5);
case 2:
return precpred(_ctx, 4);
case 3:
return precpred(_ctx, 3);
case 4:
return precpred(_ctx, 2);
case 5:
return precpred(_ctx, 1);
}
return true;
}
public static final String _serializedATN =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3C\u01a7\4\2\t\2\4"+
"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
"\4\32\t\32\3\2\7\2\66\n\2\f\2\16\29\13\2\3\2\7\2<\n\2\f\2\16\2?\13\2\3"+
"\2\6\2B\n\2\r\2\16\2C\3\2\3\2\3\3\3\3\3\3\3\3\3\3\5\3M\n\3\3\4\3\4\5\4"+
"Q\n\4\3\4\3\4\3\4\3\4\5\4W\n\4\3\5\3\5\7\5[\n\5\f\5\16\5^\13\5\3\5\3\5"+
"\3\5\3\5\3\5\5\5e\n\5\3\5\5\5h\n\5\7\5j\n\5\f\5\16\5m\13\5\3\5\3\5\3\5"+
"\3\5\3\5\3\5\5\5u\n\5\3\5\5\5x\n\5\5\5z\n\5\3\6\3\6\3\6\3\6\3\6\3\6\3"+
"\6\3\6\3\6\3\6\3\6\3\6\7\6\u0088\n\6\f\6\16\6\u008b\13\6\3\6\3\6\5\6\u008f"+
"\n\6\3\7\3\7\3\7\5\7\u0094\n\7\3\7\3\7\3\b\3\b\3\b\3\b\7\b\u009c\n\b\f"+
"\b\16\b\u009f\13\b\5\b\u00a1\n\b\3\b\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3"+
"\n\3\n\3\n\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\5\f\u00bb"+
"\n\f\3\r\3\r\3\r\3\r\3\r\5\r\u00c2\n\r\3\r\3\r\5\r\u00c6\n\r\3\r\3\r\6"+
"\r\u00ca\n\r\r\r\16\r\u00cb\3\r\3\r\5\r\u00d0\n\r\3\r\3\r\5\r\u00d4\n"+
"\r\3\r\3\r\5\r\u00d8\n\r\3\r\3\r\3\r\5\r\u00dd\n\r\5\r\u00df\n\r\5\r\u00e1"+
"\n\r\3\16\3\16\3\16\3\16\5\16\u00e7\n\16\3\17\3\17\3\17\7\17\u00ec\n\17"+
"\f\17\16\17\u00ef\13\17\3\20\3\20\7\20\u00f3\n\20\f\20\16\20\u00f6\13"+
"\20\3\21\3\21\3\21\3\21\5\21\u00fc\n\21\3\21\3\21\3\22\3\22\3\22\3\22"+
"\3\22\7\22\u0105\n\22\f\22\16\22\u0108\13\22\5\22\u010a\n\22\3\22\3\22"+
"\5\22\u010e\n\22\3\23\6\23\u0111\n\23\r\23\16\23\u0112\5\23\u0115\n\23"+
"\3\23\3\23\3\23\5\23\u011a\n\23\3\23\6\23\u011d\n\23\r\23\16\23\u011e"+
"\3\23\3\23\5\23\u0123\n\23\3\23\5\23\u0126\n\23\3\23\3\23\3\23\5\23\u012b"+
"\n\23\3\23\3\23\3\23\3\23\7\23\u0131\n\23\f\23\16\23\u0134\13\23\5\23"+
"\u0136\n\23\3\23\3\23\5\23\u013a\n\23\5\23\u013c\n\23\3\24\3\24\5\24\u0140"+
"\n\24\3\24\3\24\7\24\u0144\n\24\f\24\16\24\u0147\13\24\3\24\3\24\3\25"+
"\3\25\3\25\5\25\u014e\n\25\3\26\3\26\5\26\u0152\n\26\3\26\3\26\7\26\u0156"+
"\n\26\f\26\16\26\u0159\13\26\3\26\3\26\3\27\3\27\3\27\3\27\5\27\u0161"+
"\n\27\3\30\3\30\3\30\3\30\5\30\u0167\n\30\3\30\3\30\3\30\3\30\3\30\3\30"+
"\5\30\u016f\n\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30"+
"\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\7\30\u0186\n\30\f\30"+
"\16\30\u0189\13\30\3\31\3\31\3\31\3\31\5\31\u018f\n\31\3\31\3\31\5\31"+
"\u0193\n\31\3\31\3\31\3\31\7\31\u0198\n\31\f\31\16\31\u019b\13\31\3\31"+
"\3\31\3\32\3\32\3\32\7\32\u01a2\n\32\f\32\16\32\u01a5\13\32\3\32\2\3."+
"\33\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\2\f\4\2\13\f"+
"\16\16\4\2;;AA\3\2\23\24\3\2<@\4\2\27\30!!\3\2\31\34\3\2\27\30\4\2\37"+
" \"%\3\2&+\3\2,-\2\u01e3\2\67\3\2\2\2\4G\3\2\2\2\6N\3\2\2\2\by\3\2\2\2"+
"\n{\3\2\2\2\f\u0090\3\2\2\2\16\u0097\3\2\2\2\20\u00a6\3\2\2\2\22\u00ab"+
"\3\2\2\2\24\u00ae\3\2\2\2\26\u00ba\3\2\2\2\30\u00e0\3\2\2\2\32\u00e2\3"+
"\2\2\2\34\u00e8\3\2\2\2\36\u00f0\3\2\2\2 \u00f7\3\2\2\2\"\u00ff\3\2\2"+
"\2$\u013b\3\2\2\2&\u013d\3\2\2\2(\u014a\3\2\2\2*\u014f\3\2\2\2,\u0160"+
"\3\2\2\2.\u016e\3\2\2\2\60\u018a\3\2\2\2\62\u019e\3\2\2\2\64\66\5\4\3"+
"\2\65\64\3\2\2\2\669\3\2\2\2\67\65\3\2\2\2\678\3\2\2\28=\3\2\2\29\67\3"+
"\2\2\2:<\5\6\4\2;:\3\2\2\2\3\2\2\2>A\3\2\2\2?=\3"+
"\2\2\2@B\5\b\5\2A@\3\2\2\2BC\3\2\2\2CA\3\2\2\2CD\3\2\2\2DE\3\2\2\2EF\7"+
"\2\2\3F\3\3\2\2\2GH\7\21\2\2HI\7A\2\2IJ\7\60\2\2JL\5,\27\2KM\78\2\2LK"+
"\3\2\2\2LM\3\2\2\2M\5\3\2\2\2NP\7\22\2\2OQ\7\66\2\2PO\3\2\2\2PQ\3\2\2"+
"\2QR\3\2\2\2RS\7;\2\2ST\7\26\2\2TV\7A\2\2UW\78\2\2VU\3\2\2\2VW\3\2\2\2"+
"W\7\3\2\2\2X\\\7\64\2\2Y[\5\4\3\2ZY\3\2\2\2[^\3\2\2\2\\Z\3\2\2\2\\]\3"+
"\2\2\2]k\3\2\2\2^\\\3\2\2\2_e\5\22\n\2`e\5\20\t\2ae\5\n\6\2be\5\f\7\2"+
"ce\5\24\13\2d_\3\2\2\2d`\3\2\2\2da\3\2\2\2db\3\2\2\2dc\3\2\2\2eg\3\2\2"+
"\2fh\78\2\2gf\3\2\2\2gh\3\2\2\2hj\3\2\2\2id\3\2\2\2jm\3\2\2\2ki\3\2\2"+
"\2kl\3\2\2\2ln\3\2\2\2mk\3\2\2\2nz\7\65\2\2ou\5\22\n\2pu\5\20\t\2qu\5"+
"\n\6\2ru\5\f\7\2su\5\24\13\2to\3\2\2\2tp\3\2\2\2tq\3\2\2\2tr\3\2\2\2t"+
"s\3\2\2\2uw\3\2\2\2vx\78\2\2wv\3\2\2\2wx\3\2\2\2xz\3\2\2\2yX\3\2\2\2y"+
"t\3\2\2\2z\t\3\2\2\2{|\7\t\2\2|}\7\35\2\2}~\5.\30\2~\177\7\36\2\2\177"+
"\u0089\5\b\5\2\u0080\u0081\7\n\2\2\u0081\u0082\7\t\2\2\u0082\u0083\7\35"+
"\2\2\u0083\u0084\5.\30\2\u0084\u0085\7\36\2\2\u0085\u0086\5\b\5\2\u0086"+
"\u0088\3\2\2\2\u0087\u0080\3\2\2\2\u0088\u008b\3\2\2\2\u0089\u0087\3\2"+
"\2\2\u0089\u008a\3\2\2\2\u008a\u008e\3\2\2\2\u008b\u0089\3\2\2\2\u008c"+
"\u008d\7\n\2\2\u008d\u008f\5\b\5\2\u008e\u008c\3\2\2\2\u008e\u008f\3\2"+
"\2\2\u008f\13\3\2\2\2\u0090\u0093\t\2\2\2\u0091\u0092\7?\2\2\u0092\u0094"+
"\7.\2\2\u0093\u0091\3\2\2\2\u0093\u0094\3\2\2\2\u0094\u0095\3\2\2\2\u0095"+
"\u0096\5\26\f\2\u0096\r\3\2\2\2\u0097\u00a0\7\35\2\2\u0098\u009d\7A\2"+
"\2\u0099\u009a\7.\2\2\u009a\u009c\7A\2\2\u009b\u0099\3\2\2\2\u009c\u009f"+
"\3\2\2\2\u009d\u009b\3\2\2\2\u009d\u009e\3\2\2\2\u009e\u00a1\3\2\2\2\u009f"+
"\u009d\3\2\2\2\u00a0\u0098\3\2\2\2\u00a0\u00a1\3\2\2\2\u00a1\u00a2\3\2"+
"\2\2\u00a2\u00a3\7\36\2\2\u00a3\u00a4\7:\2\2\u00a4\u00a5\5\b\5\2\u00a5"+
"\17\3\2\2\2\u00a6\u00a7\7\17\2\2\u00a7\u00a8\7A\2\2\u00a8\u00a9\7\60\2"+
"\2\u00a9\u00aa\5\26\f\2\u00aa\21\3\2\2\2\u00ab\u00ac\7\20\2\2\u00ac\u00ad"+
"\5\26\f\2\u00ad\23\3\2\2\2\u00ae\u00af\7\r\2\2\u00af\u00b0\5\26\f\2\u00b0"+
"\25\3\2\2\2\u00b1\u00bb\5\60\31\2\u00b2\u00bb\5\16\b\2\u00b3\u00bb\5,"+
"\27\2\u00b4\u00bb\5&\24\2\u00b5\u00bb\5*\26\2\u00b6\u00bb\5\"\22\2\u00b7"+
"\u00bb\5\30\r\2\u00b8\u00bb\5\32\16\2\u00b9\u00bb\5.\30\2\u00ba\u00b1"+
"\3\2\2\2\u00ba\u00b2\3\2\2\2\u00ba\u00b3\3\2\2\2\u00ba\u00b4\3\2\2\2\u00ba"+
"\u00b5\3\2\2\2\u00ba\u00b6\3\2\2\2\u00ba\u00b7\3\2\2\2\u00ba\u00b8\3\2"+
"\2\2\u00ba\u00b9\3\2\2\2\u00bb\27\3\2\2\2\u00bc\u00bd\7\66\2\2\u00bd\u00be"+
"\7\64\2\2\u00be\u00bf\t\3\2\2\u00bf\u00c1\7\65\2\2\u00c0\u00c2\5 \21\2"+
"\u00c1\u00c0\3\2\2\2\u00c1\u00c2\3\2\2\2\u00c2\u00c5\3\2\2\2\u00c3\u00c4"+
"\7\61\2\2\u00c4\u00c6\5\34\17\2\u00c5\u00c3\3\2\2\2\u00c5\u00c6\3\2\2"+
"\2\u00c6\u00e1\3\2\2\2\u00c7\u00c9\7\66\2\2\u00c8\u00ca\5 \21\2\u00c9"+
"\u00c8\3\2\2\2\u00ca\u00cb\3\2\2\2\u00cb\u00c9\3\2\2\2\u00cb\u00cc\3\2"+
"\2\2\u00cc\u00cf\3\2\2\2\u00cd\u00ce\7\61\2\2\u00ce\u00d0\5\34\17\2\u00cf"+
"\u00cd\3\2\2\2\u00cf\u00d0\3\2\2\2\u00d0\u00e1\3\2\2\2\u00d1\u00d3\7\66"+
"\2\2\u00d2\u00d4\7\61\2\2\u00d3\u00d2\3\2\2\2\u00d3\u00d4\3\2\2\2\u00d4"+
"\u00d5\3\2\2\2\u00d5\u00e1\5\34\17\2\u00d6\u00d8\7\66\2\2\u00d7\u00d6"+
"\3\2\2\2\u00d7\u00d8\3\2\2\2\u00d8\u00d9\3\2\2\2\u00d9\u00df\5\34\17\2"+
"\u00da\u00dc\7\66\2\2\u00db\u00dd\5\34\17\2\u00dc\u00db\3\2\2\2\u00dc"+
"\u00dd\3\2\2\2\u00dd\u00df\3\2\2\2\u00de\u00d7\3\2\2\2\u00de\u00da\3\2"+
"\2\2\u00df\u00e1\3\2\2\2\u00e0\u00bc\3\2\2\2\u00e0\u00c7\3\2\2\2\u00e0"+
"\u00d1\3\2\2\2\u00e0\u00de\3\2\2\2\u00e1\31\3\2\2\2\u00e2\u00e3\5\30\r"+
"\2\u00e3\u00e6\79\2\2\u00e4\u00e7\5&\24\2\u00e5\u00e7\5*\26\2\u00e6\u00e4"+
"\3\2\2\2\u00e6\u00e5\3\2\2\2\u00e7\33\3\2\2\2\u00e8\u00ed\5\36\20\2\u00e9"+
"\u00ea\7\61\2\2\u00ea\u00ec\5\36\20\2\u00eb\u00e9\3\2\2\2\u00ec\u00ef"+
"\3\2\2\2\u00ed\u00eb\3\2\2\2\u00ed\u00ee\3\2\2\2\u00ee\35\3\2\2\2\u00ef"+
"\u00ed\3\2\2\2\u00f0\u00f4\7A\2\2\u00f1\u00f3\5 \21\2\u00f2\u00f1\3\2"+
"\2\2\u00f3\u00f6\3\2\2\2\u00f4\u00f2\3\2\2\2\u00f4\u00f5\3\2\2\2\u00f5"+
"\37\3\2\2\2\u00f6\u00f4\3\2\2\2\u00f7\u00fb\7\62\2\2\u00f8\u00fc\7;\2"+
"\2\u00f9\u00fc\7?\2\2\u00fa\u00fc\5.\30\2\u00fb\u00f8\3\2\2\2\u00fb\u00f9"+
"\3\2\2\2\u00fb\u00fa\3\2\2\2\u00fc\u00fd\3\2\2\2\u00fd\u00fe\7\63\2\2"+
"\u00fe!\3\2\2\2\u00ff\u0100\5\30\r\2\u0100\u0109\7\35\2\2\u0101\u0106"+
"\5\26\f\2\u0102\u0103\7.\2\2\u0103\u0105\5\26\f\2\u0104\u0102\3\2\2\2"+
"\u0105\u0108\3\2\2\2\u0106\u0104\3\2\2\2\u0106\u0107\3\2\2\2\u0107\u010a"+
"\3\2\2\2\u0108\u0106\3\2\2\2\u0109\u0101\3\2\2\2\u0109\u010a\3\2\2\2\u010a"+
"\u010b\3\2\2\2\u010b\u010d\7\36\2\2\u010c\u010e\5$\23\2\u010d\u010c\3"+
"\2\2\2\u010d\u010e\3\2\2\2\u010e#\3\2\2\2\u010f\u0111\5 \21\2\u0110\u010f"+
"\3\2\2\2\u0111\u0112\3\2\2\2\u0112\u0110\3\2\2\2\u0112\u0113\3\2\2\2\u0113"+
"\u0115\3\2\2\2\u0114\u0110\3\2\2\2\u0114\u0115\3\2\2\2\u0115\u0116\3\2"+
"\2\2\u0116\u0117\7\61\2\2\u0117\u0119\5\34\17\2\u0118\u011a\5$\23\2\u0119"+
"\u0118\3\2\2\2\u0119\u011a\3\2\2\2\u011a\u013c\3\2\2\2\u011b\u011d\5 "+
"\21\2\u011c\u011b\3\2\2\2\u011d\u011e\3\2\2\2\u011e\u011c\3\2\2\2\u011e"+
"\u011f\3\2\2\2\u011f\u0122\3\2\2\2\u0120\u0121\7\61\2\2\u0121\u0123\5"+
"\34\17\2\u0122\u0120\3\2\2\2\u0122\u0123\3\2\2\2\u0123\u0125\3\2\2\2\u0124"+
"\u0126\5$\23\2\u0125\u0124\3\2\2\2\u0125\u0126\3\2\2\2\u0126\u013c\3\2"+
"\2\2\u0127\u012a\79\2\2\u0128\u012b\5&\24\2\u0129\u012b\5*\26\2\u012a"+
"\u0128\3\2\2\2\u012a\u0129\3\2\2\2\u012b\u013c\3\2\2\2\u012c\u0135\7\35"+
"\2\2\u012d\u0132\5\26\f\2\u012e\u012f\7.\2\2\u012f\u0131\5\26\f\2\u0130"+
"\u012e\3\2\2\2\u0131\u0134\3\2\2\2\u0132\u0130\3\2\2\2\u0132\u0133\3\2"+
"\2\2\u0133\u0136\3\2\2\2\u0134\u0132\3\2\2\2\u0135\u012d\3\2\2\2\u0135"+
"\u0136\3\2\2\2\u0136\u0137\3\2\2\2\u0137\u0139\7\36\2\2\u0138\u013a\5"+
"$\23\2\u0139\u0138\3\2\2\2\u0139\u013a\3\2\2\2\u013a\u013c\3\2\2\2\u013b"+
"\u0114\3\2\2\2\u013b\u011c\3\2\2\2\u013b\u0127\3\2\2\2\u013b\u012c\3\2"+
"\2\2\u013c%\3\2\2\2\u013d\u013f\7\64\2\2\u013e\u0140\5(\25\2\u013f\u013e"+
"\3\2\2\2\u013f\u0140\3\2\2\2\u0140\u0145\3\2\2\2\u0141\u0142\7.\2\2\u0142"+
"\u0144\5(\25\2\u0143\u0141\3\2\2\2\u0144\u0147\3\2\2\2\u0145\u0143\3\2"+
"\2\2\u0145\u0146\3\2\2\2\u0146\u0148\3\2\2\2\u0147\u0145\3\2\2\2\u0148"+
"\u0149\7\65\2\2\u0149\'\3\2\2\2\u014a\u014d\7;\2\2\u014b\u014c\7/\2\2"+
"\u014c\u014e\5\26\f\2\u014d\u014b\3\2\2\2\u014d\u014e\3\2\2\2\u014e)\3"+
"\2\2\2\u014f\u0151\7\62\2\2\u0150\u0152\5\26\f\2\u0151\u0150\3\2\2\2\u0151"+
"\u0152\3\2\2\2\u0152\u0157\3\2\2\2\u0153\u0154\7.\2\2\u0154\u0156\5\26"+
"\f\2\u0155\u0153\3\2\2\2\u0156\u0159\3\2\2\2\u0157\u0155\3\2\2\2\u0157"+
"\u0158\3\2\2\2\u0158\u015a\3\2\2\2\u0159\u0157\3\2\2\2\u015a\u015b\7\63"+
"\2\2\u015b+\3\2\2\2\u015c\u0161\7;\2\2\u015d\u0161\7\25\2\2\u015e\u0161"+
"\t\4\2\2\u015f\u0161\t\5\2\2\u0160\u015c\3\2\2\2\u0160\u015d\3\2\2\2\u0160"+
"\u015e\3\2\2\2\u0160\u015f\3\2\2\2\u0161-\3\2\2\2\u0162\u0166\b\30\1\2"+
"\u0163\u0167\5,\27\2\u0164\u0167\5\"\22\2\u0165\u0167\5\30\r\2\u0166\u0163"+
"\3\2\2\2\u0166\u0164\3\2\2\2\u0166\u0165\3\2\2\2\u0167\u016f\3\2\2\2\u0168"+
"\u0169\7\35\2\2\u0169\u016a\5.\30\2\u016a\u016b\7\36\2\2\u016b\u016f\3"+
"\2\2\2\u016c\u016d\t\6\2\2\u016d\u016f\5.\30\t\u016e\u0162\3\2\2\2\u016e"+
"\u0168\3\2\2\2\u016e\u016c\3\2\2\2\u016f\u0187\3\2\2\2\u0170\u0171\f\b"+
"\2\2\u0171\u0172\t\7\2\2\u0172\u0186\5.\30\t\u0173\u0174\f\7\2\2\u0174"+
"\u0175\t\b\2\2\u0175\u0186\5.\30\b\u0176\u0177\f\6\2\2\u0177\u0178\t\t"+
"\2\2\u0178\u0186\5.\30\7\u0179\u017a\f\5\2\2\u017a\u017b\t\n\2\2\u017b"+
"\u0186\5.\30\6\u017c\u017d\f\4\2\2\u017d\u017e\t\13\2\2\u017e\u0186\5"+
".\30\5\u017f\u0180\f\3\2\2\u0180\u0181\7\67\2\2\u0181\u0182\5.\30\2\u0182"+
"\u0183\7/\2\2\u0183\u0184\5.\30\3\u0184\u0186\3\2\2\2\u0185\u0170\3\2"+
"\2\2\u0185\u0173\3\2\2\2\u0185\u0176\3\2\2\2\u0185\u0179\3\2\2\2\u0185"+
"\u017c\3\2\2\2\u0185\u017f\3\2\2\2\u0186\u0189\3\2\2\2\u0187\u0185\3\2"+
"\2\2\u0187\u0188\3\2\2\2\u0188/\3\2\2\2\u0189\u0187\3\2\2\2\u018a\u018b"+
"\7\7\2\2\u018b\u018e\7A\2\2\u018c\u018d\7\62\2\2\u018d\u018f\7\63\2\2"+
"\u018e\u018c\3\2\2\2\u018e\u018f\3\2\2\2\u018f\u0190\3\2\2\2\u0190\u0192"+
"\7\35\2\2\u0191\u0193\5\62\32\2\u0192\u0191\3\2\2\2\u0192\u0193\3\2\2"+
"\2\u0193\u0194\3\2\2\2\u0194\u0195\7\36\2\2\u0195\u0199\7\b\2\2\u0196"+
"\u0198\7C\2\2\u0197\u0196\3\2\2\2\u0198\u019b\3\2\2\2\u0199\u0197\3\2"+
"\2\2\u0199\u019a\3\2\2\2\u019a\u019c\3\2\2\2\u019b\u0199\3\2\2\2\u019c"+
"\u019d\7B\2\2\u019d\61\3\2\2\2\u019e\u01a3\7A\2\2\u019f\u01a0\7.\2\2\u01a0"+
"\u01a2\7A\2\2\u01a1\u019f\3\2\2\2\u01a2\u01a5\3\2\2\2\u01a3\u01a1\3\2"+
"\2\2\u01a3\u01a4\3\2\2\2\u01a4\63\3\2\2\2\u01a5\u01a3\3\2\2\2>\67=CLP"+
"V\\dgktwy\u0089\u008e\u0093\u009d\u00a0\u00ba\u00c1\u00c5\u00cb\u00cf"+
"\u00d3\u00d7\u00dc\u00de\u00e0\u00e6\u00ed\u00f4\u00fb\u0106\u0109\u010d"+
"\u0112\u0114\u0119\u011e\u0122\u0125\u012a\u0132\u0135\u0139\u013b\u013f"+
"\u0145\u014d\u0151\u0157\u0160\u0166\u016e\u0185\u0187\u018e\u0192\u0199"+
"\u01a3";
public static final ATN _ATN =
new ATNDeserializer().deserialize(_serializedATN.toCharArray());
static {
_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
}
}
}
