.java-lib.2023-22.3.source-code.PredicateExpressionParser Maven / Gradle / Ivy
The newest version!
// Generated from PredicateExpression.g4 by ANTLR 4.7.1
package condition.parser;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class PredicateExpressionParser extends Parser {
static { RuntimeMetaData.checkVersion("4.7.1", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9,
T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17,
T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, T__23=24,
T__24=25, T__25=26, T__26=27, T__27=28, T__28=29, T__29=30, T__30=31,
T__31=32, T__32=33, T__33=34, T__34=35, T__35=36, T__36=37, T__37=38,
T__38=39, T__39=40, T__40=41, T__41=42, T__42=43, T__43=44, T__44=45,
T__45=46, T__46=47, T__47=48, T__48=49, T__49=50, T__50=51, T__51=52,
T__52=53, T__53=54, T__54=55, T__55=56, T__56=57, T__57=58, T__58=59,
T__59=60, T__60=61, T__61=62, T__62=63, T__63=64, T__64=65, T__65=66,
T__66=67, T__67=68, T__68=69, T__69=70, T__70=71, T__71=72, T__72=73,
T__73=74, T__74=75, T__75=76, T__76=77, T__77=78, T__78=79, T__79=80,
T__80=81, T__81=82, T__82=83, T__83=84, T__84=85, T__85=86, T__86=87,
T__87=88, T__88=89, T__89=90, EQ=91, MinusSign=92, PlusSign=93, UID=94,
Number=95, Identifier=96, Letters=97, Quoted=98, Literal=99, WS=100, COMMENT=101,
LINE_COMMENT=102;
public static final int
RULE_program = 0, RULE_evalExpression = 1, RULE_iff = 2, RULE_parse = 3,
RULE_time = 4, RULE_evalLength = 5, RULE_evalHashCode = 6, RULE_evalIsEmpty = 7,
RULE_evalIsNotEmpty = 8, RULE_evalIsBlank = 9, RULE_evalIsNotBlank = 10,
RULE_random = 11, RULE_propertyAccessor = 12, RULE_stringExpression = 13,
RULE_stringFunc = 14, RULE_stringEvalFunc = 15, RULE_asString = 16, RULE_strIff = 17,
RULE_strSubstring = 18, RULE_strLeft = 19, RULE_strRight = 20, RULE_strReplace = 21,
RULE_strReplaceAll = 22, RULE_strToLowerCase = 23, RULE_strToUpperCase = 24,
RULE_strLength = 25, RULE_strHashCode = 26, RULE_strIsEmpty = 27, RULE_strIsNotEmpty = 28,
RULE_strIsBlank = 29, RULE_strIsNotBlank = 30, RULE_strParse = 31, RULE_string = 32,
RULE_placeholder = 33, RULE_tagk = 34, RULE_stringComparisonOp = 35, RULE_comparisonOperator = 36,
RULE_number = 37, RULE_siSuffix = 38;
public static final String[] ruleNames = {
"program", "evalExpression", "iff", "parse", "time", "evalLength", "evalHashCode",
"evalIsEmpty", "evalIsNotEmpty", "evalIsBlank", "evalIsNotBlank", "random",
"propertyAccessor", "stringExpression", "stringFunc", "stringEvalFunc",
"asString", "strIff", "strSubstring", "strLeft", "strRight", "strReplace",
"strReplaceAll", "strToLowerCase", "strToUpperCase", "strLength", "strHashCode",
"strIsEmpty", "strIsNotEmpty", "strIsBlank", "strIsNotBlank", "strParse",
"string", "placeholder", "tagk", "stringComparisonOp", "comparisonOperator",
"number", "siSuffix"
};
private static final String[] _LITERAL_NAMES = {
null, "'('", "')'", "'?'", "':'", "'&'", "'|'", "'^'", "'<<<'", "'<<'",
"'>>>'", "'>>'", "'~'", "'*'", "'/'", "'%'", "'not'", "'NOT'", "'or'",
"'and'", "'OR'", "'AND'", "'any'", "'ANY'", "'all'", "'ALL'", "'none'",
"'NONE'", "'in'", "','", "'.'", "'$'", "'if'", "'parse'", "'time'", "'length'",
"'hashCode'", "'isEmpty'", "'isNotEmpty'", "'isBlank'", "'isNotBlank'",
"'random'", "'value'", "'timestamp'", "'startMillis'", "'duration'", "'str'",
"'substring'", "'left'", "'right'", "'replace'", "'replaceAll'", "'toLowerCase'",
"'toUpperCase'", "'{{'", "'}}'", "'equals'", "'equalsIgnoreCase'", "'startsWith'",
"'startsWithIgnoreCase'", "'contains'", "'containsIgnoreCase'", "'endsWith'",
"'endsWithIgnoreCase'", "'matches'", "'matchesIgnoreCase'", "'regexMatch'",
"'regexMatchIgnoreCase'", "'>'", "'<'", "'!'", "'Y'", "'Z'", "'E'", "'P'",
"'T'", "'G'", "'M'", "'k'", "'h'", "'da'", "'d'", "'c'", "'m'", "'\u00B5'",
"'n'", "'p'", "'f'", "'a'", "'z'", "'y'", "'='", "'-'", "'+'"
};
private static final String[] _SYMBOLIC_NAMES = {
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, "EQ", "MinusSign", "PlusSign",
"UID", "Number", "Identifier", "Letters", "Quoted", "Literal", "WS", "COMMENT",
"LINE_COMMENT"
};
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 "PredicateExpression.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public PredicateExpressionParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class ProgramContext extends ParserRuleContext {
public EvalExpressionContext evalExpression() {
return getRuleContext(EvalExpressionContext.class,0);
}
public TerminalNode EOF() { return getToken(PredicateExpressionParser.EOF, 0); }
public ProgramContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_program; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterProgram(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitProgram(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitProgram(this);
else return visitor.visitChildren(this);
}
}
public final ProgramContext program() throws RecognitionException {
ProgramContext _localctx = new ProgramContext(_ctx, getState());
enterRule(_localctx, 0, RULE_program);
try {
enterOuterAlt(_localctx, 1);
{
setState(78);
evalExpression(0);
setState(79);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EvalExpressionContext extends ParserRuleContext {
public Token complement;
public Token not;
public Token multiModifier;
public Token in;
public Token ternary;
public Token op;
public List evalExpression() {
return getRuleContexts(EvalExpressionContext.class);
}
public EvalExpressionContext evalExpression(int i) {
return getRuleContext(EvalExpressionContext.class,i);
}
public PlaceholderContext placeholder() {
return getRuleContext(PlaceholderContext.class,0);
}
public StringComparisonOpContext stringComparisonOp() {
return getRuleContext(StringComparisonOpContext.class,0);
}
public List stringExpression() {
return getRuleContexts(StringExpressionContext.class);
}
public StringExpressionContext stringExpression(int i) {
return getRuleContext(StringExpressionContext.class,i);
}
public StringEvalFuncContext stringEvalFunc() {
return getRuleContext(StringEvalFuncContext.class,0);
}
public IffContext iff() {
return getRuleContext(IffContext.class,0);
}
public ParseContext parse() {
return getRuleContext(ParseContext.class,0);
}
public TimeContext time() {
return getRuleContext(TimeContext.class,0);
}
public EvalLengthContext evalLength() {
return getRuleContext(EvalLengthContext.class,0);
}
public EvalHashCodeContext evalHashCode() {
return getRuleContext(EvalHashCodeContext.class,0);
}
public EvalIsEmptyContext evalIsEmpty() {
return getRuleContext(EvalIsEmptyContext.class,0);
}
public EvalIsNotEmptyContext evalIsNotEmpty() {
return getRuleContext(EvalIsNotEmptyContext.class,0);
}
public EvalIsBlankContext evalIsBlank() {
return getRuleContext(EvalIsBlankContext.class,0);
}
public EvalIsNotBlankContext evalIsNotBlank() {
return getRuleContext(EvalIsNotBlankContext.class,0);
}
public RandomContext random() {
return getRuleContext(RandomContext.class,0);
}
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public PropertyAccessorContext propertyAccessor() {
return getRuleContext(PropertyAccessorContext.class,0);
}
public ComparisonOperatorContext comparisonOperator() {
return getRuleContext(ComparisonOperatorContext.class,0);
}
public EvalExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_evalExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterEvalExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitEvalExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitEvalExpression(this);
else return visitor.visitChildren(this);
}
}
public final EvalExpressionContext evalExpression() throws RecognitionException {
return evalExpression(0);
}
private EvalExpressionContext evalExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
EvalExpressionContext _localctx = new EvalExpressionContext(_ctx, _parentState);
EvalExpressionContext _prevctx = _localctx;
int _startState = 2;
enterRecursionRule(_localctx, 2, RULE_evalExpression, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(129);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) {
case 1:
{
setState(82);
match(T__0);
setState(83);
evalExpression(0);
setState(84);
match(T__1);
}
break;
case 2:
{
setState(86);
((EvalExpressionContext)_localctx).complement = match(T__11);
setState(87);
evalExpression(22);
}
break;
case 3:
{
setState(88);
((EvalExpressionContext)_localctx).not = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==T__15 || _la==T__16) ) {
((EvalExpressionContext)_localctx).not = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(89);
evalExpression(18);
}
break;
case 4:
{
setState(90);
placeholder();
setState(91);
((EvalExpressionContext)_localctx).multiModifier = _input.LT(1);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__21) | (1L << T__22) | (1L << T__23) | (1L << T__24) | (1L << T__25) | (1L << T__26))) != 0)) ) {
((EvalExpressionContext)_localctx).multiModifier = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(92);
stringComparisonOp();
setState(93);
stringExpression(0);
}
break;
case 5:
{
setState(95);
stringExpression(0);
setState(96);
stringComparisonOp();
setState(97);
stringExpression(0);
}
break;
case 6:
{
setState(99);
stringExpression(0);
setState(100);
((EvalExpressionContext)_localctx).in = match(T__27);
setState(101);
match(T__0);
setState(102);
stringExpression(0);
setState(107);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__28) {
{
{
setState(103);
match(T__28);
setState(104);
stringExpression(0);
}
}
setState(109);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(110);
match(T__1);
}
break;
case 7:
{
setState(112);
stringExpression(0);
setState(113);
match(T__29);
setState(114);
stringEvalFunc();
}
break;
case 8:
{
setState(116);
iff();
}
break;
case 9:
{
setState(117);
parse();
}
break;
case 10:
{
setState(118);
time();
}
break;
case 11:
{
setState(119);
evalLength();
}
break;
case 12:
{
setState(120);
evalHashCode();
}
break;
case 13:
{
setState(121);
evalIsEmpty();
}
break;
case 14:
{
setState(122);
evalIsNotEmpty();
}
break;
case 15:
{
setState(123);
evalIsBlank();
}
break;
case 16:
{
setState(124);
evalIsNotBlank();
}
break;
case 17:
{
setState(125);
random();
}
break;
case 18:
{
setState(126);
number();
}
break;
case 19:
{
setState(127);
match(T__30);
setState(128);
propertyAccessor();
}
break;
}
_ctx.stop = _input.LT(-1);
setState(155);
_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;
{
setState(153);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
case 1:
{
_localctx = new EvalExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_evalExpression);
setState(131);
if (!(precpred(_ctx, 24))) throw new FailedPredicateException(this, "precpred(_ctx, 24)");
setState(132);
((EvalExpressionContext)_localctx).ternary = match(T__2);
setState(133);
evalExpression(0);
setState(134);
match(T__3);
setState(135);
evalExpression(25);
}
break;
case 2:
{
_localctx = new EvalExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_evalExpression);
setState(137);
if (!(precpred(_ctx, 23))) throw new FailedPredicateException(this, "precpred(_ctx, 23)");
setState(138);
((EvalExpressionContext)_localctx).op = _input.LT(1);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << T__9) | (1L << T__10))) != 0)) ) {
((EvalExpressionContext)_localctx).op = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(139);
evalExpression(24);
}
break;
case 3:
{
_localctx = new EvalExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_evalExpression);
setState(140);
if (!(precpred(_ctx, 21))) throw new FailedPredicateException(this, "precpred(_ctx, 21)");
setState(141);
((EvalExpressionContext)_localctx).op = _input.LT(1);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__12) | (1L << T__13) | (1L << T__14))) != 0)) ) {
((EvalExpressionContext)_localctx).op = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(142);
evalExpression(22);
}
break;
case 4:
{
_localctx = new EvalExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_evalExpression);
setState(143);
if (!(precpred(_ctx, 20))) throw new FailedPredicateException(this, "precpred(_ctx, 20)");
setState(144);
((EvalExpressionContext)_localctx).op = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==MinusSign || _la==PlusSign) ) {
((EvalExpressionContext)_localctx).op = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(145);
evalExpression(21);
}
break;
case 5:
{
_localctx = new EvalExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_evalExpression);
setState(146);
if (!(precpred(_ctx, 19))) throw new FailedPredicateException(this, "precpred(_ctx, 19)");
setState(147);
comparisonOperator();
setState(148);
evalExpression(20);
}
break;
case 6:
{
_localctx = new EvalExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_evalExpression);
setState(150);
if (!(precpred(_ctx, 17))) throw new FailedPredicateException(this, "precpred(_ctx, 17)");
setState(151);
((EvalExpressionContext)_localctx).op = _input.LT(1);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__17) | (1L << T__18) | (1L << T__19) | (1L << T__20))) != 0)) ) {
((EvalExpressionContext)_localctx).op = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(152);
evalExpression(18);
}
break;
}
}
}
setState(157);
_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;
}
public static class IffContext extends ParserRuleContext {
public List evalExpression() {
return getRuleContexts(EvalExpressionContext.class);
}
public EvalExpressionContext evalExpression(int i) {
return getRuleContext(EvalExpressionContext.class,i);
}
public IffContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_iff; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterIff(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitIff(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitIff(this);
else return visitor.visitChildren(this);
}
}
public final IffContext iff() throws RecognitionException {
IffContext _localctx = new IffContext(_ctx, getState());
enterRule(_localctx, 4, RULE_iff);
try {
enterOuterAlt(_localctx, 1);
{
setState(158);
match(T__31);
setState(159);
match(T__0);
setState(160);
evalExpression(0);
setState(161);
match(T__28);
setState(162);
evalExpression(0);
setState(163);
match(T__28);
setState(164);
evalExpression(0);
setState(165);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParseContext extends ParserRuleContext {
public StringExpressionContext stringExpression() {
return getRuleContext(StringExpressionContext.class,0);
}
public EvalExpressionContext evalExpression() {
return getRuleContext(EvalExpressionContext.class,0);
}
public ParseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parse; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterParse(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitParse(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitParse(this);
else return visitor.visitChildren(this);
}
}
public final ParseContext parse() throws RecognitionException {
ParseContext _localctx = new ParseContext(_ctx, getState());
enterRule(_localctx, 6, RULE_parse);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(167);
match(T__32);
setState(168);
match(T__0);
setState(169);
stringExpression(0);
setState(172);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__28) {
{
setState(170);
match(T__28);
setState(171);
evalExpression(0);
}
}
setState(174);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TimeContext extends ParserRuleContext {
public List stringExpression() {
return getRuleContexts(StringExpressionContext.class);
}
public StringExpressionContext stringExpression(int i) {
return getRuleContext(StringExpressionContext.class,i);
}
public TimeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_time; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterTime(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitTime(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitTime(this);
else return visitor.visitChildren(this);
}
}
public final TimeContext time() throws RecognitionException {
TimeContext _localctx = new TimeContext(_ctx, getState());
enterRule(_localctx, 8, RULE_time);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(176);
match(T__33);
setState(177);
match(T__0);
setState(178);
stringExpression(0);
setState(181);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__28) {
{
setState(179);
match(T__28);
setState(180);
stringExpression(0);
}
}
setState(183);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EvalLengthContext extends ParserRuleContext {
public StringExpressionContext stringExpression() {
return getRuleContext(StringExpressionContext.class,0);
}
public EvalLengthContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_evalLength; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterEvalLength(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitEvalLength(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitEvalLength(this);
else return visitor.visitChildren(this);
}
}
public final EvalLengthContext evalLength() throws RecognitionException {
EvalLengthContext _localctx = new EvalLengthContext(_ctx, getState());
enterRule(_localctx, 10, RULE_evalLength);
try {
enterOuterAlt(_localctx, 1);
{
setState(185);
match(T__34);
setState(186);
match(T__0);
setState(187);
stringExpression(0);
setState(188);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EvalHashCodeContext extends ParserRuleContext {
public StringExpressionContext stringExpression() {
return getRuleContext(StringExpressionContext.class,0);
}
public EvalHashCodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_evalHashCode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterEvalHashCode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitEvalHashCode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitEvalHashCode(this);
else return visitor.visitChildren(this);
}
}
public final EvalHashCodeContext evalHashCode() throws RecognitionException {
EvalHashCodeContext _localctx = new EvalHashCodeContext(_ctx, getState());
enterRule(_localctx, 12, RULE_evalHashCode);
try {
enterOuterAlt(_localctx, 1);
{
setState(190);
match(T__35);
setState(191);
match(T__0);
setState(192);
stringExpression(0);
setState(193);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EvalIsEmptyContext extends ParserRuleContext {
public StringExpressionContext stringExpression() {
return getRuleContext(StringExpressionContext.class,0);
}
public EvalIsEmptyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_evalIsEmpty; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterEvalIsEmpty(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitEvalIsEmpty(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitEvalIsEmpty(this);
else return visitor.visitChildren(this);
}
}
public final EvalIsEmptyContext evalIsEmpty() throws RecognitionException {
EvalIsEmptyContext _localctx = new EvalIsEmptyContext(_ctx, getState());
enterRule(_localctx, 14, RULE_evalIsEmpty);
try {
enterOuterAlt(_localctx, 1);
{
setState(195);
match(T__36);
setState(196);
match(T__0);
setState(197);
stringExpression(0);
setState(198);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EvalIsNotEmptyContext extends ParserRuleContext {
public StringExpressionContext stringExpression() {
return getRuleContext(StringExpressionContext.class,0);
}
public EvalIsNotEmptyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_evalIsNotEmpty; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterEvalIsNotEmpty(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitEvalIsNotEmpty(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitEvalIsNotEmpty(this);
else return visitor.visitChildren(this);
}
}
public final EvalIsNotEmptyContext evalIsNotEmpty() throws RecognitionException {
EvalIsNotEmptyContext _localctx = new EvalIsNotEmptyContext(_ctx, getState());
enterRule(_localctx, 16, RULE_evalIsNotEmpty);
try {
enterOuterAlt(_localctx, 1);
{
setState(200);
match(T__37);
setState(201);
match(T__0);
setState(202);
stringExpression(0);
setState(203);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EvalIsBlankContext extends ParserRuleContext {
public StringExpressionContext stringExpression() {
return getRuleContext(StringExpressionContext.class,0);
}
public EvalIsBlankContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_evalIsBlank; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterEvalIsBlank(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitEvalIsBlank(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitEvalIsBlank(this);
else return visitor.visitChildren(this);
}
}
public final EvalIsBlankContext evalIsBlank() throws RecognitionException {
EvalIsBlankContext _localctx = new EvalIsBlankContext(_ctx, getState());
enterRule(_localctx, 18, RULE_evalIsBlank);
try {
enterOuterAlt(_localctx, 1);
{
setState(205);
match(T__38);
setState(206);
match(T__0);
setState(207);
stringExpression(0);
setState(208);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EvalIsNotBlankContext extends ParserRuleContext {
public StringExpressionContext stringExpression() {
return getRuleContext(StringExpressionContext.class,0);
}
public EvalIsNotBlankContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_evalIsNotBlank; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterEvalIsNotBlank(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitEvalIsNotBlank(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitEvalIsNotBlank(this);
else return visitor.visitChildren(this);
}
}
public final EvalIsNotBlankContext evalIsNotBlank() throws RecognitionException {
EvalIsNotBlankContext _localctx = new EvalIsNotBlankContext(_ctx, getState());
enterRule(_localctx, 20, RULE_evalIsNotBlank);
try {
enterOuterAlt(_localctx, 1);
{
setState(210);
match(T__39);
setState(211);
match(T__0);
setState(212);
stringExpression(0);
setState(213);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RandomContext extends ParserRuleContext {
public RandomContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_random; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterRandom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitRandom(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitRandom(this);
else return visitor.visitChildren(this);
}
}
public final RandomContext random() throws RecognitionException {
RandomContext _localctx = new RandomContext(_ctx, getState());
enterRule(_localctx, 22, RULE_random);
try {
enterOuterAlt(_localctx, 1);
{
setState(215);
match(T__40);
setState(216);
match(T__0);
setState(217);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PropertyAccessorContext extends ParserRuleContext {
public PropertyAccessorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_propertyAccessor; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterPropertyAccessor(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitPropertyAccessor(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitPropertyAccessor(this);
else return visitor.visitChildren(this);
}
}
public final PropertyAccessorContext propertyAccessor() throws RecognitionException {
PropertyAccessorContext _localctx = new PropertyAccessorContext(_ctx, getState());
enterRule(_localctx, 24, RULE_propertyAccessor);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(219);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__41) | (1L << T__42) | (1L << T__43) | (1L << T__44))) != 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;
}
public static class StringExpressionContext extends ParserRuleContext {
public Token concat;
public List stringExpression() {
return getRuleContexts(StringExpressionContext.class);
}
public StringExpressionContext stringExpression(int i) {
return getRuleContext(StringExpressionContext.class,i);
}
public AsStringContext asString() {
return getRuleContext(AsStringContext.class,0);
}
public StrIffContext strIff() {
return getRuleContext(StrIffContext.class,0);
}
public StringContext string() {
return getRuleContext(StringContext.class,0);
}
public StringFuncContext stringFunc() {
return getRuleContext(StringFuncContext.class,0);
}
public StringExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stringExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterStringExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitStringExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitStringExpression(this);
else return visitor.visitChildren(this);
}
}
public final StringExpressionContext stringExpression() throws RecognitionException {
return stringExpression(0);
}
private StringExpressionContext stringExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
StringExpressionContext _localctx = new StringExpressionContext(_ctx, _parentState);
StringExpressionContext _prevctx = _localctx;
int _startState = 26;
enterRecursionRule(_localctx, 26, RULE_stringExpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(229);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__0:
{
setState(222);
match(T__0);
setState(223);
stringExpression(0);
setState(224);
match(T__1);
}
break;
case T__45:
{
setState(226);
asString();
}
break;
case T__31:
{
setState(227);
strIff();
}
break;
case T__53:
case Quoted:
{
setState(228);
string();
}
break;
default:
throw new NoViableAltException(this);
}
_ctx.stop = _input.LT(-1);
setState(239);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,8,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(237);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
case 1:
{
_localctx = new StringExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_stringExpression);
setState(231);
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
setState(232);
((StringExpressionContext)_localctx).concat = match(PlusSign);
setState(233);
stringExpression(6);
}
break;
case 2:
{
_localctx = new StringExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_stringExpression);
setState(234);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(235);
match(T__29);
setState(236);
stringFunc();
}
break;
}
}
}
setState(241);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,8,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class StringFuncContext extends ParserRuleContext {
public StrSubstringContext strSubstring() {
return getRuleContext(StrSubstringContext.class,0);
}
public StrLeftContext strLeft() {
return getRuleContext(StrLeftContext.class,0);
}
public StrRightContext strRight() {
return getRuleContext(StrRightContext.class,0);
}
public StrReplaceContext strReplace() {
return getRuleContext(StrReplaceContext.class,0);
}
public StrReplaceAllContext strReplaceAll() {
return getRuleContext(StrReplaceAllContext.class,0);
}
public StrToLowerCaseContext strToLowerCase() {
return getRuleContext(StrToLowerCaseContext.class,0);
}
public StrToUpperCaseContext strToUpperCase() {
return getRuleContext(StrToUpperCaseContext.class,0);
}
public StringFuncContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stringFunc; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterStringFunc(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitStringFunc(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitStringFunc(this);
else return visitor.visitChildren(this);
}
}
public final StringFuncContext stringFunc() throws RecognitionException {
StringFuncContext _localctx = new StringFuncContext(_ctx, getState());
enterRule(_localctx, 28, RULE_stringFunc);
try {
setState(249);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__46:
enterOuterAlt(_localctx, 1);
{
setState(242);
strSubstring();
}
break;
case T__47:
enterOuterAlt(_localctx, 2);
{
setState(243);
strLeft();
}
break;
case T__48:
enterOuterAlt(_localctx, 3);
{
setState(244);
strRight();
}
break;
case T__49:
enterOuterAlt(_localctx, 4);
{
setState(245);
strReplace();
}
break;
case T__50:
enterOuterAlt(_localctx, 5);
{
setState(246);
strReplaceAll();
}
break;
case T__51:
enterOuterAlt(_localctx, 6);
{
setState(247);
strToLowerCase();
}
break;
case T__52:
enterOuterAlt(_localctx, 7);
{
setState(248);
strToUpperCase();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StringEvalFuncContext extends ParserRuleContext {
public StrLengthContext strLength() {
return getRuleContext(StrLengthContext.class,0);
}
public StrHashCodeContext strHashCode() {
return getRuleContext(StrHashCodeContext.class,0);
}
public StrIsEmptyContext strIsEmpty() {
return getRuleContext(StrIsEmptyContext.class,0);
}
public StrIsNotEmptyContext strIsNotEmpty() {
return getRuleContext(StrIsNotEmptyContext.class,0);
}
public StrIsBlankContext strIsBlank() {
return getRuleContext(StrIsBlankContext.class,0);
}
public StrIsNotBlankContext strIsNotBlank() {
return getRuleContext(StrIsNotBlankContext.class,0);
}
public StrParseContext strParse() {
return getRuleContext(StrParseContext.class,0);
}
public StringEvalFuncContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stringEvalFunc; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterStringEvalFunc(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitStringEvalFunc(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitStringEvalFunc(this);
else return visitor.visitChildren(this);
}
}
public final StringEvalFuncContext stringEvalFunc() throws RecognitionException {
StringEvalFuncContext _localctx = new StringEvalFuncContext(_ctx, getState());
enterRule(_localctx, 30, RULE_stringEvalFunc);
try {
setState(258);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__34:
enterOuterAlt(_localctx, 1);
{
setState(251);
strLength();
}
break;
case T__35:
enterOuterAlt(_localctx, 2);
{
setState(252);
strHashCode();
}
break;
case T__36:
enterOuterAlt(_localctx, 3);
{
setState(253);
strIsEmpty();
}
break;
case T__37:
enterOuterAlt(_localctx, 4);
{
setState(254);
strIsNotEmpty();
}
break;
case T__38:
enterOuterAlt(_localctx, 5);
{
setState(255);
strIsBlank();
}
break;
case T__39:
enterOuterAlt(_localctx, 6);
{
setState(256);
strIsNotBlank();
}
break;
case T__32:
enterOuterAlt(_localctx, 7);
{
setState(257);
strParse();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AsStringContext extends ParserRuleContext {
public EvalExpressionContext evalExpression() {
return getRuleContext(EvalExpressionContext.class,0);
}
public StringExpressionContext stringExpression() {
return getRuleContext(StringExpressionContext.class,0);
}
public AsStringContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_asString; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterAsString(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitAsString(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitAsString(this);
else return visitor.visitChildren(this);
}
}
public final AsStringContext asString() throws RecognitionException {
AsStringContext _localctx = new AsStringContext(_ctx, getState());
enterRule(_localctx, 32, RULE_asString);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(260);
match(T__45);
setState(261);
match(T__0);
setState(262);
evalExpression(0);
setState(265);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__28) {
{
setState(263);
match(T__28);
setState(264);
stringExpression(0);
}
}
setState(267);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StrIffContext extends ParserRuleContext {
public EvalExpressionContext evalExpression() {
return getRuleContext(EvalExpressionContext.class,0);
}
public List stringExpression() {
return getRuleContexts(StringExpressionContext.class);
}
public StringExpressionContext stringExpression(int i) {
return getRuleContext(StringExpressionContext.class,i);
}
public StrIffContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_strIff; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterStrIff(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitStrIff(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitStrIff(this);
else return visitor.visitChildren(this);
}
}
public final StrIffContext strIff() throws RecognitionException {
StrIffContext _localctx = new StrIffContext(_ctx, getState());
enterRule(_localctx, 34, RULE_strIff);
try {
enterOuterAlt(_localctx, 1);
{
setState(269);
match(T__31);
setState(270);
match(T__0);
setState(271);
evalExpression(0);
setState(272);
match(T__28);
setState(273);
stringExpression(0);
setState(274);
match(T__28);
setState(275);
stringExpression(0);
setState(276);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StrSubstringContext extends ParserRuleContext {
public List evalExpression() {
return getRuleContexts(EvalExpressionContext.class);
}
public EvalExpressionContext evalExpression(int i) {
return getRuleContext(EvalExpressionContext.class,i);
}
public StrSubstringContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_strSubstring; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterStrSubstring(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitStrSubstring(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitStrSubstring(this);
else return visitor.visitChildren(this);
}
}
public final StrSubstringContext strSubstring() throws RecognitionException {
StrSubstringContext _localctx = new StrSubstringContext(_ctx, getState());
enterRule(_localctx, 36, RULE_strSubstring);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(278);
match(T__46);
setState(279);
match(T__0);
setState(280);
evalExpression(0);
setState(283);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__28) {
{
setState(281);
match(T__28);
setState(282);
evalExpression(0);
}
}
setState(285);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StrLeftContext extends ParserRuleContext {
public EvalExpressionContext evalExpression() {
return getRuleContext(EvalExpressionContext.class,0);
}
public StrLeftContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_strLeft; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterStrLeft(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitStrLeft(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitStrLeft(this);
else return visitor.visitChildren(this);
}
}
public final StrLeftContext strLeft() throws RecognitionException {
StrLeftContext _localctx = new StrLeftContext(_ctx, getState());
enterRule(_localctx, 38, RULE_strLeft);
try {
enterOuterAlt(_localctx, 1);
{
setState(287);
match(T__47);
setState(288);
match(T__0);
setState(289);
evalExpression(0);
setState(290);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StrRightContext extends ParserRuleContext {
public EvalExpressionContext evalExpression() {
return getRuleContext(EvalExpressionContext.class,0);
}
public StrRightContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_strRight; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterStrRight(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitStrRight(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitStrRight(this);
else return visitor.visitChildren(this);
}
}
public final StrRightContext strRight() throws RecognitionException {
StrRightContext _localctx = new StrRightContext(_ctx, getState());
enterRule(_localctx, 40, RULE_strRight);
try {
enterOuterAlt(_localctx, 1);
{
setState(292);
match(T__48);
setState(293);
match(T__0);
setState(294);
evalExpression(0);
setState(295);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StrReplaceContext extends ParserRuleContext {
public List stringExpression() {
return getRuleContexts(StringExpressionContext.class);
}
public StringExpressionContext stringExpression(int i) {
return getRuleContext(StringExpressionContext.class,i);
}
public StrReplaceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_strReplace; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterStrReplace(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitStrReplace(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitStrReplace(this);
else return visitor.visitChildren(this);
}
}
public final StrReplaceContext strReplace() throws RecognitionException {
StrReplaceContext _localctx = new StrReplaceContext(_ctx, getState());
enterRule(_localctx, 42, RULE_strReplace);
try {
enterOuterAlt(_localctx, 1);
{
setState(297);
match(T__49);
setState(298);
match(T__0);
setState(299);
stringExpression(0);
setState(300);
match(T__28);
setState(301);
stringExpression(0);
setState(302);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StrReplaceAllContext extends ParserRuleContext {
public List stringExpression() {
return getRuleContexts(StringExpressionContext.class);
}
public StringExpressionContext stringExpression(int i) {
return getRuleContext(StringExpressionContext.class,i);
}
public StrReplaceAllContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_strReplaceAll; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterStrReplaceAll(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitStrReplaceAll(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitStrReplaceAll(this);
else return visitor.visitChildren(this);
}
}
public final StrReplaceAllContext strReplaceAll() throws RecognitionException {
StrReplaceAllContext _localctx = new StrReplaceAllContext(_ctx, getState());
enterRule(_localctx, 44, RULE_strReplaceAll);
try {
enterOuterAlt(_localctx, 1);
{
setState(304);
match(T__50);
setState(305);
match(T__0);
setState(306);
stringExpression(0);
setState(307);
match(T__28);
setState(308);
stringExpression(0);
setState(309);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StrToLowerCaseContext extends ParserRuleContext {
public StrToLowerCaseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_strToLowerCase; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterStrToLowerCase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitStrToLowerCase(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitStrToLowerCase(this);
else return visitor.visitChildren(this);
}
}
public final StrToLowerCaseContext strToLowerCase() throws RecognitionException {
StrToLowerCaseContext _localctx = new StrToLowerCaseContext(_ctx, getState());
enterRule(_localctx, 46, RULE_strToLowerCase);
try {
enterOuterAlt(_localctx, 1);
{
setState(311);
match(T__51);
setState(312);
match(T__0);
setState(313);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StrToUpperCaseContext extends ParserRuleContext {
public StrToUpperCaseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_strToUpperCase; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterStrToUpperCase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitStrToUpperCase(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitStrToUpperCase(this);
else return visitor.visitChildren(this);
}
}
public final StrToUpperCaseContext strToUpperCase() throws RecognitionException {
StrToUpperCaseContext _localctx = new StrToUpperCaseContext(_ctx, getState());
enterRule(_localctx, 48, RULE_strToUpperCase);
try {
enterOuterAlt(_localctx, 1);
{
setState(315);
match(T__52);
setState(316);
match(T__0);
setState(317);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StrLengthContext extends ParserRuleContext {
public StrLengthContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_strLength; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterStrLength(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitStrLength(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitStrLength(this);
else return visitor.visitChildren(this);
}
}
public final StrLengthContext strLength() throws RecognitionException {
StrLengthContext _localctx = new StrLengthContext(_ctx, getState());
enterRule(_localctx, 50, RULE_strLength);
try {
enterOuterAlt(_localctx, 1);
{
setState(319);
match(T__34);
setState(320);
match(T__0);
setState(321);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StrHashCodeContext extends ParserRuleContext {
public StrHashCodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_strHashCode; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterStrHashCode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitStrHashCode(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitStrHashCode(this);
else return visitor.visitChildren(this);
}
}
public final StrHashCodeContext strHashCode() throws RecognitionException {
StrHashCodeContext _localctx = new StrHashCodeContext(_ctx, getState());
enterRule(_localctx, 52, RULE_strHashCode);
try {
enterOuterAlt(_localctx, 1);
{
setState(323);
match(T__35);
setState(324);
match(T__0);
setState(325);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StrIsEmptyContext extends ParserRuleContext {
public StrIsEmptyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_strIsEmpty; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterStrIsEmpty(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitStrIsEmpty(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitStrIsEmpty(this);
else return visitor.visitChildren(this);
}
}
public final StrIsEmptyContext strIsEmpty() throws RecognitionException {
StrIsEmptyContext _localctx = new StrIsEmptyContext(_ctx, getState());
enterRule(_localctx, 54, RULE_strIsEmpty);
try {
enterOuterAlt(_localctx, 1);
{
setState(327);
match(T__36);
setState(328);
match(T__0);
setState(329);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StrIsNotEmptyContext extends ParserRuleContext {
public StrIsNotEmptyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_strIsNotEmpty; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterStrIsNotEmpty(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitStrIsNotEmpty(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitStrIsNotEmpty(this);
else return visitor.visitChildren(this);
}
}
public final StrIsNotEmptyContext strIsNotEmpty() throws RecognitionException {
StrIsNotEmptyContext _localctx = new StrIsNotEmptyContext(_ctx, getState());
enterRule(_localctx, 56, RULE_strIsNotEmpty);
try {
enterOuterAlt(_localctx, 1);
{
setState(331);
match(T__37);
setState(332);
match(T__0);
setState(333);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StrIsBlankContext extends ParserRuleContext {
public StrIsBlankContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_strIsBlank; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterStrIsBlank(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitStrIsBlank(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitStrIsBlank(this);
else return visitor.visitChildren(this);
}
}
public final StrIsBlankContext strIsBlank() throws RecognitionException {
StrIsBlankContext _localctx = new StrIsBlankContext(_ctx, getState());
enterRule(_localctx, 58, RULE_strIsBlank);
try {
enterOuterAlt(_localctx, 1);
{
setState(335);
match(T__38);
setState(336);
match(T__0);
setState(337);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StrIsNotBlankContext extends ParserRuleContext {
public StrIsNotBlankContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_strIsNotBlank; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterStrIsNotBlank(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitStrIsNotBlank(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitStrIsNotBlank(this);
else return visitor.visitChildren(this);
}
}
public final StrIsNotBlankContext strIsNotBlank() throws RecognitionException {
StrIsNotBlankContext _localctx = new StrIsNotBlankContext(_ctx, getState());
enterRule(_localctx, 60, RULE_strIsNotBlank);
try {
enterOuterAlt(_localctx, 1);
{
setState(339);
match(T__39);
setState(340);
match(T__0);
setState(341);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StrParseContext extends ParserRuleContext {
public EvalExpressionContext evalExpression() {
return getRuleContext(EvalExpressionContext.class,0);
}
public StrParseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_strParse; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterStrParse(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitStrParse(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitStrParse(this);
else return visitor.visitChildren(this);
}
}
public final StrParseContext strParse() throws RecognitionException {
StrParseContext _localctx = new StrParseContext(_ctx, getState());
enterRule(_localctx, 62, RULE_strParse);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(343);
match(T__32);
setState(344);
match(T__0);
setState(346);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__11) | (1L << T__15) | (1L << T__16) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__33) | (1L << T__34) | (1L << T__35) | (1L << T__36) | (1L << T__37) | (1L << T__38) | (1L << T__39) | (1L << T__40) | (1L << T__45) | (1L << T__53))) != 0) || ((((_la - 92)) & ~0x3f) == 0 && ((1L << (_la - 92)) & ((1L << (MinusSign - 92)) | (1L << (PlusSign - 92)) | (1L << (Number - 92)) | (1L << (Quoted - 92)))) != 0)) {
{
setState(345);
evalExpression(0);
}
}
setState(348);
match(T__1);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StringContext extends ParserRuleContext {
public TerminalNode Quoted() { return getToken(PredicateExpressionParser.Quoted, 0); }
public PlaceholderContext placeholder() {
return getRuleContext(PlaceholderContext.class,0);
}
public StringContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_string; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterString(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitString(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitString(this);
else return visitor.visitChildren(this);
}
}
public final StringContext string() throws RecognitionException {
StringContext _localctx = new StringContext(_ctx, getState());
enterRule(_localctx, 64, RULE_string);
try {
setState(352);
_errHandler.sync(this);
switch (_input.LA(1)) {
case Quoted:
enterOuterAlt(_localctx, 1);
{
setState(350);
match(Quoted);
}
break;
case T__53:
enterOuterAlt(_localctx, 2);
{
setState(351);
placeholder();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PlaceholderContext extends ParserRuleContext {
public TagkContext tagk() {
return getRuleContext(TagkContext.class,0);
}
public PlaceholderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_placeholder; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterPlaceholder(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitPlaceholder(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitPlaceholder(this);
else return visitor.visitChildren(this);
}
}
public final PlaceholderContext placeholder() throws RecognitionException {
PlaceholderContext _localctx = new PlaceholderContext(_ctx, getState());
enterRule(_localctx, 66, RULE_placeholder);
try {
enterOuterAlt(_localctx, 1);
{
setState(354);
match(T__53);
setState(355);
tagk();
setState(356);
match(T__54);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TagkContext extends ParserRuleContext {
public TerminalNode Quoted() { return getToken(PredicateExpressionParser.Quoted, 0); }
public TerminalNode Letters() { return getToken(PredicateExpressionParser.Letters, 0); }
public TerminalNode Literal() { return getToken(PredicateExpressionParser.Literal, 0); }
public TerminalNode Identifier() { return getToken(PredicateExpressionParser.Identifier, 0); }
public TerminalNode Number() { return getToken(PredicateExpressionParser.Number, 0); }
public TagkContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tagk; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterTagk(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitTagk(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitTagk(this);
else return visitor.visitChildren(this);
}
}
public final TagkContext tagk() throws RecognitionException {
TagkContext _localctx = new TagkContext(_ctx, getState());
enterRule(_localctx, 68, RULE_tagk);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(358);
_la = _input.LA(1);
if ( !(((((_la - 95)) & ~0x3f) == 0 && ((1L << (_la - 95)) & ((1L << (Number - 95)) | (1L << (Identifier - 95)) | (1L << (Letters - 95)) | (1L << (Quoted - 95)) | (1L << (Literal - 95)))) != 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;
}
public static class StringComparisonOpContext extends ParserRuleContext {
public StringComparisonOpContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stringComparisonOp; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterStringComparisonOp(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitStringComparisonOp(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitStringComparisonOp(this);
else return visitor.visitChildren(this);
}
}
public final StringComparisonOpContext stringComparisonOp() throws RecognitionException {
StringComparisonOpContext _localctx = new StringComparisonOpContext(_ctx, getState());
enterRule(_localctx, 70, RULE_stringComparisonOp);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(360);
_la = _input.LA(1);
if ( !(((((_la - 56)) & ~0x3f) == 0 && ((1L << (_la - 56)) & ((1L << (T__55 - 56)) | (1L << (T__56 - 56)) | (1L << (T__57 - 56)) | (1L << (T__58 - 56)) | (1L << (T__59 - 56)) | (1L << (T__60 - 56)) | (1L << (T__61 - 56)) | (1L << (T__62 - 56)) | (1L << (T__63 - 56)) | (1L << (T__64 - 56)) | (1L << (T__65 - 56)) | (1L << (T__66 - 56)) | (1L << (EQ - 56)))) != 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;
}
public static class ComparisonOperatorContext extends ParserRuleContext {
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 PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterComparisonOperator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitComparisonOperator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitComparisonOperator(this);
else return visitor.visitChildren(this);
}
}
public final ComparisonOperatorContext comparisonOperator() throws RecognitionException {
ComparisonOperatorContext _localctx = new ComparisonOperatorContext(_ctx, getState());
enterRule(_localctx, 72, RULE_comparisonOperator);
try {
setState(371);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(362);
match(EQ);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(363);
match(T__67);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(364);
match(T__68);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(365);
match(T__68);
setState(366);
match(EQ);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(367);
match(T__67);
setState(368);
match(EQ);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(369);
match(T__69);
setState(370);
match(EQ);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NumberContext extends ParserRuleContext {
public TerminalNode Number() { return getToken(PredicateExpressionParser.Number, 0); }
public TerminalNode MinusSign() { return getToken(PredicateExpressionParser.MinusSign, 0); }
public SiSuffixContext siSuffix() {
return getRuleContext(SiSuffixContext.class,0);
}
public TerminalNode PlusSign() { return getToken(PredicateExpressionParser.PlusSign, 0); }
public NumberContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_number; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterNumber(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitNumber(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitNumber(this);
else return visitor.visitChildren(this);
}
}
public final NumberContext number() throws RecognitionException {
NumberContext _localctx = new NumberContext(_ctx, getState());
enterRule(_localctx, 74, RULE_number);
int _la;
try {
setState(387);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(374);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MinusSign) {
{
setState(373);
match(MinusSign);
}
}
setState(376);
match(Number);
setState(378);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
case 1:
{
setState(377);
siSuffix();
}
break;
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(381);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PlusSign) {
{
setState(380);
match(PlusSign);
}
}
setState(383);
match(Number);
setState(385);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
case 1:
{
setState(384);
siSuffix();
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SiSuffixContext extends ParserRuleContext {
public SiSuffixContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_siSuffix; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).enterSiSuffix(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof PredicateExpressionListener ) ((PredicateExpressionListener)listener).exitSiSuffix(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof PredicateExpressionVisitor ) return ((PredicateExpressionVisitor)visitor).visitSiSuffix(this);
else return visitor.visitChildren(this);
}
}
public final SiSuffixContext siSuffix() throws RecognitionException {
SiSuffixContext _localctx = new SiSuffixContext(_ctx, getState());
enterRule(_localctx, 76, RULE_siSuffix);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(389);
_la = _input.LA(1);
if ( !(((((_la - 71)) & ~0x3f) == 0 && ((1L << (_la - 71)) & ((1L << (T__70 - 71)) | (1L << (T__71 - 71)) | (1L << (T__72 - 71)) | (1L << (T__73 - 71)) | (1L << (T__74 - 71)) | (1L << (T__75 - 71)) | (1L << (T__76 - 71)) | (1L << (T__77 - 71)) | (1L << (T__78 - 71)) | (1L << (T__79 - 71)) | (1L << (T__80 - 71)) | (1L << (T__81 - 71)) | (1L << (T__82 - 71)) | (1L << (T__83 - 71)) | (1L << (T__84 - 71)) | (1L << (T__85 - 71)) | (1L << (T__86 - 71)) | (1L << (T__87 - 71)) | (1L << (T__88 - 71)) | (1L << (T__89 - 71)))) != 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;
}
public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
switch (ruleIndex) {
case 1:
return evalExpression_sempred((EvalExpressionContext)_localctx, predIndex);
case 13:
return stringExpression_sempred((StringExpressionContext)_localctx, predIndex);
}
return true;
}
private boolean evalExpression_sempred(EvalExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return precpred(_ctx, 24);
case 1:
return precpred(_ctx, 23);
case 2:
return precpred(_ctx, 21);
case 3:
return precpred(_ctx, 20);
case 4:
return precpred(_ctx, 19);
case 5:
return precpred(_ctx, 17);
}
return true;
}
private boolean stringExpression_sempred(StringExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 6:
return precpred(_ctx, 5);
case 7:
return precpred(_ctx, 4);
}
return true;
}
public static final String _serializedATN =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3h\u018a\4\2\t\2\4"+
"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\3\2\3\2\3\2\3\3\3\3"+
"\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3"+
"\3\3\3\3\3\3\3\3\3\7\3l\n\3\f\3\16\3o\13\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3"+
"\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\5\3\u0084\n\3\3\3\3\3"+
"\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3"+
"\3\3\3\3\3\7\3\u009c\n\3\f\3\16\3\u009f\13\3\3\4\3\4\3\4\3\4\3\4\3\4\3"+
"\4\3\4\3\4\3\5\3\5\3\5\3\5\3\5\5\5\u00af\n\5\3\5\3\5\3\6\3\6\3\6\3\6\3"+
"\6\5\6\u00b8\n\6\3\6\3\6\3\7\3\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b\3\b\3\t\3"+
"\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\13\3\f\3\f\3"+
"\f\3\f\3\f\3\r\3\r\3\r\3\r\3\16\3\16\3\17\3\17\3\17\3\17\3\17\3\17\3\17"+
"\3\17\5\17\u00e8\n\17\3\17\3\17\3\17\3\17\3\17\3\17\7\17\u00f0\n\17\f"+
"\17\16\17\u00f3\13\17\3\20\3\20\3\20\3\20\3\20\3\20\3\20\5\20\u00fc\n"+
"\20\3\21\3\21\3\21\3\21\3\21\3\21\3\21\5\21\u0105\n\21\3\22\3\22\3\22"+
"\3\22\3\22\5\22\u010c\n\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\23\3\23"+
"\3\23\3\23\3\24\3\24\3\24\3\24\3\24\5\24\u011e\n\24\3\24\3\24\3\25\3\25"+
"\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\26\3\27\3\27\3\27\3\27\3\27\3\27"+
"\3\27\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3\31\3\31\3\32\3\32"+
"\3\32\3\32\3\33\3\33\3\33\3\33\3\34\3\34\3\34\3\34\3\35\3\35\3\35\3\35"+
"\3\36\3\36\3\36\3\36\3\37\3\37\3\37\3\37\3 \3 \3 \3 \3!\3!\3!\5!\u015d"+
"\n!\3!\3!\3\"\3\"\5\"\u0163\n\"\3#\3#\3#\3#\3$\3$\3%\3%\3&\3&\3&\3&\3"+
"&\3&\3&\3&\3&\5&\u0176\n&\3\'\5\'\u0179\n\'\3\'\3\'\5\'\u017d\n\'\3\'"+
"\5\'\u0180\n\'\3\'\3\'\5\'\u0184\n\'\5\'\u0186\n\'\3(\3(\3(\2\4\4\34)"+
"\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFH"+
"JLN\2\f\3\2\22\23\3\2\30\35\3\2\7\r\3\2\17\21\3\2^_\3\2\24\27\3\2,/\3"+
"\2ae\4\2:E]]\3\2I\\\2\u019c\2P\3\2\2\2\4\u0083\3\2\2\2\6\u00a0\3\2\2\2"+
"\b\u00a9\3\2\2\2\n\u00b2\3\2\2\2\f\u00bb\3\2\2\2\16\u00c0\3\2\2\2\20\u00c5"+
"\3\2\2\2\22\u00ca\3\2\2\2\24\u00cf\3\2\2\2\26\u00d4\3\2\2\2\30\u00d9\3"+
"\2\2\2\32\u00dd\3\2\2\2\34\u00e7\3\2\2\2\36\u00fb\3\2\2\2 \u0104\3\2\2"+
"\2\"\u0106\3\2\2\2$\u010f\3\2\2\2&\u0118\3\2\2\2(\u0121\3\2\2\2*\u0126"+
"\3\2\2\2,\u012b\3\2\2\2.\u0132\3\2\2\2\60\u0139\3\2\2\2\62\u013d\3\2\2"+
"\2\64\u0141\3\2\2\2\66\u0145\3\2\2\28\u0149\3\2\2\2:\u014d\3\2\2\2<\u0151"+
"\3\2\2\2>\u0155\3\2\2\2@\u0159\3\2\2\2B\u0162\3\2\2\2D\u0164\3\2\2\2F"+
"\u0168\3\2\2\2H\u016a\3\2\2\2J\u0175\3\2\2\2L\u0185\3\2\2\2N\u0187\3\2"+
"\2\2PQ\5\4\3\2QR\7\2\2\3R\3\3\2\2\2ST\b\3\1\2TU\7\3\2\2UV\5\4\3\2VW\7"+
"\4\2\2W\u0084\3\2\2\2XY\7\16\2\2Y\u0084\5\4\3\30Z[\t\2\2\2[\u0084\5\4"+
"\3\24\\]\5D#\2]^\t\3\2\2^_\5H%\2_`\5\34\17\2`\u0084\3\2\2\2ab\5\34\17"+
"\2bc\5H%\2cd\5\34\17\2d\u0084\3\2\2\2ef\5\34\17\2fg\7\36\2\2gh\7\3\2\2"+
"hm\5\34\17\2ij\7\37\2\2jl\5\34\17\2ki\3\2\2\2lo\3\2\2\2mk\3\2\2\2mn\3"+
"\2\2\2np\3\2\2\2om\3\2\2\2pq\7\4\2\2q\u0084\3\2\2\2rs\5\34\17\2st\7 \2"+
"\2tu\5 \21\2u\u0084\3\2\2\2v\u0084\5\6\4\2w\u0084\5\b\5\2x\u0084\5\n\6"+
"\2y\u0084\5\f\7\2z\u0084\5\16\b\2{\u0084\5\20\t\2|\u0084\5\22\n\2}\u0084"+
"\5\24\13\2~\u0084\5\26\f\2\177\u0084\5\30\r\2\u0080\u0084\5L\'\2\u0081"+
"\u0082\7!\2\2\u0082\u0084\5\32\16\2\u0083S\3\2\2\2\u0083X\3\2\2\2\u0083"+
"Z\3\2\2\2\u0083\\\3\2\2\2\u0083a\3\2\2\2\u0083e\3\2\2\2\u0083r\3\2\2\2"+
"\u0083v\3\2\2\2\u0083w\3\2\2\2\u0083x\3\2\2\2\u0083y\3\2\2\2\u0083z\3"+
"\2\2\2\u0083{\3\2\2\2\u0083|\3\2\2\2\u0083}\3\2\2\2\u0083~\3\2\2\2\u0083"+
"\177\3\2\2\2\u0083\u0080\3\2\2\2\u0083\u0081\3\2\2\2\u0084\u009d\3\2\2"+
"\2\u0085\u0086\f\32\2\2\u0086\u0087\7\5\2\2\u0087\u0088\5\4\3\2\u0088"+
"\u0089\7\6\2\2\u0089\u008a\5\4\3\33\u008a\u009c\3\2\2\2\u008b\u008c\f"+
"\31\2\2\u008c\u008d\t\4\2\2\u008d\u009c\5\4\3\32\u008e\u008f\f\27\2\2"+
"\u008f\u0090\t\5\2\2\u0090\u009c\5\4\3\30\u0091\u0092\f\26\2\2\u0092\u0093"+
"\t\6\2\2\u0093\u009c\5\4\3\27\u0094\u0095\f\25\2\2\u0095\u0096\5J&\2\u0096"+
"\u0097\5\4\3\26\u0097\u009c\3\2\2\2\u0098\u0099\f\23\2\2\u0099\u009a\t"+
"\7\2\2\u009a\u009c\5\4\3\24\u009b\u0085\3\2\2\2\u009b\u008b\3\2\2\2\u009b"+
"\u008e\3\2\2\2\u009b\u0091\3\2\2\2\u009b\u0094\3\2\2\2\u009b\u0098\3\2"+
"\2\2\u009c\u009f\3\2\2\2\u009d\u009b\3\2\2\2\u009d\u009e\3\2\2\2\u009e"+
"\5\3\2\2\2\u009f\u009d\3\2\2\2\u00a0\u00a1\7\"\2\2\u00a1\u00a2\7\3\2\2"+
"\u00a2\u00a3\5\4\3\2\u00a3\u00a4\7\37\2\2\u00a4\u00a5\5\4\3\2\u00a5\u00a6"+
"\7\37\2\2\u00a6\u00a7\5\4\3\2\u00a7\u00a8\7\4\2\2\u00a8\7\3\2\2\2\u00a9"+
"\u00aa\7#\2\2\u00aa\u00ab\7\3\2\2\u00ab\u00ae\5\34\17\2\u00ac\u00ad\7"+
"\37\2\2\u00ad\u00af\5\4\3\2\u00ae\u00ac\3\2\2\2\u00ae\u00af\3\2\2\2\u00af"+
"\u00b0\3\2\2\2\u00b0\u00b1\7\4\2\2\u00b1\t\3\2\2\2\u00b2\u00b3\7$\2\2"+
"\u00b3\u00b4\7\3\2\2\u00b4\u00b7\5\34\17\2\u00b5\u00b6\7\37\2\2\u00b6"+
"\u00b8\5\34\17\2\u00b7\u00b5\3\2\2\2\u00b7\u00b8\3\2\2\2\u00b8\u00b9\3"+
"\2\2\2\u00b9\u00ba\7\4\2\2\u00ba\13\3\2\2\2\u00bb\u00bc\7%\2\2\u00bc\u00bd"+
"\7\3\2\2\u00bd\u00be\5\34\17\2\u00be\u00bf\7\4\2\2\u00bf\r\3\2\2\2\u00c0"+
"\u00c1\7&\2\2\u00c1\u00c2\7\3\2\2\u00c2\u00c3\5\34\17\2\u00c3\u00c4\7"+
"\4\2\2\u00c4\17\3\2\2\2\u00c5\u00c6\7\'\2\2\u00c6\u00c7\7\3\2\2\u00c7"+
"\u00c8\5\34\17\2\u00c8\u00c9\7\4\2\2\u00c9\21\3\2\2\2\u00ca\u00cb\7(\2"+
"\2\u00cb\u00cc\7\3\2\2\u00cc\u00cd\5\34\17\2\u00cd\u00ce\7\4\2\2\u00ce"+
"\23\3\2\2\2\u00cf\u00d0\7)\2\2\u00d0\u00d1\7\3\2\2\u00d1\u00d2\5\34\17"+
"\2\u00d2\u00d3\7\4\2\2\u00d3\25\3\2\2\2\u00d4\u00d5\7*\2\2\u00d5\u00d6"+
"\7\3\2\2\u00d6\u00d7\5\34\17\2\u00d7\u00d8\7\4\2\2\u00d8\27\3\2\2\2\u00d9"+
"\u00da\7+\2\2\u00da\u00db\7\3\2\2\u00db\u00dc\7\4\2\2\u00dc\31\3\2\2\2"+
"\u00dd\u00de\t\b\2\2\u00de\33\3\2\2\2\u00df\u00e0\b\17\1\2\u00e0\u00e1"+
"\7\3\2\2\u00e1\u00e2\5\34\17\2\u00e2\u00e3\7\4\2\2\u00e3\u00e8\3\2\2\2"+
"\u00e4\u00e8\5\"\22\2\u00e5\u00e8\5$\23\2\u00e6\u00e8\5B\"\2\u00e7\u00df"+
"\3\2\2\2\u00e7\u00e4\3\2\2\2\u00e7\u00e5\3\2\2\2\u00e7\u00e6\3\2\2\2\u00e8"+
"\u00f1\3\2\2\2\u00e9\u00ea\f\7\2\2\u00ea\u00eb\7_\2\2\u00eb\u00f0\5\34"+
"\17\b\u00ec\u00ed\f\6\2\2\u00ed\u00ee\7 \2\2\u00ee\u00f0\5\36\20\2\u00ef"+
"\u00e9\3\2\2\2\u00ef\u00ec\3\2\2\2\u00f0\u00f3\3\2\2\2\u00f1\u00ef\3\2"+
"\2\2\u00f1\u00f2\3\2\2\2\u00f2\35\3\2\2\2\u00f3\u00f1\3\2\2\2\u00f4\u00fc"+
"\5&\24\2\u00f5\u00fc\5(\25\2\u00f6\u00fc\5*\26\2\u00f7\u00fc\5,\27\2\u00f8"+
"\u00fc\5.\30\2\u00f9\u00fc\5\60\31\2\u00fa\u00fc\5\62\32\2\u00fb\u00f4"+
"\3\2\2\2\u00fb\u00f5\3\2\2\2\u00fb\u00f6\3\2\2\2\u00fb\u00f7\3\2\2\2\u00fb"+
"\u00f8\3\2\2\2\u00fb\u00f9\3\2\2\2\u00fb\u00fa\3\2\2\2\u00fc\37\3\2\2"+
"\2\u00fd\u0105\5\64\33\2\u00fe\u0105\5\66\34\2\u00ff\u0105\58\35\2\u0100"+
"\u0105\5:\36\2\u0101\u0105\5<\37\2\u0102\u0105\5> \2\u0103\u0105\5@!\2"+
"\u0104\u00fd\3\2\2\2\u0104\u00fe\3\2\2\2\u0104\u00ff\3\2\2\2\u0104\u0100"+
"\3\2\2\2\u0104\u0101\3\2\2\2\u0104\u0102\3\2\2\2\u0104\u0103\3\2\2\2\u0105"+
"!\3\2\2\2\u0106\u0107\7\60\2\2\u0107\u0108\7\3\2\2\u0108\u010b\5\4\3\2"+
"\u0109\u010a\7\37\2\2\u010a\u010c\5\34\17\2\u010b\u0109\3\2\2\2\u010b"+
"\u010c\3\2\2\2\u010c\u010d\3\2\2\2\u010d\u010e\7\4\2\2\u010e#\3\2\2\2"+
"\u010f\u0110\7\"\2\2\u0110\u0111\7\3\2\2\u0111\u0112\5\4\3\2\u0112\u0113"+
"\7\37\2\2\u0113\u0114\5\34\17\2\u0114\u0115\7\37\2\2\u0115\u0116\5\34"+
"\17\2\u0116\u0117\7\4\2\2\u0117%\3\2\2\2\u0118\u0119\7\61\2\2\u0119\u011a"+
"\7\3\2\2\u011a\u011d\5\4\3\2\u011b\u011c\7\37\2\2\u011c\u011e\5\4\3\2"+
"\u011d\u011b\3\2\2\2\u011d\u011e\3\2\2\2\u011e\u011f\3\2\2\2\u011f\u0120"+
"\7\4\2\2\u0120\'\3\2\2\2\u0121\u0122\7\62\2\2\u0122\u0123\7\3\2\2\u0123"+
"\u0124\5\4\3\2\u0124\u0125\7\4\2\2\u0125)\3\2\2\2\u0126\u0127\7\63\2\2"+
"\u0127\u0128\7\3\2\2\u0128\u0129\5\4\3\2\u0129\u012a\7\4\2\2\u012a+\3"+
"\2\2\2\u012b\u012c\7\64\2\2\u012c\u012d\7\3\2\2\u012d\u012e\5\34\17\2"+
"\u012e\u012f\7\37\2\2\u012f\u0130\5\34\17\2\u0130\u0131\7\4\2\2\u0131"+
"-\3\2\2\2\u0132\u0133\7\65\2\2\u0133\u0134\7\3\2\2\u0134\u0135\5\34\17"+
"\2\u0135\u0136\7\37\2\2\u0136\u0137\5\34\17\2\u0137\u0138\7\4\2\2\u0138"+
"/\3\2\2\2\u0139\u013a\7\66\2\2\u013a\u013b\7\3\2\2\u013b\u013c\7\4\2\2"+
"\u013c\61\3\2\2\2\u013d\u013e\7\67\2\2\u013e\u013f\7\3\2\2\u013f\u0140"+
"\7\4\2\2\u0140\63\3\2\2\2\u0141\u0142\7%\2\2\u0142\u0143\7\3\2\2\u0143"+
"\u0144\7\4\2\2\u0144\65\3\2\2\2\u0145\u0146\7&\2\2\u0146\u0147\7\3\2\2"+
"\u0147\u0148\7\4\2\2\u0148\67\3\2\2\2\u0149\u014a\7\'\2\2\u014a\u014b"+
"\7\3\2\2\u014b\u014c\7\4\2\2\u014c9\3\2\2\2\u014d\u014e\7(\2\2\u014e\u014f"+
"\7\3\2\2\u014f\u0150\7\4\2\2\u0150;\3\2\2\2\u0151\u0152\7)\2\2\u0152\u0153"+
"\7\3\2\2\u0153\u0154\7\4\2\2\u0154=\3\2\2\2\u0155\u0156\7*\2\2\u0156\u0157"+
"\7\3\2\2\u0157\u0158\7\4\2\2\u0158?\3\2\2\2\u0159\u015a\7#\2\2\u015a\u015c"+
"\7\3\2\2\u015b\u015d\5\4\3\2\u015c\u015b\3\2\2\2\u015c\u015d\3\2\2\2\u015d"+
"\u015e\3\2\2\2\u015e\u015f\7\4\2\2\u015fA\3\2\2\2\u0160\u0163\7d\2\2\u0161"+
"\u0163\5D#\2\u0162\u0160\3\2\2\2\u0162\u0161\3\2\2\2\u0163C\3\2\2\2\u0164"+
"\u0165\78\2\2\u0165\u0166\5F$\2\u0166\u0167\79\2\2\u0167E\3\2\2\2\u0168"+
"\u0169\t\t\2\2\u0169G\3\2\2\2\u016a\u016b\t\n\2\2\u016bI\3\2\2\2\u016c"+
"\u0176\7]\2\2\u016d\u0176\7F\2\2\u016e\u0176\7G\2\2\u016f\u0170\7G\2\2"+
"\u0170\u0176\7]\2\2\u0171\u0172\7F\2\2\u0172\u0176\7]\2\2\u0173\u0174"+
"\7H\2\2\u0174\u0176\7]\2\2\u0175\u016c\3\2\2\2\u0175\u016d\3\2\2\2\u0175"+
"\u016e\3\2\2\2\u0175\u016f\3\2\2\2\u0175\u0171\3\2\2\2\u0175\u0173\3\2"+
"\2\2\u0176K\3\2\2\2\u0177\u0179\7^\2\2\u0178\u0177\3\2\2\2\u0178\u0179"+
"\3\2\2\2\u0179\u017a\3\2\2\2\u017a\u017c\7a\2\2\u017b\u017d\5N(\2\u017c"+
"\u017b\3\2\2\2\u017c\u017d\3\2\2\2\u017d\u0186\3\2\2\2\u017e\u0180\7_"+
"\2\2\u017f\u017e\3\2\2\2\u017f\u0180\3\2\2\2\u0180\u0181\3\2\2\2\u0181"+
"\u0183\7a\2\2\u0182\u0184\5N(\2\u0183\u0182\3\2\2\2\u0183\u0184\3\2\2"+
"\2\u0184\u0186\3\2\2\2\u0185\u0178\3\2\2\2\u0185\u017f\3\2\2\2\u0186M"+
"\3\2\2\2\u0187\u0188\t\13\2\2\u0188O\3\2\2\2\27m\u0083\u009b\u009d\u00ae"+
"\u00b7\u00e7\u00ef\u00f1\u00fb\u0104\u010b\u011d\u015c\u0162\u0175\u0178"+
"\u017c\u017f\u0183\u0185";
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);
}
}
}