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.
org.projectnessie.cel.parser.gen.CELParser Maven / Gradle / Ivy
// Generated from org.projectnessie.cel.parser.gen/CEL.g4 by ANTLR 4.13.2
package org.projectnessie.cel.parser.gen;
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", "CheckReturnValue", "this-escape"})
public class CELParser extends Parser {
static { RuntimeMetaData.checkVersion("4.13.2", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
EQUALS=1, NOT_EQUALS=2, IN=3, LESS=4, LESS_EQUALS=5, GREATER_EQUALS=6,
GREATER=7, LOGICAL_AND=8, LOGICAL_OR=9, LBRACKET=10, RPRACKET=11, LBRACE=12,
RBRACE=13, LPAREN=14, RPAREN=15, DOT=16, COMMA=17, MINUS=18, EXCLAM=19,
QUESTIONMARK=20, COLON=21, PLUS=22, STAR=23, SLASH=24, PERCENT=25, TRUE=26,
FALSE=27, NULL=28, WHITESPACE=29, COMMENT=30, NUM_FLOAT=31, NUM_INT=32,
NUM_UINT=33, STRING=34, BYTES=35, IDENTIFIER=36;
public static final int
RULE_start = 0, RULE_expr = 1, RULE_conditionalOr = 2, RULE_conditionalAnd = 3,
RULE_relation = 4, RULE_calc = 5, RULE_unary = 6, RULE_member = 7, RULE_primary = 8,
RULE_exprList = 9, RULE_fieldInitializerList = 10, RULE_mapInitializerList = 11,
RULE_literal = 12;
private static String[] makeRuleNames() {
return new String[] {
"start", "expr", "conditionalOr", "conditionalAnd", "relation", "calc",
"unary", "member", "primary", "exprList", "fieldInitializerList", "mapInitializerList",
"literal"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, "'=='", "'!='", "'in'", "'<'", "'<='", "'>='", "'>'", "'&&'", "'||'",
"'['", "']'", "'{'", "'}'", "'('", "')'", "'.'", "','", "'-'", "'!'",
"'?'", "':'", "'+'", "'*'", "'/'", "'%'", "'true'", "'false'", "'null'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, "EQUALS", "NOT_EQUALS", "IN", "LESS", "LESS_EQUALS", "GREATER_EQUALS",
"GREATER", "LOGICAL_AND", "LOGICAL_OR", "LBRACKET", "RPRACKET", "LBRACE",
"RBRACE", "LPAREN", "RPAREN", "DOT", "COMMA", "MINUS", "EXCLAM", "QUESTIONMARK",
"COLON", "PLUS", "STAR", "SLASH", "PERCENT", "TRUE", "FALSE", "NULL",
"WHITESPACE", "COMMENT", "NUM_FLOAT", "NUM_INT", "NUM_UINT", "STRING",
"BYTES", "IDENTIFIER"
};
}
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 "CEL.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public CELParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
@SuppressWarnings("CheckReturnValue")
public static class StartContext extends ParserRuleContext {
public ExprContext e;
public TerminalNode EOF() { return getToken(CELParser.EOF, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public StartContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_start; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).enterStart(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).exitStart(this);
}
}
public final StartContext start() throws RecognitionException {
StartContext _localctx = new StartContext(_ctx, getState());
enterRule(_localctx, 0, RULE_start);
try {
enterOuterAlt(_localctx, 1);
{
setState(26);
((StartContext)_localctx).e = expr();
setState(27);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ExprContext extends ParserRuleContext {
public ConditionalOrContext e;
public Token op;
public ConditionalOrContext e1;
public ExprContext e2;
public List conditionalOr() {
return getRuleContexts(ConditionalOrContext.class);
}
public ConditionalOrContext conditionalOr(int i) {
return getRuleContext(ConditionalOrContext.class,i);
}
public TerminalNode COLON() { return getToken(CELParser.COLON, 0); }
public TerminalNode QUESTIONMARK() { return getToken(CELParser.QUESTIONMARK, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public ExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).enterExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).exitExpr(this);
}
}
public final ExprContext expr() throws RecognitionException {
ExprContext _localctx = new ExprContext(_ctx, getState());
enterRule(_localctx, 2, RULE_expr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(29);
((ExprContext)_localctx).e = conditionalOr();
setState(35);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==QUESTIONMARK) {
{
setState(30);
((ExprContext)_localctx).op = match(QUESTIONMARK);
setState(31);
((ExprContext)_localctx).e1 = conditionalOr();
setState(32);
match(COLON);
setState(33);
((ExprContext)_localctx).e2 = expr();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ConditionalOrContext extends ParserRuleContext {
public ConditionalAndContext e;
public Token s9;
public List ops = new ArrayList();
public ConditionalAndContext conditionalAnd;
public List e1 = new ArrayList();
public List conditionalAnd() {
return getRuleContexts(ConditionalAndContext.class);
}
public ConditionalAndContext conditionalAnd(int i) {
return getRuleContext(ConditionalAndContext.class,i);
}
public List LOGICAL_OR() { return getTokens(CELParser.LOGICAL_OR); }
public TerminalNode LOGICAL_OR(int i) {
return getToken(CELParser.LOGICAL_OR, i);
}
public ConditionalOrContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_conditionalOr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).enterConditionalOr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).exitConditionalOr(this);
}
}
public final ConditionalOrContext conditionalOr() throws RecognitionException {
ConditionalOrContext _localctx = new ConditionalOrContext(_ctx, getState());
enterRule(_localctx, 4, RULE_conditionalOr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(37);
((ConditionalOrContext)_localctx).e = conditionalAnd();
setState(42);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LOGICAL_OR) {
{
{
setState(38);
((ConditionalOrContext)_localctx).s9 = match(LOGICAL_OR);
((ConditionalOrContext)_localctx).ops.add(((ConditionalOrContext)_localctx).s9);
setState(39);
((ConditionalOrContext)_localctx).conditionalAnd = conditionalAnd();
((ConditionalOrContext)_localctx).e1.add(((ConditionalOrContext)_localctx).conditionalAnd);
}
}
setState(44);
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class ConditionalAndContext extends ParserRuleContext {
public RelationContext e;
public Token s8;
public List ops = new ArrayList();
public RelationContext relation;
public List e1 = new ArrayList();
public List relation() {
return getRuleContexts(RelationContext.class);
}
public RelationContext relation(int i) {
return getRuleContext(RelationContext.class,i);
}
public List LOGICAL_AND() { return getTokens(CELParser.LOGICAL_AND); }
public TerminalNode LOGICAL_AND(int i) {
return getToken(CELParser.LOGICAL_AND, i);
}
public ConditionalAndContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_conditionalAnd; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).enterConditionalAnd(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).exitConditionalAnd(this);
}
}
public final ConditionalAndContext conditionalAnd() throws RecognitionException {
ConditionalAndContext _localctx = new ConditionalAndContext(_ctx, getState());
enterRule(_localctx, 6, RULE_conditionalAnd);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(45);
((ConditionalAndContext)_localctx).e = relation(0);
setState(50);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LOGICAL_AND) {
{
{
setState(46);
((ConditionalAndContext)_localctx).s8 = match(LOGICAL_AND);
((ConditionalAndContext)_localctx).ops.add(((ConditionalAndContext)_localctx).s8);
setState(47);
((ConditionalAndContext)_localctx).relation = relation(0);
((ConditionalAndContext)_localctx).e1.add(((ConditionalAndContext)_localctx).relation);
}
}
setState(52);
_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;
}
@SuppressWarnings("CheckReturnValue")
public static class RelationContext extends ParserRuleContext {
public Token op;
public CalcContext calc() {
return getRuleContext(CalcContext.class,0);
}
public List relation() {
return getRuleContexts(RelationContext.class);
}
public RelationContext relation(int i) {
return getRuleContext(RelationContext.class,i);
}
public TerminalNode LESS() { return getToken(CELParser.LESS, 0); }
public TerminalNode LESS_EQUALS() { return getToken(CELParser.LESS_EQUALS, 0); }
public TerminalNode GREATER_EQUALS() { return getToken(CELParser.GREATER_EQUALS, 0); }
public TerminalNode GREATER() { return getToken(CELParser.GREATER, 0); }
public TerminalNode EQUALS() { return getToken(CELParser.EQUALS, 0); }
public TerminalNode NOT_EQUALS() { return getToken(CELParser.NOT_EQUALS, 0); }
public TerminalNode IN() { return getToken(CELParser.IN, 0); }
public RelationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).enterRelation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).exitRelation(this);
}
}
public final RelationContext relation() throws RecognitionException {
return relation(0);
}
private RelationContext relation(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
RelationContext _localctx = new RelationContext(_ctx, _parentState);
RelationContext _prevctx = _localctx;
int _startState = 8;
enterRecursionRule(_localctx, 8, RULE_relation, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(54);
calc(0);
}
_ctx.stop = _input.LT(-1);
setState(61);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,3,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new RelationContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_relation);
setState(56);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(57);
((RelationContext)_localctx).op = _input.LT(1);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 254L) != 0)) ) {
((RelationContext)_localctx).op = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(58);
relation(2);
}
}
}
setState(63);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,3,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class CalcContext extends ParserRuleContext {
public Token op;
public UnaryContext unary() {
return getRuleContext(UnaryContext.class,0);
}
public List calc() {
return getRuleContexts(CalcContext.class);
}
public CalcContext calc(int i) {
return getRuleContext(CalcContext.class,i);
}
public TerminalNode STAR() { return getToken(CELParser.STAR, 0); }
public TerminalNode SLASH() { return getToken(CELParser.SLASH, 0); }
public TerminalNode PERCENT() { return getToken(CELParser.PERCENT, 0); }
public TerminalNode PLUS() { return getToken(CELParser.PLUS, 0); }
public TerminalNode MINUS() { return getToken(CELParser.MINUS, 0); }
public CalcContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_calc; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).enterCalc(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).exitCalc(this);
}
}
public final CalcContext calc() throws RecognitionException {
return calc(0);
}
private CalcContext calc(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
CalcContext _localctx = new CalcContext(_ctx, _parentState);
CalcContext _prevctx = _localctx;
int _startState = 10;
enterRecursionRule(_localctx, 10, RULE_calc, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(65);
unary();
}
_ctx.stop = _input.LT(-1);
setState(75);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(73);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
case 1:
{
_localctx = new CalcContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_calc);
setState(67);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(68);
((CalcContext)_localctx).op = _input.LT(1);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 58720256L) != 0)) ) {
((CalcContext)_localctx).op = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(69);
calc(3);
}
break;
case 2:
{
_localctx = new CalcContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_calc);
setState(70);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(71);
((CalcContext)_localctx).op = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==MINUS || _la==PLUS) ) {
((CalcContext)_localctx).op = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(72);
calc(2);
}
break;
}
}
}
setState(77);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UnaryContext extends ParserRuleContext {
public UnaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unary; }
public UnaryContext() { }
public void copyFrom(UnaryContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class LogicalNotContext extends UnaryContext {
public Token s19;
public List ops = new ArrayList();
public MemberContext member() {
return getRuleContext(MemberContext.class,0);
}
public List EXCLAM() { return getTokens(CELParser.EXCLAM); }
public TerminalNode EXCLAM(int i) {
return getToken(CELParser.EXCLAM, i);
}
public LogicalNotContext(UnaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).enterLogicalNot(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).exitLogicalNot(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class MemberExprContext extends UnaryContext {
public MemberContext member() {
return getRuleContext(MemberContext.class,0);
}
public MemberExprContext(UnaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).enterMemberExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).exitMemberExpr(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class NegateContext extends UnaryContext {
public Token s18;
public List ops = new ArrayList();
public MemberContext member() {
return getRuleContext(MemberContext.class,0);
}
public List MINUS() { return getTokens(CELParser.MINUS); }
public TerminalNode MINUS(int i) {
return getToken(CELParser.MINUS, i);
}
public NegateContext(UnaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).enterNegate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).exitNegate(this);
}
}
public final UnaryContext unary() throws RecognitionException {
UnaryContext _localctx = new UnaryContext(_ctx, getState());
enterRule(_localctx, 12, RULE_unary);
int _la;
try {
int _alt;
setState(91);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {
case 1:
_localctx = new MemberExprContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(78);
member(0);
}
break;
case 2:
_localctx = new LogicalNotContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(80);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(79);
((LogicalNotContext)_localctx).s19 = match(EXCLAM);
((LogicalNotContext)_localctx).ops.add(((LogicalNotContext)_localctx).s19);
}
}
setState(82);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==EXCLAM );
setState(84);
member(0);
}
break;
case 3:
_localctx = new NegateContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(86);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(85);
((NegateContext)_localctx).s18 = match(MINUS);
((NegateContext)_localctx).ops.add(((NegateContext)_localctx).s18);
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(88);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,7,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
setState(90);
member(0);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MemberContext extends ParserRuleContext {
public MemberContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_member; }
public MemberContext() { }
public void copyFrom(MemberContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SelectOrCallContext extends MemberContext {
public Token op;
public Token id;
public Token open;
public ExprListContext args;
public MemberContext member() {
return getRuleContext(MemberContext.class,0);
}
public TerminalNode DOT() { return getToken(CELParser.DOT, 0); }
public TerminalNode IDENTIFIER() { return getToken(CELParser.IDENTIFIER, 0); }
public TerminalNode RPAREN() { return getToken(CELParser.RPAREN, 0); }
public TerminalNode LPAREN() { return getToken(CELParser.LPAREN, 0); }
public ExprListContext exprList() {
return getRuleContext(ExprListContext.class,0);
}
public SelectOrCallContext(MemberContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).enterSelectOrCall(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).exitSelectOrCall(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PrimaryExprContext extends MemberContext {
public PrimaryContext primary() {
return getRuleContext(PrimaryContext.class,0);
}
public PrimaryExprContext(MemberContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).enterPrimaryExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).exitPrimaryExpr(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class IndexContext extends MemberContext {
public Token op;
public ExprContext index;
public MemberContext member() {
return getRuleContext(MemberContext.class,0);
}
public TerminalNode RPRACKET() { return getToken(CELParser.RPRACKET, 0); }
public TerminalNode LBRACKET() { return getToken(CELParser.LBRACKET, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public IndexContext(MemberContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).enterIndex(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).exitIndex(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateMessageContext extends MemberContext {
public Token op;
public FieldInitializerListContext entries;
public MemberContext member() {
return getRuleContext(MemberContext.class,0);
}
public TerminalNode RBRACE() { return getToken(CELParser.RBRACE, 0); }
public TerminalNode LBRACE() { return getToken(CELParser.LBRACE, 0); }
public TerminalNode COMMA() { return getToken(CELParser.COMMA, 0); }
public FieldInitializerListContext fieldInitializerList() {
return getRuleContext(FieldInitializerListContext.class,0);
}
public CreateMessageContext(MemberContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).enterCreateMessage(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).exitCreateMessage(this);
}
}
public final MemberContext member() throws RecognitionException {
return member(0);
}
private MemberContext member(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
MemberContext _localctx = new MemberContext(_ctx, _parentState);
MemberContext _prevctx = _localctx;
int _startState = 14;
enterRecursionRule(_localctx, 14, RULE_member, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
_localctx = new PrimaryExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(94);
primary();
}
_ctx.stop = _input.LT(-1);
setState(122);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(120);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
case 1:
{
_localctx = new SelectOrCallContext(new MemberContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_member);
setState(96);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(97);
((SelectOrCallContext)_localctx).op = match(DOT);
setState(98);
((SelectOrCallContext)_localctx).id = match(IDENTIFIER);
setState(104);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
case 1:
{
setState(99);
((SelectOrCallContext)_localctx).open = match(LPAREN);
setState(101);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 135762105344L) != 0)) {
{
setState(100);
((SelectOrCallContext)_localctx).args = exprList();
}
}
setState(103);
match(RPAREN);
}
break;
}
}
break;
case 2:
{
_localctx = new IndexContext(new MemberContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_member);
setState(106);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(107);
((IndexContext)_localctx).op = match(LBRACKET);
setState(108);
((IndexContext)_localctx).index = expr();
setState(109);
match(RPRACKET);
}
break;
case 3:
{
_localctx = new CreateMessageContext(new MemberContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_member);
setState(111);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(112);
((CreateMessageContext)_localctx).op = match(LBRACE);
setState(114);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IDENTIFIER) {
{
setState(113);
((CreateMessageContext)_localctx).entries = fieldInitializerList();
}
}
setState(117);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(116);
match(COMMA);
}
}
setState(119);
match(RBRACE);
}
break;
}
}
}
setState(124);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PrimaryContext extends ParserRuleContext {
public PrimaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primary; }
public PrimaryContext() { }
public void copyFrom(PrimaryContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateListContext extends PrimaryContext {
public Token op;
public ExprListContext elems;
public TerminalNode RPRACKET() { return getToken(CELParser.RPRACKET, 0); }
public TerminalNode LBRACKET() { return getToken(CELParser.LBRACKET, 0); }
public TerminalNode COMMA() { return getToken(CELParser.COMMA, 0); }
public ExprListContext exprList() {
return getRuleContext(ExprListContext.class,0);
}
public CreateListContext(PrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).enterCreateList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).exitCreateList(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CreateStructContext extends PrimaryContext {
public Token op;
public MapInitializerListContext entries;
public TerminalNode RBRACE() { return getToken(CELParser.RBRACE, 0); }
public TerminalNode LBRACE() { return getToken(CELParser.LBRACE, 0); }
public TerminalNode COMMA() { return getToken(CELParser.COMMA, 0); }
public MapInitializerListContext mapInitializerList() {
return getRuleContext(MapInitializerListContext.class,0);
}
public CreateStructContext(PrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).enterCreateStruct(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).exitCreateStruct(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ConstantLiteralContext extends PrimaryContext {
public LiteralContext literal() {
return getRuleContext(LiteralContext.class,0);
}
public ConstantLiteralContext(PrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).enterConstantLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).exitConstantLiteral(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class NestedContext extends PrimaryContext {
public ExprContext e;
public TerminalNode LPAREN() { return getToken(CELParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(CELParser.RPAREN, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public NestedContext(PrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).enterNested(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).exitNested(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class IdentOrGlobalCallContext extends PrimaryContext {
public Token leadingDot;
public Token id;
public Token op;
public ExprListContext args;
public TerminalNode IDENTIFIER() { return getToken(CELParser.IDENTIFIER, 0); }
public TerminalNode RPAREN() { return getToken(CELParser.RPAREN, 0); }
public TerminalNode DOT() { return getToken(CELParser.DOT, 0); }
public TerminalNode LPAREN() { return getToken(CELParser.LPAREN, 0); }
public ExprListContext exprList() {
return getRuleContext(ExprListContext.class,0);
}
public IdentOrGlobalCallContext(PrimaryContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).enterIdentOrGlobalCall(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).exitIdentOrGlobalCall(this);
}
}
public final PrimaryContext primary() throws RecognitionException {
PrimaryContext _localctx = new PrimaryContext(_ctx, getState());
enterRule(_localctx, 16, RULE_primary);
int _la;
try {
setState(157);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DOT:
case IDENTIFIER:
_localctx = new IdentOrGlobalCallContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(126);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(125);
((IdentOrGlobalCallContext)_localctx).leadingDot = match(DOT);
}
}
setState(128);
((IdentOrGlobalCallContext)_localctx).id = match(IDENTIFIER);
setState(134);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
case 1:
{
setState(129);
((IdentOrGlobalCallContext)_localctx).op = match(LPAREN);
setState(131);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 135762105344L) != 0)) {
{
setState(130);
((IdentOrGlobalCallContext)_localctx).args = exprList();
}
}
setState(133);
match(RPAREN);
}
break;
}
}
break;
case LPAREN:
_localctx = new NestedContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(136);
match(LPAREN);
setState(137);
((NestedContext)_localctx).e = expr();
setState(138);
match(RPAREN);
}
break;
case LBRACKET:
_localctx = new CreateListContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(140);
((CreateListContext)_localctx).op = match(LBRACKET);
setState(142);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 135762105344L) != 0)) {
{
setState(141);
((CreateListContext)_localctx).elems = exprList();
}
}
setState(145);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(144);
match(COMMA);
}
}
setState(147);
match(RPRACKET);
}
break;
case LBRACE:
_localctx = new CreateStructContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(148);
((CreateStructContext)_localctx).op = match(LBRACE);
setState(150);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 135762105344L) != 0)) {
{
setState(149);
((CreateStructContext)_localctx).entries = mapInitializerList();
}
}
setState(153);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(152);
match(COMMA);
}
}
setState(155);
match(RBRACE);
}
break;
case MINUS:
case TRUE:
case FALSE:
case NULL:
case NUM_FLOAT:
case NUM_INT:
case NUM_UINT:
case STRING:
case BYTES:
_localctx = new ConstantLiteralContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(156);
literal();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ExprListContext extends ParserRuleContext {
public ExprContext expr;
public List e = new ArrayList();
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public List COMMA() { return getTokens(CELParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(CELParser.COMMA, i);
}
public ExprListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exprList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).enterExprList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).exitExprList(this);
}
}
public final ExprListContext exprList() throws RecognitionException {
ExprListContext _localctx = new ExprListContext(_ctx, getState());
enterRule(_localctx, 18, RULE_exprList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(159);
((ExprListContext)_localctx).expr = expr();
((ExprListContext)_localctx).e.add(((ExprListContext)_localctx).expr);
setState(164);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,23,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(160);
match(COMMA);
setState(161);
((ExprListContext)_localctx).expr = expr();
((ExprListContext)_localctx).e.add(((ExprListContext)_localctx).expr);
}
}
}
setState(166);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,23,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FieldInitializerListContext extends ParserRuleContext {
public Token IDENTIFIER;
public List fields = new ArrayList();
public Token s21;
public List cols = new ArrayList();
public ExprContext expr;
public List values = new ArrayList();
public List IDENTIFIER() { return getTokens(CELParser.IDENTIFIER); }
public TerminalNode IDENTIFIER(int i) {
return getToken(CELParser.IDENTIFIER, i);
}
public List COLON() { return getTokens(CELParser.COLON); }
public TerminalNode COLON(int i) {
return getToken(CELParser.COLON, i);
}
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public List COMMA() { return getTokens(CELParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(CELParser.COMMA, i);
}
public FieldInitializerListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fieldInitializerList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).enterFieldInitializerList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).exitFieldInitializerList(this);
}
}
public final FieldInitializerListContext fieldInitializerList() throws RecognitionException {
FieldInitializerListContext _localctx = new FieldInitializerListContext(_ctx, getState());
enterRule(_localctx, 20, RULE_fieldInitializerList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(167);
((FieldInitializerListContext)_localctx).IDENTIFIER = match(IDENTIFIER);
((FieldInitializerListContext)_localctx).fields.add(((FieldInitializerListContext)_localctx).IDENTIFIER);
setState(168);
((FieldInitializerListContext)_localctx).s21 = match(COLON);
((FieldInitializerListContext)_localctx).cols.add(((FieldInitializerListContext)_localctx).s21);
setState(169);
((FieldInitializerListContext)_localctx).expr = expr();
((FieldInitializerListContext)_localctx).values.add(((FieldInitializerListContext)_localctx).expr);
setState(176);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,24,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(170);
match(COMMA);
setState(171);
((FieldInitializerListContext)_localctx).IDENTIFIER = match(IDENTIFIER);
((FieldInitializerListContext)_localctx).fields.add(((FieldInitializerListContext)_localctx).IDENTIFIER);
setState(172);
((FieldInitializerListContext)_localctx).s21 = match(COLON);
((FieldInitializerListContext)_localctx).cols.add(((FieldInitializerListContext)_localctx).s21);
setState(173);
((FieldInitializerListContext)_localctx).expr = expr();
((FieldInitializerListContext)_localctx).values.add(((FieldInitializerListContext)_localctx).expr);
}
}
}
setState(178);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,24,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class MapInitializerListContext extends ParserRuleContext {
public ExprContext expr;
public List keys = new ArrayList();
public Token s21;
public List cols = new ArrayList();
public List values = new ArrayList();
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public List COLON() { return getTokens(CELParser.COLON); }
public TerminalNode COLON(int i) {
return getToken(CELParser.COLON, i);
}
public List COMMA() { return getTokens(CELParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(CELParser.COMMA, i);
}
public MapInitializerListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_mapInitializerList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).enterMapInitializerList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).exitMapInitializerList(this);
}
}
public final MapInitializerListContext mapInitializerList() throws RecognitionException {
MapInitializerListContext _localctx = new MapInitializerListContext(_ctx, getState());
enterRule(_localctx, 22, RULE_mapInitializerList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(179);
((MapInitializerListContext)_localctx).expr = expr();
((MapInitializerListContext)_localctx).keys.add(((MapInitializerListContext)_localctx).expr);
setState(180);
((MapInitializerListContext)_localctx).s21 = match(COLON);
((MapInitializerListContext)_localctx).cols.add(((MapInitializerListContext)_localctx).s21);
setState(181);
((MapInitializerListContext)_localctx).expr = expr();
((MapInitializerListContext)_localctx).values.add(((MapInitializerListContext)_localctx).expr);
setState(189);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,25,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(182);
match(COMMA);
setState(183);
((MapInitializerListContext)_localctx).expr = expr();
((MapInitializerListContext)_localctx).keys.add(((MapInitializerListContext)_localctx).expr);
setState(184);
((MapInitializerListContext)_localctx).s21 = match(COLON);
((MapInitializerListContext)_localctx).cols.add(((MapInitializerListContext)_localctx).s21);
setState(185);
((MapInitializerListContext)_localctx).expr = expr();
((MapInitializerListContext)_localctx).values.add(((MapInitializerListContext)_localctx).expr);
}
}
}
setState(191);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,25,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LiteralContext extends ParserRuleContext {
public LiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_literal; }
public LiteralContext() { }
public void copyFrom(LiteralContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class BytesContext extends LiteralContext {
public Token tok;
public TerminalNode BYTES() { return getToken(CELParser.BYTES, 0); }
public BytesContext(LiteralContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).enterBytes(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).exitBytes(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class UintContext extends LiteralContext {
public Token tok;
public TerminalNode NUM_UINT() { return getToken(CELParser.NUM_UINT, 0); }
public UintContext(LiteralContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).enterUint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).exitUint(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class NullContext extends LiteralContext {
public Token tok;
public TerminalNode NULL() { return getToken(CELParser.NULL, 0); }
public NullContext(LiteralContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).enterNull(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).exitNull(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class BoolFalseContext extends LiteralContext {
public Token tok;
public TerminalNode FALSE() { return getToken(CELParser.FALSE, 0); }
public BoolFalseContext(LiteralContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).enterBoolFalse(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).exitBoolFalse(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class StringContext extends LiteralContext {
public Token tok;
public TerminalNode STRING() { return getToken(CELParser.STRING, 0); }
public StringContext(LiteralContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).enterString(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).exitString(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DoubleContext extends LiteralContext {
public Token sign;
public Token tok;
public TerminalNode NUM_FLOAT() { return getToken(CELParser.NUM_FLOAT, 0); }
public TerminalNode MINUS() { return getToken(CELParser.MINUS, 0); }
public DoubleContext(LiteralContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).enterDouble(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).exitDouble(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class BoolTrueContext extends LiteralContext {
public Token tok;
public TerminalNode TRUE() { return getToken(CELParser.TRUE, 0); }
public BoolTrueContext(LiteralContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).enterBoolTrue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).exitBoolTrue(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class IntContext extends LiteralContext {
public Token sign;
public Token tok;
public TerminalNode NUM_INT() { return getToken(CELParser.NUM_INT, 0); }
public TerminalNode MINUS() { return getToken(CELParser.MINUS, 0); }
public IntContext(LiteralContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).enterInt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CELListener ) ((CELListener)listener).exitInt(this);
}
}
public final LiteralContext literal() throws RecognitionException {
LiteralContext _localctx = new LiteralContext(_ctx, getState());
enterRule(_localctx, 24, RULE_literal);
int _la;
try {
setState(206);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,28,_ctx) ) {
case 1:
_localctx = new IntContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(193);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(192);
((IntContext)_localctx).sign = match(MINUS);
}
}
setState(195);
((IntContext)_localctx).tok = match(NUM_INT);
}
break;
case 2:
_localctx = new UintContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(196);
((UintContext)_localctx).tok = match(NUM_UINT);
}
break;
case 3:
_localctx = new DoubleContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(198);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(197);
((DoubleContext)_localctx).sign = match(MINUS);
}
}
setState(200);
((DoubleContext)_localctx).tok = match(NUM_FLOAT);
}
break;
case 4:
_localctx = new StringContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(201);
((StringContext)_localctx).tok = match(STRING);
}
break;
case 5:
_localctx = new BytesContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(202);
((BytesContext)_localctx).tok = match(BYTES);
}
break;
case 6:
_localctx = new BoolTrueContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(203);
((BoolTrueContext)_localctx).tok = match(TRUE);
}
break;
case 7:
_localctx = new BoolFalseContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(204);
((BoolFalseContext)_localctx).tok = match(FALSE);
}
break;
case 8:
_localctx = new NullContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(205);
((NullContext)_localctx).tok = match(NULL);
}
break;
}
}
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 4:
return relation_sempred((RelationContext)_localctx, predIndex);
case 5:
return calc_sempred((CalcContext)_localctx, predIndex);
case 7:
return member_sempred((MemberContext)_localctx, predIndex);
}
return true;
}
private boolean relation_sempred(RelationContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return precpred(_ctx, 1);
}
return true;
}
private boolean calc_sempred(CalcContext _localctx, int predIndex) {
switch (predIndex) {
case 1:
return precpred(_ctx, 2);
case 2:
return precpred(_ctx, 1);
}
return true;
}
private boolean member_sempred(MemberContext _localctx, int predIndex) {
switch (predIndex) {
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 =
"\u0004\u0001$\u00d1\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001\u0002"+
"\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004\u0002"+
"\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007\u0002"+
"\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b\u0002"+
"\f\u0007\f\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001"+
"\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0003\u0001$\b\u0001"+
"\u0001\u0002\u0001\u0002\u0001\u0002\u0005\u0002)\b\u0002\n\u0002\f\u0002"+
",\t\u0002\u0001\u0003\u0001\u0003\u0001\u0003\u0005\u00031\b\u0003\n\u0003"+
"\f\u00034\t\u0003\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001"+
"\u0004\u0001\u0004\u0005\u0004<\b\u0004\n\u0004\f\u0004?\t\u0004\u0001"+
"\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001"+
"\u0005\u0001\u0005\u0001\u0005\u0005\u0005J\b\u0005\n\u0005\f\u0005M\t"+
"\u0005\u0001\u0006\u0001\u0006\u0004\u0006Q\b\u0006\u000b\u0006\f\u0006"+
"R\u0001\u0006\u0001\u0006\u0004\u0006W\b\u0006\u000b\u0006\f\u0006X\u0001"+
"\u0006\u0003\u0006\\\b\u0006\u0001\u0007\u0001\u0007\u0001\u0007\u0001"+
"\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0003\u0007f\b"+
"\u0007\u0001\u0007\u0003\u0007i\b\u0007\u0001\u0007\u0001\u0007\u0001"+
"\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0003"+
"\u0007s\b\u0007\u0001\u0007\u0003\u0007v\b\u0007\u0001\u0007\u0005\u0007"+
"y\b\u0007\n\u0007\f\u0007|\t\u0007\u0001\b\u0003\b\u007f\b\b\u0001\b\u0001"+
"\b\u0001\b\u0003\b\u0084\b\b\u0001\b\u0003\b\u0087\b\b\u0001\b\u0001\b"+
"\u0001\b\u0001\b\u0001\b\u0001\b\u0003\b\u008f\b\b\u0001\b\u0003\b\u0092"+
"\b\b\u0001\b\u0001\b\u0001\b\u0003\b\u0097\b\b\u0001\b\u0003\b\u009a\b"+
"\b\u0001\b\u0001\b\u0003\b\u009e\b\b\u0001\t\u0001\t\u0001\t\u0005\t\u00a3"+
"\b\t\n\t\f\t\u00a6\t\t\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n"+
"\u0001\n\u0005\n\u00af\b\n\n\n\f\n\u00b2\t\n\u0001\u000b\u0001\u000b\u0001"+
"\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0005"+
"\u000b\u00bc\b\u000b\n\u000b\f\u000b\u00bf\t\u000b\u0001\f\u0003\f\u00c2"+
"\b\f\u0001\f\u0001\f\u0001\f\u0003\f\u00c7\b\f\u0001\f\u0001\f\u0001\f"+
"\u0001\f\u0001\f\u0001\f\u0003\f\u00cf\b\f\u0001\f\u0000\u0003\b\n\u000e"+
"\r\u0000\u0002\u0004\u0006\b\n\f\u000e\u0010\u0012\u0014\u0016\u0018\u0000"+
"\u0003\u0001\u0000\u0001\u0007\u0001\u0000\u0017\u0019\u0002\u0000\u0012"+
"\u0012\u0016\u0016\u00eb\u0000\u001a\u0001\u0000\u0000\u0000\u0002\u001d"+
"\u0001\u0000\u0000\u0000\u0004%\u0001\u0000\u0000\u0000\u0006-\u0001\u0000"+
"\u0000\u0000\b5\u0001\u0000\u0000\u0000\n@\u0001\u0000\u0000\u0000\f["+
"\u0001\u0000\u0000\u0000\u000e]\u0001\u0000\u0000\u0000\u0010\u009d\u0001"+
"\u0000\u0000\u0000\u0012\u009f\u0001\u0000\u0000\u0000\u0014\u00a7\u0001"+
"\u0000\u0000\u0000\u0016\u00b3\u0001\u0000\u0000\u0000\u0018\u00ce\u0001"+
"\u0000\u0000\u0000\u001a\u001b\u0003\u0002\u0001\u0000\u001b\u001c\u0005"+
"\u0000\u0000\u0001\u001c\u0001\u0001\u0000\u0000\u0000\u001d#\u0003\u0004"+
"\u0002\u0000\u001e\u001f\u0005\u0014\u0000\u0000\u001f \u0003\u0004\u0002"+
"\u0000 !\u0005\u0015\u0000\u0000!\"\u0003\u0002\u0001\u0000\"$\u0001\u0000"+
"\u0000\u0000#\u001e\u0001\u0000\u0000\u0000#$\u0001\u0000\u0000\u0000"+
"$\u0003\u0001\u0000\u0000\u0000%*\u0003\u0006\u0003\u0000&\'\u0005\t\u0000"+
"\u0000\')\u0003\u0006\u0003\u0000(&\u0001\u0000\u0000\u0000),\u0001\u0000"+
"\u0000\u0000*(\u0001\u0000\u0000\u0000*+\u0001\u0000\u0000\u0000+\u0005"+
"\u0001\u0000\u0000\u0000,*\u0001\u0000\u0000\u0000-2\u0003\b\u0004\u0000"+
"./\u0005\b\u0000\u0000/1\u0003\b\u0004\u00000.\u0001\u0000\u0000\u0000"+
"14\u0001\u0000\u0000\u000020\u0001\u0000\u0000\u000023\u0001\u0000\u0000"+
"\u00003\u0007\u0001\u0000\u0000\u000042\u0001\u0000\u0000\u000056\u0006"+
"\u0004\uffff\uffff\u000067\u0003\n\u0005\u00007=\u0001\u0000\u0000\u0000"+
"89\n\u0001\u0000\u00009:\u0007\u0000\u0000\u0000:<\u0003\b\u0004\u0002"+
";8\u0001\u0000\u0000\u0000\u0001\u0000\u0000\u0000>\t\u0001\u0000\u0000\u0000?=\u0001\u0000"+
"\u0000\u0000@A\u0006\u0005\uffff\uffff\u0000AB\u0003\f\u0006\u0000BK\u0001"+
"\u0000\u0000\u0000CD\n\u0002\u0000\u0000DE\u0007\u0001\u0000\u0000EJ\u0003"+
"\n\u0005\u0003FG\n\u0001\u0000\u0000GH\u0007\u0002\u0000\u0000HJ\u0003"+
"\n\u0005\u0002IC\u0001\u0000\u0000\u0000IF\u0001\u0000\u0000\u0000JM\u0001"+
"\u0000\u0000\u0000KI\u0001\u0000\u0000\u0000KL\u0001\u0000\u0000\u0000"+
"L\u000b\u0001\u0000\u0000\u0000MK\u0001\u0000\u0000\u0000N\\\u0003\u000e"+
"\u0007\u0000OQ\u0005\u0013\u0000\u0000PO\u0001\u0000\u0000\u0000QR\u0001"+
"\u0000\u0000\u0000RP\u0001\u0000\u0000\u0000RS\u0001\u0000\u0000\u0000"+
"ST\u0001\u0000\u0000\u0000T\\\u0003\u000e\u0007\u0000UW\u0005\u0012\u0000"+
"\u0000VU\u0001\u0000\u0000\u0000WX\u0001\u0000\u0000\u0000XV\u0001\u0000"+
"\u0000\u0000XY\u0001\u0000\u0000\u0000YZ\u0001\u0000\u0000\u0000Z\\\u0003"+
"\u000e\u0007\u0000[N\u0001\u0000\u0000\u0000[P\u0001\u0000\u0000\u0000"+
"[V\u0001\u0000\u0000\u0000\\\r\u0001\u0000\u0000\u0000]^\u0006\u0007\uffff"+
"\uffff\u0000^_\u0003\u0010\b\u0000_z\u0001\u0000\u0000\u0000`a\n\u0003"+
"\u0000\u0000ab\u0005\u0010\u0000\u0000bh\u0005$\u0000\u0000ce\u0005\u000e"+
"\u0000\u0000df\u0003\u0012\t\u0000ed\u0001\u0000\u0000\u0000ef\u0001\u0000"+
"\u0000\u0000fg\u0001\u0000\u0000\u0000gi\u0005\u000f\u0000\u0000hc\u0001"+
"\u0000\u0000\u0000hi\u0001\u0000\u0000\u0000iy\u0001\u0000\u0000\u0000"+
"jk\n\u0002\u0000\u0000kl\u0005\n\u0000\u0000lm\u0003\u0002\u0001\u0000"+
"mn\u0005\u000b\u0000\u0000ny\u0001\u0000\u0000\u0000op\n\u0001\u0000\u0000"+
"pr\u0005\f\u0000\u0000qs\u0003\u0014\n\u0000rq\u0001\u0000\u0000\u0000"+
"rs\u0001\u0000\u0000\u0000su\u0001\u0000\u0000\u0000tv\u0005\u0011\u0000"+
"\u0000ut\u0001\u0000\u0000\u0000uv\u0001\u0000\u0000\u0000vw\u0001\u0000"+
"\u0000\u0000wy\u0005\r\u0000\u0000x`\u0001\u0000\u0000\u0000xj\u0001\u0000"+
"\u0000\u0000xo\u0001\u0000\u0000\u0000y|\u0001\u0000\u0000\u0000zx\u0001"+
"\u0000\u0000\u0000z{\u0001\u0000\u0000\u0000{\u000f\u0001\u0000\u0000"+
"\u0000|z\u0001\u0000\u0000\u0000}\u007f\u0005\u0010\u0000\u0000~}\u0001"+
"\u0000\u0000\u0000~\u007f\u0001\u0000\u0000\u0000\u007f\u0080\u0001\u0000"+
"\u0000\u0000\u0080\u0086\u0005$\u0000\u0000\u0081\u0083\u0005\u000e\u0000"+
"\u0000\u0082\u0084\u0003\u0012\t\u0000\u0083\u0082\u0001\u0000\u0000\u0000"+
"\u0083\u0084\u0001\u0000\u0000\u0000\u0084\u0085\u0001\u0000\u0000\u0000"+
"\u0085\u0087\u0005\u000f\u0000\u0000\u0086\u0081\u0001\u0000\u0000\u0000"+
"\u0086\u0087\u0001\u0000\u0000\u0000\u0087\u009e\u0001\u0000\u0000\u0000"+
"\u0088\u0089\u0005\u000e\u0000\u0000\u0089\u008a\u0003\u0002\u0001\u0000"+
"\u008a\u008b\u0005\u000f\u0000\u0000\u008b\u009e\u0001\u0000\u0000\u0000"+
"\u008c\u008e\u0005\n\u0000\u0000\u008d\u008f\u0003\u0012\t\u0000\u008e"+
"\u008d\u0001\u0000\u0000\u0000\u008e\u008f\u0001\u0000\u0000\u0000\u008f"+
"\u0091\u0001\u0000\u0000\u0000\u0090\u0092\u0005\u0011\u0000\u0000\u0091"+
"\u0090\u0001\u0000\u0000\u0000\u0091\u0092\u0001\u0000\u0000\u0000\u0092"+
"\u0093\u0001\u0000\u0000\u0000\u0093\u009e\u0005\u000b\u0000\u0000\u0094"+
"\u0096\u0005\f\u0000\u0000\u0095\u0097\u0003\u0016\u000b\u0000\u0096\u0095"+
"\u0001\u0000\u0000\u0000\u0096\u0097\u0001\u0000\u0000\u0000\u0097\u0099"+
"\u0001\u0000\u0000\u0000\u0098\u009a\u0005\u0011\u0000\u0000\u0099\u0098"+
"\u0001\u0000\u0000\u0000\u0099\u009a\u0001\u0000\u0000\u0000\u009a\u009b"+
"\u0001\u0000\u0000\u0000\u009b\u009e\u0005\r\u0000\u0000\u009c\u009e\u0003"+
"\u0018\f\u0000\u009d~\u0001\u0000\u0000\u0000\u009d\u0088\u0001\u0000"+
"\u0000\u0000\u009d\u008c\u0001\u0000\u0000\u0000\u009d\u0094\u0001\u0000"+
"\u0000\u0000\u009d\u009c\u0001\u0000\u0000\u0000\u009e\u0011\u0001\u0000"+
"\u0000\u0000\u009f\u00a4\u0003\u0002\u0001\u0000\u00a0\u00a1\u0005\u0011"+
"\u0000\u0000\u00a1\u00a3\u0003\u0002\u0001\u0000\u00a2\u00a0\u0001\u0000"+
"\u0000\u0000\u00a3\u00a6\u0001\u0000\u0000\u0000\u00a4\u00a2\u0001\u0000"+
"\u0000\u0000\u00a4\u00a5\u0001\u0000\u0000\u0000\u00a5\u0013\u0001\u0000"+
"\u0000\u0000\u00a6\u00a4\u0001\u0000\u0000\u0000\u00a7\u00a8\u0005$\u0000"+
"\u0000\u00a8\u00a9\u0005\u0015\u0000\u0000\u00a9\u00b0\u0003\u0002\u0001"+
"\u0000\u00aa\u00ab\u0005\u0011\u0000\u0000\u00ab\u00ac\u0005$\u0000\u0000"+
"\u00ac\u00ad\u0005\u0015\u0000\u0000\u00ad\u00af\u0003\u0002\u0001\u0000"+
"\u00ae\u00aa\u0001\u0000\u0000\u0000\u00af\u00b2\u0001\u0000\u0000\u0000"+
"\u00b0\u00ae\u0001\u0000\u0000\u0000\u00b0\u00b1\u0001\u0000\u0000\u0000"+
"\u00b1\u0015\u0001\u0000\u0000\u0000\u00b2\u00b0\u0001\u0000\u0000\u0000"+
"\u00b3\u00b4\u0003\u0002\u0001\u0000\u00b4\u00b5\u0005\u0015\u0000\u0000"+
"\u00b5\u00bd\u0003\u0002\u0001\u0000\u00b6\u00b7\u0005\u0011\u0000\u0000"+
"\u00b7\u00b8\u0003\u0002\u0001\u0000\u00b8\u00b9\u0005\u0015\u0000\u0000"+
"\u00b9\u00ba\u0003\u0002\u0001\u0000\u00ba\u00bc\u0001\u0000\u0000\u0000"+
"\u00bb\u00b6\u0001\u0000\u0000\u0000\u00bc\u00bf\u0001\u0000\u0000\u0000"+
"\u00bd\u00bb\u0001\u0000\u0000\u0000\u00bd\u00be\u0001\u0000\u0000\u0000"+
"\u00be\u0017\u0001\u0000\u0000\u0000\u00bf\u00bd\u0001\u0000\u0000\u0000"+
"\u00c0\u00c2\u0005\u0012\u0000\u0000\u00c1\u00c0\u0001\u0000\u0000\u0000"+
"\u00c1\u00c2\u0001\u0000\u0000\u0000\u00c2\u00c3\u0001\u0000\u0000\u0000"+
"\u00c3\u00cf\u0005 \u0000\u0000\u00c4\u00cf\u0005!\u0000\u0000\u00c5\u00c7"+
"\u0005\u0012\u0000\u0000\u00c6\u00c5\u0001\u0000\u0000\u0000\u00c6\u00c7"+
"\u0001\u0000\u0000\u0000\u00c7\u00c8\u0001\u0000\u0000\u0000\u00c8\u00cf"+
"\u0005\u001f\u0000\u0000\u00c9\u00cf\u0005\"\u0000\u0000\u00ca\u00cf\u0005"+
"#\u0000\u0000\u00cb\u00cf\u0005\u001a\u0000\u0000\u00cc\u00cf\u0005\u001b"+
"\u0000\u0000\u00cd\u00cf\u0005\u001c\u0000\u0000\u00ce\u00c1\u0001\u0000"+
"\u0000\u0000\u00ce\u00c4\u0001\u0000\u0000\u0000\u00ce\u00c6\u0001\u0000"+
"\u0000\u0000\u00ce\u00c9\u0001\u0000\u0000\u0000\u00ce\u00ca\u0001\u0000"+
"\u0000\u0000\u00ce\u00cb\u0001\u0000\u0000\u0000\u00ce\u00cc\u0001\u0000"+
"\u0000\u0000\u00ce\u00cd\u0001\u0000\u0000\u0000\u00cf\u0019\u0001\u0000"+
"\u0000\u0000\u001d#*2=IKRX[ehruxz~\u0083\u0086\u008e\u0091\u0096\u0099"+
"\u009d\u00a4\u00b0\u00bd\u00c1\u00c6\u00ce";
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);
}
}
}
