io.trino.plugin.deltalake.expression.SparkExpressionBaseParser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of trino-delta-lake Show documentation
Show all versions of trino-delta-lake Show documentation
Trino - Delta Lake connector
// Generated from io/trino/plugin/deltalake/expression/SparkExpressionBase.g4 by ANTLR 4.13.1
package io.trino.plugin.deltalake.expression;
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"})
public class SparkExpressionBaseParser extends Parser {
static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
AND=1, BETWEEN=2, OR=3, FALSE=4, TRUE=5, NULL=6, EQ=7, NEQ=8, LT=9, LTE=10,
GT=11, GTE=12, NOT=13, PLUS=14, MINUS=15, ASTERISK=16, SLASH=17, PERCENT=18,
AMPERSAND=19, CIRCUMFLEX=20, STRING=21, INTEGER_VALUE=22, IDENTIFIER=23,
BACKQUOTED_IDENTIFIER=24, WS=25, DELIMITER=26;
public static final int
RULE_standaloneExpression = 0, RULE_expression = 1, RULE_booleanExpression = 2,
RULE_predicate = 3, RULE_valueExpression = 4, RULE_primaryExpression = 5,
RULE_string = 6, RULE_comparisonOperator = 7, RULE_booleanValue = 8, RULE_identifier = 9,
RULE_number = 10;
private static String[] makeRuleNames() {
return new String[] {
"standaloneExpression", "expression", "booleanExpression", "predicate",
"valueExpression", "primaryExpression", "string", "comparisonOperator",
"booleanValue", "identifier", "number"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, "'AND'", "'BETWEEN'", "'OR'", "'FALSE'", "'TRUE'", "'NULL'", "'='",
null, "'<'", "'<='", "'>'", "'>='", "'NOT'", "'+'", "'-'", "'*'", "'/'",
"'%'", "'&'", "'^'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, "AND", "BETWEEN", "OR", "FALSE", "TRUE", "NULL", "EQ", "NEQ", "LT",
"LTE", "GT", "GTE", "NOT", "PLUS", "MINUS", "ASTERISK", "SLASH", "PERCENT",
"AMPERSAND", "CIRCUMFLEX", "STRING", "INTEGER_VALUE", "IDENTIFIER", "BACKQUOTED_IDENTIFIER",
"WS", "DELIMITER"
};
}
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 "SparkExpressionBase.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public SparkExpressionBaseParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
@SuppressWarnings("CheckReturnValue")
public static class StandaloneExpressionContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode EOF() { return getToken(SparkExpressionBaseParser.EOF, 0); }
public StandaloneExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_standaloneExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).enterStandaloneExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).exitStandaloneExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SparkExpressionBaseVisitor ) return ((SparkExpressionBaseVisitor)visitor).visitStandaloneExpression(this);
else return visitor.visitChildren(this);
}
}
public final StandaloneExpressionContext standaloneExpression() throws RecognitionException {
StandaloneExpressionContext _localctx = new StandaloneExpressionContext(_ctx, getState());
enterRule(_localctx, 0, RULE_standaloneExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(22);
expression();
setState(23);
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 ExpressionContext extends ParserRuleContext {
public BooleanExpressionContext booleanExpression() {
return getRuleContext(BooleanExpressionContext.class,0);
}
public ExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).enterExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).exitExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SparkExpressionBaseVisitor ) return ((SparkExpressionBaseVisitor)visitor).visitExpression(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionContext expression() throws RecognitionException {
ExpressionContext _localctx = new ExpressionContext(_ctx, getState());
enterRule(_localctx, 2, RULE_expression);
try {
enterOuterAlt(_localctx, 1);
{
setState(25);
booleanExpression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class BooleanExpressionContext extends ParserRuleContext {
public BooleanExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_booleanExpression; }
public BooleanExpressionContext() { }
public void copyFrom(BooleanExpressionContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PredicatedContext extends BooleanExpressionContext {
public ValueExpressionContext valueExpression;
public ValueExpressionContext valueExpression() {
return getRuleContext(ValueExpressionContext.class,0);
}
public PredicateContext predicate() {
return getRuleContext(PredicateContext.class,0);
}
public PredicatedContext(BooleanExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).enterPredicated(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).exitPredicated(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SparkExpressionBaseVisitor ) return ((SparkExpressionBaseVisitor)visitor).visitPredicated(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class OrContext extends BooleanExpressionContext {
public BooleanExpressionContext left;
public BooleanExpressionContext right;
public TerminalNode OR() { return getToken(SparkExpressionBaseParser.OR, 0); }
public List booleanExpression() {
return getRuleContexts(BooleanExpressionContext.class);
}
public BooleanExpressionContext booleanExpression(int i) {
return getRuleContext(BooleanExpressionContext.class,i);
}
public OrContext(BooleanExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).enterOr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).exitOr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SparkExpressionBaseVisitor ) return ((SparkExpressionBaseVisitor)visitor).visitOr(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class AndContext extends BooleanExpressionContext {
public BooleanExpressionContext left;
public BooleanExpressionContext right;
public TerminalNode AND() { return getToken(SparkExpressionBaseParser.AND, 0); }
public List booleanExpression() {
return getRuleContexts(BooleanExpressionContext.class);
}
public BooleanExpressionContext booleanExpression(int i) {
return getRuleContext(BooleanExpressionContext.class,i);
}
public AndContext(BooleanExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).enterAnd(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).exitAnd(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SparkExpressionBaseVisitor ) return ((SparkExpressionBaseVisitor)visitor).visitAnd(this);
else return visitor.visitChildren(this);
}
}
public final BooleanExpressionContext booleanExpression() throws RecognitionException {
return booleanExpression(0);
}
private BooleanExpressionContext booleanExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
BooleanExpressionContext _localctx = new BooleanExpressionContext(_ctx, _parentState);
BooleanExpressionContext _prevctx = _localctx;
int _startState = 4;
enterRecursionRule(_localctx, 4, RULE_booleanExpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
_localctx = new PredicatedContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(28);
((PredicatedContext)_localctx).valueExpression = valueExpression(0);
setState(30);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
case 1:
{
setState(29);
predicate(((PredicatedContext)_localctx).valueExpression);
}
break;
}
}
_ctx.stop = _input.LT(-1);
setState(40);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,2,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(38);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) {
case 1:
{
_localctx = new AndContext(new BooleanExpressionContext(_parentctx, _parentState));
((AndContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_booleanExpression);
setState(32);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(33);
match(AND);
setState(34);
((AndContext)_localctx).right = booleanExpression(3);
}
break;
case 2:
{
_localctx = new OrContext(new BooleanExpressionContext(_parentctx, _parentState));
((OrContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_booleanExpression);
setState(35);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(36);
match(OR);
setState(37);
((OrContext)_localctx).right = booleanExpression(2);
}
break;
}
}
}
setState(42);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,2,_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 PredicateContext extends ParserRuleContext {
public ParserRuleContext value;
public PredicateContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
public PredicateContext(ParserRuleContext parent, int invokingState, ParserRuleContext value) {
super(parent, invokingState);
this.value = value;
}
@Override public int getRuleIndex() { return RULE_predicate; }
public PredicateContext() { }
public void copyFrom(PredicateContext ctx) {
super.copyFrom(ctx);
this.value = ctx.value;
}
}
@SuppressWarnings("CheckReturnValue")
public static class ComparisonContext extends PredicateContext {
public ValueExpressionContext right;
public ComparisonOperatorContext comparisonOperator() {
return getRuleContext(ComparisonOperatorContext.class,0);
}
public ValueExpressionContext valueExpression() {
return getRuleContext(ValueExpressionContext.class,0);
}
public ComparisonContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).enterComparison(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).exitComparison(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SparkExpressionBaseVisitor ) return ((SparkExpressionBaseVisitor)visitor).visitComparison(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class BetweenContext extends PredicateContext {
public ValueExpressionContext lower;
public ValueExpressionContext upper;
public TerminalNode BETWEEN() { return getToken(SparkExpressionBaseParser.BETWEEN, 0); }
public TerminalNode AND() { return getToken(SparkExpressionBaseParser.AND, 0); }
public List valueExpression() {
return getRuleContexts(ValueExpressionContext.class);
}
public ValueExpressionContext valueExpression(int i) {
return getRuleContext(ValueExpressionContext.class,i);
}
public TerminalNode NOT() { return getToken(SparkExpressionBaseParser.NOT, 0); }
public BetweenContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).enterBetween(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).exitBetween(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SparkExpressionBaseVisitor ) return ((SparkExpressionBaseVisitor)visitor).visitBetween(this);
else return visitor.visitChildren(this);
}
}
public final PredicateContext predicate(ParserRuleContext value) throws RecognitionException {
PredicateContext _localctx = new PredicateContext(_ctx, getState(), value);
enterRule(_localctx, 6, RULE_predicate);
int _la;
try {
setState(54);
_errHandler.sync(this);
switch (_input.LA(1)) {
case EQ:
case NEQ:
case LT:
case LTE:
case GT:
case GTE:
_localctx = new ComparisonContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(43);
comparisonOperator();
setState(44);
((ComparisonContext)_localctx).right = valueExpression(0);
}
break;
case BETWEEN:
case NOT:
_localctx = new BetweenContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(47);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(46);
match(NOT);
}
}
setState(49);
match(BETWEEN);
setState(50);
((BetweenContext)_localctx).lower = valueExpression(0);
setState(51);
match(AND);
setState(52);
((BetweenContext)_localctx).upper = valueExpression(0);
}
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 ValueExpressionContext extends ParserRuleContext {
public ValueExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_valueExpression; }
public ValueExpressionContext() { }
public void copyFrom(ValueExpressionContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ValueExpressionDefaultContext extends ValueExpressionContext {
public PrimaryExpressionContext primaryExpression() {
return getRuleContext(PrimaryExpressionContext.class,0);
}
public ValueExpressionDefaultContext(ValueExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).enterValueExpressionDefault(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).exitValueExpressionDefault(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SparkExpressionBaseVisitor ) return ((SparkExpressionBaseVisitor)visitor).visitValueExpressionDefault(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ArithmeticBinaryContext extends ValueExpressionContext {
public ValueExpressionContext left;
public Token operator;
public ValueExpressionContext right;
public List valueExpression() {
return getRuleContexts(ValueExpressionContext.class);
}
public ValueExpressionContext valueExpression(int i) {
return getRuleContext(ValueExpressionContext.class,i);
}
public TerminalNode ASTERISK() { return getToken(SparkExpressionBaseParser.ASTERISK, 0); }
public TerminalNode SLASH() { return getToken(SparkExpressionBaseParser.SLASH, 0); }
public TerminalNode PERCENT() { return getToken(SparkExpressionBaseParser.PERCENT, 0); }
public TerminalNode PLUS() { return getToken(SparkExpressionBaseParser.PLUS, 0); }
public TerminalNode MINUS() { return getToken(SparkExpressionBaseParser.MINUS, 0); }
public TerminalNode AMPERSAND() { return getToken(SparkExpressionBaseParser.AMPERSAND, 0); }
public TerminalNode CIRCUMFLEX() { return getToken(SparkExpressionBaseParser.CIRCUMFLEX, 0); }
public ArithmeticBinaryContext(ValueExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).enterArithmeticBinary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).exitArithmeticBinary(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SparkExpressionBaseVisitor ) return ((SparkExpressionBaseVisitor)visitor).visitArithmeticBinary(this);
else return visitor.visitChildren(this);
}
}
public final ValueExpressionContext valueExpression() throws RecognitionException {
return valueExpression(0);
}
private ValueExpressionContext valueExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ValueExpressionContext _localctx = new ValueExpressionContext(_ctx, _parentState);
ValueExpressionContext _prevctx = _localctx;
int _startState = 8;
enterRecursionRule(_localctx, 8, RULE_valueExpression, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
_localctx = new ValueExpressionDefaultContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(57);
primaryExpression();
}
_ctx.stop = _input.LT(-1);
setState(70);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,6,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(68);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
case 1:
{
_localctx = new ArithmeticBinaryContext(new ValueExpressionContext(_parentctx, _parentState));
((ArithmeticBinaryContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_valueExpression);
setState(59);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(60);
((ArithmeticBinaryContext)_localctx).operator = _input.LT(1);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 458752L) != 0)) ) {
((ArithmeticBinaryContext)_localctx).operator = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(61);
((ArithmeticBinaryContext)_localctx).right = valueExpression(4);
}
break;
case 2:
{
_localctx = new ArithmeticBinaryContext(new ValueExpressionContext(_parentctx, _parentState));
((ArithmeticBinaryContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_valueExpression);
setState(62);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(63);
((ArithmeticBinaryContext)_localctx).operator = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==PLUS || _la==MINUS) ) {
((ArithmeticBinaryContext)_localctx).operator = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(64);
((ArithmeticBinaryContext)_localctx).right = valueExpression(3);
}
break;
case 3:
{
_localctx = new ArithmeticBinaryContext(new ValueExpressionContext(_parentctx, _parentState));
((ArithmeticBinaryContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_valueExpression);
setState(65);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(66);
((ArithmeticBinaryContext)_localctx).operator = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==AMPERSAND || _la==CIRCUMFLEX) ) {
((ArithmeticBinaryContext)_localctx).operator = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(67);
((ArithmeticBinaryContext)_localctx).right = valueExpression(2);
}
break;
}
}
}
setState(72);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,6,_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 PrimaryExpressionContext extends ParserRuleContext {
public PrimaryExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primaryExpression; }
public PrimaryExpressionContext() { }
public void copyFrom(PrimaryExpressionContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ColumnReferenceContext extends PrimaryExpressionContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ColumnReferenceContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).enterColumnReference(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).exitColumnReference(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SparkExpressionBaseVisitor ) return ((SparkExpressionBaseVisitor)visitor).visitColumnReference(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class NullLiteralContext extends PrimaryExpressionContext {
public TerminalNode NULL() { return getToken(SparkExpressionBaseParser.NULL, 0); }
public NullLiteralContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).enterNullLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).exitNullLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SparkExpressionBaseVisitor ) return ((SparkExpressionBaseVisitor)visitor).visitNullLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class StringLiteralContext extends PrimaryExpressionContext {
public StringContext string() {
return getRuleContext(StringContext.class,0);
}
public StringLiteralContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).enterStringLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).exitStringLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SparkExpressionBaseVisitor ) return ((SparkExpressionBaseVisitor)visitor).visitStringLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class NumericLiteralContext extends PrimaryExpressionContext {
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public NumericLiteralContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).enterNumericLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).exitNumericLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SparkExpressionBaseVisitor ) return ((SparkExpressionBaseVisitor)visitor).visitNumericLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class BooleanLiteralContext extends PrimaryExpressionContext {
public BooleanValueContext booleanValue() {
return getRuleContext(BooleanValueContext.class,0);
}
public BooleanLiteralContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).enterBooleanLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).exitBooleanLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SparkExpressionBaseVisitor ) return ((SparkExpressionBaseVisitor)visitor).visitBooleanLiteral(this);
else return visitor.visitChildren(this);
}
}
public final PrimaryExpressionContext primaryExpression() throws RecognitionException {
PrimaryExpressionContext _localctx = new PrimaryExpressionContext(_ctx, getState());
enterRule(_localctx, 10, RULE_primaryExpression);
try {
setState(78);
_errHandler.sync(this);
switch (_input.LA(1)) {
case MINUS:
case INTEGER_VALUE:
_localctx = new NumericLiteralContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(73);
number();
}
break;
case FALSE:
case TRUE:
_localctx = new BooleanLiteralContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(74);
booleanValue();
}
break;
case NULL:
_localctx = new NullLiteralContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(75);
match(NULL);
}
break;
case STRING:
_localctx = new StringLiteralContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(76);
string();
}
break;
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
_localctx = new ColumnReferenceContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(77);
identifier();
}
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 StringContext extends ParserRuleContext {
public StringContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_string; }
public StringContext() { }
public void copyFrom(StringContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class UnicodeStringLiteralContext extends StringContext {
public TerminalNode STRING() { return getToken(SparkExpressionBaseParser.STRING, 0); }
public UnicodeStringLiteralContext(StringContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).enterUnicodeStringLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).exitUnicodeStringLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SparkExpressionBaseVisitor ) return ((SparkExpressionBaseVisitor)visitor).visitUnicodeStringLiteral(this);
else return visitor.visitChildren(this);
}
}
public final StringContext string() throws RecognitionException {
StringContext _localctx = new StringContext(_ctx, getState());
enterRule(_localctx, 12, RULE_string);
try {
_localctx = new UnicodeStringLiteralContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(80);
match(STRING);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ComparisonOperatorContext extends ParserRuleContext {
public TerminalNode EQ() { return getToken(SparkExpressionBaseParser.EQ, 0); }
public TerminalNode NEQ() { return getToken(SparkExpressionBaseParser.NEQ, 0); }
public TerminalNode LT() { return getToken(SparkExpressionBaseParser.LT, 0); }
public TerminalNode LTE() { return getToken(SparkExpressionBaseParser.LTE, 0); }
public TerminalNode GT() { return getToken(SparkExpressionBaseParser.GT, 0); }
public TerminalNode GTE() { return getToken(SparkExpressionBaseParser.GTE, 0); }
public ComparisonOperatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_comparisonOperator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).enterComparisonOperator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).exitComparisonOperator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SparkExpressionBaseVisitor ) return ((SparkExpressionBaseVisitor)visitor).visitComparisonOperator(this);
else return visitor.visitChildren(this);
}
}
public final ComparisonOperatorContext comparisonOperator() throws RecognitionException {
ComparisonOperatorContext _localctx = new ComparisonOperatorContext(_ctx, getState());
enterRule(_localctx, 14, RULE_comparisonOperator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(82);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 8064L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class BooleanValueContext extends ParserRuleContext {
public TerminalNode TRUE() { return getToken(SparkExpressionBaseParser.TRUE, 0); }
public TerminalNode FALSE() { return getToken(SparkExpressionBaseParser.FALSE, 0); }
public BooleanValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_booleanValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).enterBooleanValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).exitBooleanValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SparkExpressionBaseVisitor ) return ((SparkExpressionBaseVisitor)visitor).visitBooleanValue(this);
else return visitor.visitChildren(this);
}
}
public final BooleanValueContext booleanValue() throws RecognitionException {
BooleanValueContext _localctx = new BooleanValueContext(_ctx, getState());
enterRule(_localctx, 16, RULE_booleanValue);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(84);
_la = _input.LA(1);
if ( !(_la==FALSE || _la==TRUE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IdentifierContext extends ParserRuleContext {
public IdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifier; }
public IdentifierContext() { }
public void copyFrom(IdentifierContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class BackQuotedIdentifierContext extends IdentifierContext {
public TerminalNode BACKQUOTED_IDENTIFIER() { return getToken(SparkExpressionBaseParser.BACKQUOTED_IDENTIFIER, 0); }
public BackQuotedIdentifierContext(IdentifierContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).enterBackQuotedIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).exitBackQuotedIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SparkExpressionBaseVisitor ) return ((SparkExpressionBaseVisitor)visitor).visitBackQuotedIdentifier(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class UnquotedIdentifierContext extends IdentifierContext {
public TerminalNode IDENTIFIER() { return getToken(SparkExpressionBaseParser.IDENTIFIER, 0); }
public UnquotedIdentifierContext(IdentifierContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).enterUnquotedIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).exitUnquotedIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SparkExpressionBaseVisitor ) return ((SparkExpressionBaseVisitor)visitor).visitUnquotedIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final IdentifierContext identifier() throws RecognitionException {
IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
enterRule(_localctx, 18, RULE_identifier);
try {
setState(88);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IDENTIFIER:
_localctx = new UnquotedIdentifierContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(86);
match(IDENTIFIER);
}
break;
case BACKQUOTED_IDENTIFIER:
_localctx = new BackQuotedIdentifierContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(87);
match(BACKQUOTED_IDENTIFIER);
}
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 NumberContext extends ParserRuleContext {
public NumberContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_number; }
public NumberContext() { }
public void copyFrom(NumberContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class IntegerLiteralContext extends NumberContext {
public TerminalNode INTEGER_VALUE() { return getToken(SparkExpressionBaseParser.INTEGER_VALUE, 0); }
public TerminalNode MINUS() { return getToken(SparkExpressionBaseParser.MINUS, 0); }
public IntegerLiteralContext(NumberContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).enterIntegerLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SparkExpressionBaseListener ) ((SparkExpressionBaseListener)listener).exitIntegerLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SparkExpressionBaseVisitor ) return ((SparkExpressionBaseVisitor)visitor).visitIntegerLiteral(this);
else return visitor.visitChildren(this);
}
}
public final NumberContext number() throws RecognitionException {
NumberContext _localctx = new NumberContext(_ctx, getState());
enterRule(_localctx, 20, RULE_number);
int _la;
try {
_localctx = new IntegerLiteralContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(91);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(90);
match(MINUS);
}
}
setState(93);
match(INTEGER_VALUE);
}
}
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 2:
return booleanExpression_sempred((BooleanExpressionContext)_localctx, predIndex);
case 4:
return valueExpression_sempred((ValueExpressionContext)_localctx, predIndex);
}
return true;
}
private boolean booleanExpression_sempred(BooleanExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return precpred(_ctx, 2);
case 1:
return precpred(_ctx, 1);
}
return true;
}
private boolean valueExpression_sempred(ValueExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 2:
return precpred(_ctx, 3);
case 3:
return precpred(_ctx, 2);
case 4:
return precpred(_ctx, 1);
}
return true;
}
public static final String _serializedATN =
"\u0004\u0001\u001a`\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\u0001\u0000\u0001\u0000\u0001"+
"\u0000\u0001\u0001\u0001\u0001\u0001\u0002\u0001\u0002\u0001\u0002\u0003"+
"\u0002\u001f\b\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001"+
"\u0002\u0001\u0002\u0005\u0002\'\b\u0002\n\u0002\f\u0002*\t\u0002\u0001"+
"\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0003\u00030\b\u0003\u0001"+
"\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0003\u00037\b"+
"\u0003\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001"+
"\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001"+
"\u0004\u0005\u0004E\b\u0004\n\u0004\f\u0004H\t\u0004\u0001\u0005\u0001"+
"\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0003\u0005O\b\u0005\u0001"+
"\u0006\u0001\u0006\u0001\u0007\u0001\u0007\u0001\b\u0001\b\u0001\t\u0001"+
"\t\u0003\tY\b\t\u0001\n\u0003\n\\\b\n\u0001\n\u0001\n\u0001\n\u0000\u0002"+
"\u0004\b\u000b\u0000\u0002\u0004\u0006\b\n\f\u000e\u0010\u0012\u0014\u0000"+
"\u0005\u0001\u0000\u0010\u0012\u0001\u0000\u000e\u000f\u0001\u0000\u0013"+
"\u0014\u0001\u0000\u0007\f\u0001\u0000\u0004\u0005b\u0000\u0016\u0001"+
"\u0000\u0000\u0000\u0002\u0019\u0001\u0000\u0000\u0000\u0004\u001b\u0001"+
"\u0000\u0000\u0000\u00066\u0001\u0000\u0000\u0000\b8\u0001\u0000\u0000"+
"\u0000\nN\u0001\u0000\u0000\u0000\fP\u0001\u0000\u0000\u0000\u000eR\u0001"+
"\u0000\u0000\u0000\u0010T\u0001\u0000\u0000\u0000\u0012X\u0001\u0000\u0000"+
"\u0000\u0014[\u0001\u0000\u0000\u0000\u0016\u0017\u0003\u0002\u0001\u0000"+
"\u0017\u0018\u0005\u0000\u0000\u0001\u0018\u0001\u0001\u0000\u0000\u0000"+
"\u0019\u001a\u0003\u0004\u0002\u0000\u001a\u0003\u0001\u0000\u0000\u0000"+
"\u001b\u001c\u0006\u0002\uffff\uffff\u0000\u001c\u001e\u0003\b\u0004\u0000"+
"\u001d\u001f\u0003\u0006\u0003\u0000\u001e\u001d\u0001\u0000\u0000\u0000"+
"\u001e\u001f\u0001\u0000\u0000\u0000\u001f(\u0001\u0000\u0000\u0000 !"+
"\n\u0002\u0000\u0000!\"\u0005\u0001\u0000\u0000\"\'\u0003\u0004\u0002"+
"\u0003#$\n\u0001\u0000\u0000$%\u0005\u0003\u0000\u0000%\'\u0003\u0004"+
"\u0002\u0002& \u0001\u0000\u0000\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+,\u0003\u000e"+
"\u0007\u0000,-\u0003\b\u0004\u0000-7\u0001\u0000\u0000\u0000.0\u0005\r"+
"\u0000\u0000/.\u0001\u0000\u0000\u0000/0\u0001\u0000\u0000\u000001\u0001"+
"\u0000\u0000\u000012\u0005\u0002\u0000\u000023\u0003\b\u0004\u000034\u0005"+
"\u0001\u0000\u000045\u0003\b\u0004\u000057\u0001\u0000\u0000\u00006+\u0001"+
"\u0000\u0000\u00006/\u0001\u0000\u0000\u00007\u0007\u0001\u0000\u0000"+
"\u000089\u0006\u0004\uffff\uffff\u00009:\u0003\n\u0005\u0000:F\u0001\u0000"+
"\u0000\u0000;<\n\u0003\u0000\u0000<=\u0007\u0000\u0000\u0000=E\u0003\b"+
"\u0004\u0004>?\n\u0002\u0000\u0000?@\u0007\u0001\u0000\u0000@E\u0003\b"+
"\u0004\u0003AB\n\u0001\u0000\u0000BC\u0007\u0002\u0000\u0000CE\u0003\b"+
"\u0004\u0002D;\u0001\u0000\u0000\u0000D>\u0001\u0000\u0000\u0000DA\u0001"+
"\u0000\u0000\u0000EH\u0001\u0000\u0000\u0000FD\u0001\u0000\u0000\u0000"+
"FG\u0001\u0000\u0000\u0000G\t\u0001\u0000\u0000\u0000HF\u0001\u0000\u0000"+
"\u0000IO\u0003\u0014\n\u0000JO\u0003\u0010\b\u0000KO\u0005\u0006\u0000"+
"\u0000LO\u0003\f\u0006\u0000MO\u0003\u0012\t\u0000NI\u0001\u0000\u0000"+
"\u0000NJ\u0001\u0000\u0000\u0000NK\u0001\u0000\u0000\u0000NL\u0001\u0000"+
"\u0000\u0000NM\u0001\u0000\u0000\u0000O\u000b\u0001\u0000\u0000\u0000"+
"PQ\u0005\u0015\u0000\u0000Q\r\u0001\u0000\u0000\u0000RS\u0007\u0003\u0000"+
"\u0000S\u000f\u0001\u0000\u0000\u0000TU\u0007\u0004\u0000\u0000U\u0011"+
"\u0001\u0000\u0000\u0000VY\u0005\u0017\u0000\u0000WY\u0005\u0018\u0000"+
"\u0000XV\u0001\u0000\u0000\u0000XW\u0001\u0000\u0000\u0000Y\u0013\u0001"+
"\u0000\u0000\u0000Z\\\u0005\u000f\u0000\u0000[Z\u0001\u0000\u0000\u0000"+
"[\\\u0001\u0000\u0000\u0000\\]\u0001\u0000\u0000\u0000]^\u0005\u0016\u0000"+
"\u0000^\u0015\u0001\u0000\u0000\u0000\n\u001e&(/6DFNX[";
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);
}
}
}