Please wait. This can take some minutes ...
Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
com.blazebit.persistence.parser.JPQLNextParser Maven / Gradle / Ivy
// Generated from com\blazebit\persistence\parser\JPQLNextParser.g4 by ANTLR 4.7.2
package com.blazebit.persistence.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 JPQLNextParser extends Parser {
static { RuntimeMetaData.checkVersion("4.7.2", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
WS=1, INTEGER_LITERAL=2, BIG_INTEGER_LITERAL=3, LONG_LITERAL=4, FLOAT_LITERAL=5,
DOUBLE_LITERAL=6, BIG_DECIMAL_LITERAL=7, CHARACTER_LITERAL=8, STRING_LITERAL=9,
AFTER=10, ALL=11, AND=12, ANY=13, AS=14, ASC=15, BEFORE=16, BETWEEN=17,
BOTH=18, BY=19, CASE=20, COLLATE=21, CONTAINING=22, COUNT=23, CROSS=24,
CURRENT=25, CURRENT_DATE=26, CURRENT_INSTANT=27, CURRENT_TIME=28, CURRENT_TIMESTAMP=29,
DELETE=30, DESC=31, DISTINCT=32, ELSE=33, EMPTY=34, END=35, ENTRY=36,
ESCAPE=37, EXCEPT=38, EXCLUDE=39, EXISTS=40, FALSE=41, FETCH=42, FILTER=43,
FIRST=44, FOLLOWING=45, FROM=46, FULL=47, GROUP=48, GROUPS=49, HAVING=50,
IN=51, INDEX=52, INNER=53, INSERT=54, INTERSECT=55, INTO=56, IS=57, JOIN=58,
JUMP=59, KEY=60, LAST=61, LEADING=62, LEFT=63, LIKE=64, LIMIT=65, MEMBER=66,
NEW=67, NO=68, NOT=69, NULL=70, NULLS=71, OBJECT=72, OF=73, OFFSET=74,
OLD=75, ON=76, OR=77, ORDER=78, OTHERS=79, OUTER=80, OVER=81, PAGE=82,
PARTITION=83, PRECEDING=84, RANGE=85, RECURSIVE=86, RETURNING=87, RIGHT=88,
ROW=89, ROWS=90, SELECT=91, SET=92, SOME=93, THEN=94, TIES=95, TO=96,
TRAILING=97, TREAT=98, TRIM=99, TRUE=100, TYPE=101, UNBOUNDED=102, UNION=103,
UPDATE=104, VALUE=105, VALUES=106, WHEN=107, WHERE=108, WINDOW=109, WITH=110,
WITHIN=111, TIMESTAMP_ESCAPE_START=112, DATE_ESCAPE_START=113, TIME_ESCAPE_START=114,
TEMPORAL_ESCAPE_END=115, EQUAL=116, NOT_EQUAL=117, GREATER=118, GREATER_EQUAL=119,
LESS=120, LESS_EQUAL=121, COMMA=122, DOT=123, LP=124, RP=125, LB=126,
RB=127, PLUS=128, MINUS=129, ASTERISK=130, SLASH=131, PERCENT=132, COLON=133,
DOUBLE_PIPE=134, QUESTION_MARK=135, DOLLAR=136, IDENTIFIER=137, QUOTED_IDENTIFIER=138;
public static final int
RULE_parseStatement = 0, RULE_parseSelectExpression = 1, RULE_parsePathExpression = 2,
RULE_parseExpression = 3, RULE_parseInItemExpression = 4, RULE_parseInItemOrPathExpression = 5,
RULE_parsePredicate = 6, RULE_withQuery = 7, RULE_simpleStatement = 8,
RULE_selectStatement = 9, RULE_subQuery = 10, RULE_subQuerySpecification = 11,
RULE_subQueryOrderByClause = 12, RULE_deleteStatement = 13, RULE_updateStatement = 14,
RULE_insertStatement = 15, RULE_dmlAttributeName = 16, RULE_targetFieldsSpecification = 17,
RULE_returningClause = 18, RULE_querySpecification = 19, RULE_fromClause = 20,
RULE_subQueryFromClause = 21, RULE_fromItem = 22, RULE_subQueryFromItem = 23,
RULE_fromItemElement = 24, RULE_fromItemValuesItem = 25, RULE_entityName = 26,
RULE_identificationVariable = 27, RULE_crossJoin = 28, RULE_inCollectionJoin = 29,
RULE_qualifiedJoin = 30, RULE_subQueryQualifiedJoin = 31, RULE_joinItemElement = 32,
RULE_joinExpression = 33, RULE_joinTypeQualifier = 34, RULE_qualifiedJoinPredicate = 35,
RULE_selectClause = 36, RULE_subQuerySelectClause = 37, RULE_selectItem = 38,
RULE_subQuerySelectItem = 39, RULE_selectExpression = 40, RULE_resultIdentifier = 41,
RULE_mapEntrySelectExpression = 42, RULE_constructorExpression = 43, RULE_constructorItem = 44,
RULE_objectSelectExpression = 45, RULE_path = 46, RULE_macroPath = 47,
RULE_outerPath = 48, RULE_qualifiedPath = 49, RULE_simpleSubpath = 50,
RULE_generalSubpath = 51, RULE_groupByClause = 52, RULE_groupingValue = 53,
RULE_havingClause = 54, RULE_orderByClause = 55, RULE_orderByItem = 56,
RULE_windowClause = 57, RULE_windowDefinition = 58, RULE_partitionByClause = 59,
RULE_frameClause = 60, RULE_frameStart = 61, RULE_frameEnd = 62, RULE_frameExclusionClause = 63,
RULE_limitClause = 64, RULE_offsetClause = 65, RULE_parameterOrNumberLiteral = 66,
RULE_keysetClause = 67, RULE_parameterOrLiteral = 68, RULE_entityTypeOrEnumLiteral = 69,
RULE_whereClause = 70, RULE_expression = 71, RULE_predicate = 72, RULE_predicateOrExpression = 73,
RULE_inList = 74, RULE_entityType = 75, RULE_simpleCaseWhen = 76, RULE_searchedCaseWhen = 77,
RULE_literal = 78, RULE_timestampLiteral = 79, RULE_dateLiteral = 80,
RULE_timeLiteral = 81, RULE_dateTimeLiteralText = 82, RULE_parameter = 83,
RULE_function = 84, RULE_trimSpecification = 85, RULE_trimCharacter = 86,
RULE_identifier = 87, RULE_identifierNonStart = 88;
private static String[] makeRuleNames() {
return new String[] {
"parseStatement", "parseSelectExpression", "parsePathExpression", "parseExpression",
"parseInItemExpression", "parseInItemOrPathExpression", "parsePredicate",
"withQuery", "simpleStatement", "selectStatement", "subQuery", "subQuerySpecification",
"subQueryOrderByClause", "deleteStatement", "updateStatement", "insertStatement",
"dmlAttributeName", "targetFieldsSpecification", "returningClause", "querySpecification",
"fromClause", "subQueryFromClause", "fromItem", "subQueryFromItem", "fromItemElement",
"fromItemValuesItem", "entityName", "identificationVariable", "crossJoin",
"inCollectionJoin", "qualifiedJoin", "subQueryQualifiedJoin", "joinItemElement",
"joinExpression", "joinTypeQualifier", "qualifiedJoinPredicate", "selectClause",
"subQuerySelectClause", "selectItem", "subQuerySelectItem", "selectExpression",
"resultIdentifier", "mapEntrySelectExpression", "constructorExpression",
"constructorItem", "objectSelectExpression", "path", "macroPath", "outerPath",
"qualifiedPath", "simpleSubpath", "generalSubpath", "groupByClause",
"groupingValue", "havingClause", "orderByClause", "orderByItem", "windowClause",
"windowDefinition", "partitionByClause", "frameClause", "frameStart",
"frameEnd", "frameExclusionClause", "limitClause", "offsetClause", "parameterOrNumberLiteral",
"keysetClause", "parameterOrLiteral", "entityTypeOrEnumLiteral", "whereClause",
"expression", "predicate", "predicateOrExpression", "inList", "entityType",
"simpleCaseWhen", "searchedCaseWhen", "literal", "timestampLiteral",
"dateLiteral", "timeLiteral", "dateTimeLiteralText", "parameter", "function",
"trimSpecification", "trimCharacter", "identifier", "identifierNonStart"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
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, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, "'{ts'", "'{d'", "'{t'", "'}'", "'='", null,
"'>'", "'>='", "'<'", "'<='", "','", "'.'", "'('", "')'", "'['", "']'",
"'+'", "'-'", "'*'", "'/'", "'%'", "':'", "'||'", "'?'", "'$'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, "WS", "INTEGER_LITERAL", "BIG_INTEGER_LITERAL", "LONG_LITERAL",
"FLOAT_LITERAL", "DOUBLE_LITERAL", "BIG_DECIMAL_LITERAL", "CHARACTER_LITERAL",
"STRING_LITERAL", "AFTER", "ALL", "AND", "ANY", "AS", "ASC", "BEFORE",
"BETWEEN", "BOTH", "BY", "CASE", "COLLATE", "CONTAINING", "COUNT", "CROSS",
"CURRENT", "CURRENT_DATE", "CURRENT_INSTANT", "CURRENT_TIME", "CURRENT_TIMESTAMP",
"DELETE", "DESC", "DISTINCT", "ELSE", "EMPTY", "END", "ENTRY", "ESCAPE",
"EXCEPT", "EXCLUDE", "EXISTS", "FALSE", "FETCH", "FILTER", "FIRST", "FOLLOWING",
"FROM", "FULL", "GROUP", "GROUPS", "HAVING", "IN", "INDEX", "INNER",
"INSERT", "INTERSECT", "INTO", "IS", "JOIN", "JUMP", "KEY", "LAST", "LEADING",
"LEFT", "LIKE", "LIMIT", "MEMBER", "NEW", "NO", "NOT", "NULL", "NULLS",
"OBJECT", "OF", "OFFSET", "OLD", "ON", "OR", "ORDER", "OTHERS", "OUTER",
"OVER", "PAGE", "PARTITION", "PRECEDING", "RANGE", "RECURSIVE", "RETURNING",
"RIGHT", "ROW", "ROWS", "SELECT", "SET", "SOME", "THEN", "TIES", "TO",
"TRAILING", "TREAT", "TRIM", "TRUE", "TYPE", "UNBOUNDED", "UNION", "UPDATE",
"VALUE", "VALUES", "WHEN", "WHERE", "WINDOW", "WITH", "WITHIN", "TIMESTAMP_ESCAPE_START",
"DATE_ESCAPE_START", "TIME_ESCAPE_START", "TEMPORAL_ESCAPE_END", "EQUAL",
"NOT_EQUAL", "GREATER", "GREATER_EQUAL", "LESS", "LESS_EQUAL", "COMMA",
"DOT", "LP", "RP", "LB", "RB", "PLUS", "MINUS", "ASTERISK", "SLASH",
"PERCENT", "COLON", "DOUBLE_PIPE", "QUESTION_MARK", "DOLLAR", "IDENTIFIER",
"QUOTED_IDENTIFIER"
};
}
private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
/**
* @deprecated Use {@link #VOCABULARY} instead.
*/
@Deprecated
public static final String[] tokenNames;
static {
tokenNames = new String[_SYMBOLIC_NAMES.length];
for (int i = 0; i < tokenNames.length; i++) {
tokenNames[i] = VOCABULARY.getLiteralName(i);
if (tokenNames[i] == null) {
tokenNames[i] = VOCABULARY.getSymbolicName(i);
}
if (tokenNames[i] == null) {
tokenNames[i] = "";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "JPQLNextParser.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public JPQLNextParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class ParseStatementContext extends ParserRuleContext {
public SimpleStatementContext simpleStatement() {
return getRuleContext(SimpleStatementContext.class,0);
}
public TerminalNode EOF() { return getToken(JPQLNextParser.EOF, 0); }
public TerminalNode WITH() { return getToken(JPQLNextParser.WITH, 0); }
public WithQueryContext withQuery() {
return getRuleContext(WithQueryContext.class,0);
}
public TerminalNode RECURSIVE() { return getToken(JPQLNextParser.RECURSIVE, 0); }
public ParseStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parseStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterParseStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitParseStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitParseStatement(this);
else return visitor.visitChildren(this);
}
}
public final ParseStatementContext parseStatement() throws RecognitionException {
ParseStatementContext _localctx = new ParseStatementContext(_ctx, getState());
enterRule(_localctx, 0, RULE_parseStatement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(183);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(178);
match(WITH);
setState(180);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
case 1:
{
setState(179);
match(RECURSIVE);
}
break;
}
setState(182);
withQuery();
}
}
setState(185);
simpleStatement();
setState(186);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParseSelectExpressionContext extends ParserRuleContext {
public SelectExpressionContext selectExpression() {
return getRuleContext(SelectExpressionContext.class,0);
}
public TerminalNode EOF() { return getToken(JPQLNextParser.EOF, 0); }
public ParseSelectExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parseSelectExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterParseSelectExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitParseSelectExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitParseSelectExpression(this);
else return visitor.visitChildren(this);
}
}
public final ParseSelectExpressionContext parseSelectExpression() throws RecognitionException {
ParseSelectExpressionContext _localctx = new ParseSelectExpressionContext(_ctx, getState());
enterRule(_localctx, 2, RULE_parseSelectExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(188);
selectExpression();
setState(189);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParsePathExpressionContext extends ParserRuleContext {
public PathContext path() {
return getRuleContext(PathContext.class,0);
}
public TerminalNode EOF() { return getToken(JPQLNextParser.EOF, 0); }
public OuterPathContext outerPath() {
return getRuleContext(OuterPathContext.class,0);
}
public MacroPathContext macroPath() {
return getRuleContext(MacroPathContext.class,0);
}
public ParsePathExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parsePathExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterParsePathExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitParsePathExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitParsePathExpression(this);
else return visitor.visitChildren(this);
}
}
public final ParsePathExpressionContext parsePathExpression() throws RecognitionException {
ParsePathExpressionContext _localctx = new ParsePathExpressionContext(_ctx, getState());
enterRule(_localctx, 4, RULE_parsePathExpression);
try {
setState(200);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(191);
path();
setState(192);
match(EOF);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(194);
outerPath();
setState(195);
match(EOF);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(197);
macroPath();
setState(198);
match(EOF);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParseExpressionContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode EOF() { return getToken(JPQLNextParser.EOF, 0); }
public ParseExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parseExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterParseExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitParseExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitParseExpression(this);
else return visitor.visitChildren(this);
}
}
public final ParseExpressionContext parseExpression() throws RecognitionException {
ParseExpressionContext _localctx = new ParseExpressionContext(_ctx, getState());
enterRule(_localctx, 6, RULE_parseExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(202);
expression(0);
setState(203);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParseInItemExpressionContext extends ParserRuleContext {
public ParameterOrLiteralContext parameterOrLiteral() {
return getRuleContext(ParameterOrLiteralContext.class,0);
}
public TerminalNode EOF() { return getToken(JPQLNextParser.EOF, 0); }
public EntityTypeOrEnumLiteralContext entityTypeOrEnumLiteral() {
return getRuleContext(EntityTypeOrEnumLiteralContext.class,0);
}
public ParseInItemExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parseInItemExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterParseInItemExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitParseInItemExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitParseInItemExpression(this);
else return visitor.visitChildren(this);
}
}
public final ParseInItemExpressionContext parseInItemExpression() throws RecognitionException {
ParseInItemExpressionContext _localctx = new ParseInItemExpressionContext(_ctx, getState());
enterRule(_localctx, 8, RULE_parseInItemExpression);
try {
setState(211);
_errHandler.sync(this);
switch (_input.LA(1)) {
case INTEGER_LITERAL:
case BIG_INTEGER_LITERAL:
case LONG_LITERAL:
case FLOAT_LITERAL:
case DOUBLE_LITERAL:
case BIG_DECIMAL_LITERAL:
case CHARACTER_LITERAL:
case STRING_LITERAL:
case FALSE:
case NULL:
case TRUE:
case TIMESTAMP_ESCAPE_START:
case DATE_ESCAPE_START:
case TIME_ESCAPE_START:
case COLON:
case QUESTION_MARK:
enterOuterAlt(_localctx, 1);
{
setState(205);
parameterOrLiteral();
setState(206);
match(EOF);
}
break;
case AFTER:
case ALL:
case AND:
case ANY:
case AS:
case ASC:
case BEFORE:
case BETWEEN:
case BOTH:
case BY:
case CASE:
case COLLATE:
case CONTAINING:
case COUNT:
case CROSS:
case CURRENT:
case DELETE:
case DESC:
case DISTINCT:
case ELSE:
case EMPTY:
case END:
case ENTRY:
case ESCAPE:
case EXCEPT:
case EXCLUDE:
case EXISTS:
case FETCH:
case FILTER:
case FIRST:
case FOLLOWING:
case FROM:
case FULL:
case GROUP:
case GROUPS:
case HAVING:
case IN:
case INDEX:
case INNER:
case INSERT:
case INTERSECT:
case INTO:
case IS:
case JOIN:
case JUMP:
case KEY:
case LAST:
case LEADING:
case LEFT:
case LIKE:
case LIMIT:
case MEMBER:
case NEW:
case NO:
case NOT:
case NULLS:
case OBJECT:
case OF:
case OFFSET:
case ON:
case OR:
case ORDER:
case OTHERS:
case OUTER:
case OVER:
case PAGE:
case PARTITION:
case PRECEDING:
case RANGE:
case RECURSIVE:
case RETURNING:
case RIGHT:
case ROW:
case ROWS:
case SELECT:
case SET:
case SOME:
case THEN:
case TIES:
case TO:
case TRAILING:
case TREAT:
case TRIM:
case TYPE:
case UNBOUNDED:
case UNION:
case UPDATE:
case VALUE:
case VALUES:
case WHEN:
case WHERE:
case WINDOW:
case WITH:
case IDENTIFIER:
enterOuterAlt(_localctx, 2);
{
setState(208);
entityTypeOrEnumLiteral();
setState(209);
match(EOF);
}
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 ParseInItemOrPathExpressionContext extends ParserRuleContext {
public ParameterOrLiteralContext parameterOrLiteral() {
return getRuleContext(ParameterOrLiteralContext.class,0);
}
public TerminalNode EOF() { return getToken(JPQLNextParser.EOF, 0); }
public ParsePathExpressionContext parsePathExpression() {
return getRuleContext(ParsePathExpressionContext.class,0);
}
public ParseInItemOrPathExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parseInItemOrPathExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterParseInItemOrPathExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitParseInItemOrPathExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitParseInItemOrPathExpression(this);
else return visitor.visitChildren(this);
}
}
public final ParseInItemOrPathExpressionContext parseInItemOrPathExpression() throws RecognitionException {
ParseInItemOrPathExpressionContext _localctx = new ParseInItemOrPathExpressionContext(_ctx, getState());
enterRule(_localctx, 10, RULE_parseInItemOrPathExpression);
try {
setState(217);
_errHandler.sync(this);
switch (_input.LA(1)) {
case INTEGER_LITERAL:
case BIG_INTEGER_LITERAL:
case LONG_LITERAL:
case FLOAT_LITERAL:
case DOUBLE_LITERAL:
case BIG_DECIMAL_LITERAL:
case CHARACTER_LITERAL:
case STRING_LITERAL:
case FALSE:
case NULL:
case TRUE:
case TIMESTAMP_ESCAPE_START:
case DATE_ESCAPE_START:
case TIME_ESCAPE_START:
case COLON:
case QUESTION_MARK:
enterOuterAlt(_localctx, 1);
{
setState(213);
parameterOrLiteral();
setState(214);
match(EOF);
}
break;
case AFTER:
case ALL:
case AND:
case ANY:
case AS:
case ASC:
case BEFORE:
case BETWEEN:
case BOTH:
case BY:
case CASE:
case COLLATE:
case CONTAINING:
case COUNT:
case CROSS:
case CURRENT:
case DELETE:
case DESC:
case DISTINCT:
case ELSE:
case EMPTY:
case END:
case ENTRY:
case ESCAPE:
case EXCEPT:
case EXCLUDE:
case EXISTS:
case FETCH:
case FILTER:
case FIRST:
case FOLLOWING:
case FROM:
case FULL:
case GROUP:
case GROUPS:
case HAVING:
case IN:
case INDEX:
case INNER:
case INSERT:
case INTERSECT:
case INTO:
case IS:
case JOIN:
case JUMP:
case KEY:
case LAST:
case LEADING:
case LEFT:
case LIKE:
case LIMIT:
case MEMBER:
case NEW:
case NO:
case NOT:
case NULLS:
case OBJECT:
case OF:
case OFFSET:
case ON:
case OR:
case ORDER:
case OTHERS:
case OUTER:
case OVER:
case PAGE:
case PARTITION:
case PRECEDING:
case RANGE:
case RECURSIVE:
case RETURNING:
case RIGHT:
case ROW:
case ROWS:
case SELECT:
case SET:
case SOME:
case THEN:
case TIES:
case TO:
case TRAILING:
case TREAT:
case TRIM:
case TYPE:
case UNBOUNDED:
case UNION:
case UPDATE:
case VALUE:
case VALUES:
case WHEN:
case WHERE:
case WINDOW:
case WITH:
case IDENTIFIER:
enterOuterAlt(_localctx, 2);
{
setState(216);
parsePathExpression();
}
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 ParsePredicateContext extends ParserRuleContext {
public PredicateContext predicate() {
return getRuleContext(PredicateContext.class,0);
}
public TerminalNode EOF() { return getToken(JPQLNextParser.EOF, 0); }
public ParsePredicateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parsePredicate; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterParsePredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitParsePredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitParsePredicate(this);
else return visitor.visitChildren(this);
}
}
public final ParsePredicateContext parsePredicate() throws RecognitionException {
ParsePredicateContext _localctx = new ParsePredicateContext(_ctx, getState());
enterRule(_localctx, 12, RULE_parsePredicate);
try {
enterOuterAlt(_localctx, 1);
{
setState(219);
predicate(0);
setState(220);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WithQueryContext extends ParserRuleContext {
public EntityNameContext entityName() {
return getRuleContext(EntityNameContext.class,0);
}
public List LP() { return getTokens(JPQLNextParser.LP); }
public TerminalNode LP(int i) {
return getToken(JPQLNextParser.LP, i);
}
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public List RP() { return getTokens(JPQLNextParser.RP); }
public TerminalNode RP(int i) {
return getToken(JPQLNextParser.RP, i);
}
public TerminalNode AS() { return getToken(JPQLNextParser.AS, 0); }
public SimpleStatementContext simpleStatement() {
return getRuleContext(SimpleStatementContext.class,0);
}
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public WithQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_withQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterWithQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitWithQuery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitWithQuery(this);
else return visitor.visitChildren(this);
}
}
public final WithQueryContext withQuery() throws RecognitionException {
WithQueryContext _localctx = new WithQueryContext(_ctx, getState());
enterRule(_localctx, 14, RULE_withQuery);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(222);
entityName();
setState(223);
match(LP);
setState(224);
identifier();
setState(229);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(225);
match(COMMA);
setState(226);
identifier();
}
}
setState(231);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(232);
match(RP);
setState(233);
match(AS);
setState(234);
match(LP);
setState(235);
simpleStatement();
setState(236);
match(RP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SimpleStatementContext extends ParserRuleContext {
public SelectStatementContext selectStatement() {
return getRuleContext(SelectStatementContext.class,0);
}
public UpdateStatementContext updateStatement() {
return getRuleContext(UpdateStatementContext.class,0);
}
public DeleteStatementContext deleteStatement() {
return getRuleContext(DeleteStatementContext.class,0);
}
public InsertStatementContext insertStatement() {
return getRuleContext(InsertStatementContext.class,0);
}
public SimpleStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simpleStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSimpleStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSimpleStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSimpleStatement(this);
else return visitor.visitChildren(this);
}
}
public final SimpleStatementContext simpleStatement() throws RecognitionException {
SimpleStatementContext _localctx = new SimpleStatementContext(_ctx, getState());
enterRule(_localctx, 16, RULE_simpleStatement);
try {
setState(242);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FROM:
case SELECT:
case LP:
enterOuterAlt(_localctx, 1);
{
setState(238);
selectStatement();
}
break;
case UPDATE:
enterOuterAlt(_localctx, 2);
{
setState(239);
updateStatement();
}
break;
case DELETE:
enterOuterAlt(_localctx, 3);
{
setState(240);
deleteStatement();
}
break;
case INSERT:
enterOuterAlt(_localctx, 4);
{
setState(241);
insertStatement();
}
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 SelectStatementContext extends ParserRuleContext {
public QuerySpecificationContext querySpecification() {
return getRuleContext(QuerySpecificationContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public List selectStatement() {
return getRuleContexts(SelectStatementContext.class);
}
public SelectStatementContext selectStatement(int i) {
return getRuleContext(SelectStatementContext.class,i);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public TerminalNode UNION() { return getToken(JPQLNextParser.UNION, 0); }
public TerminalNode INTERSECT() { return getToken(JPQLNextParser.INTERSECT, 0); }
public TerminalNode EXCEPT() { return getToken(JPQLNextParser.EXCEPT, 0); }
public TerminalNode ALL() { return getToken(JPQLNextParser.ALL, 0); }
public TerminalNode DISTINCT() { return getToken(JPQLNextParser.DISTINCT, 0); }
public SelectStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSelectStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSelectStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSelectStatement(this);
else return visitor.visitChildren(this);
}
}
public final SelectStatementContext selectStatement() throws RecognitionException {
SelectStatementContext _localctx = new SelectStatementContext(_ctx, getState());
enterRule(_localctx, 18, RULE_selectStatement);
int _la;
try {
setState(254);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FROM:
case SELECT:
enterOuterAlt(_localctx, 1);
{
setState(244);
querySpecification();
}
break;
case LP:
enterOuterAlt(_localctx, 2);
{
setState(245);
match(LP);
setState(246);
selectStatement();
setState(247);
match(RP);
setState(248);
_la = _input.LA(1);
if ( !(_la==EXCEPT || _la==INTERSECT || _la==UNION) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(250);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(249);
_la = _input.LA(1);
if ( !(_la==ALL || _la==DISTINCT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(252);
selectStatement();
}
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 SubQueryContext extends ParserRuleContext {
public SubQuerySpecificationContext subQuerySpecification() {
return getRuleContext(SubQuerySpecificationContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public List subQuery() {
return getRuleContexts(SubQueryContext.class);
}
public SubQueryContext subQuery(int i) {
return getRuleContext(SubQueryContext.class,i);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public TerminalNode UNION() { return getToken(JPQLNextParser.UNION, 0); }
public TerminalNode INTERSECT() { return getToken(JPQLNextParser.INTERSECT, 0); }
public TerminalNode EXCEPT() { return getToken(JPQLNextParser.EXCEPT, 0); }
public TerminalNode ALL() { return getToken(JPQLNextParser.ALL, 0); }
public TerminalNode DISTINCT() { return getToken(JPQLNextParser.DISTINCT, 0); }
public SubQueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subQuery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSubQuery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSubQuery(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSubQuery(this);
else return visitor.visitChildren(this);
}
}
public final SubQueryContext subQuery() throws RecognitionException {
SubQueryContext _localctx = new SubQueryContext(_ctx, getState());
enterRule(_localctx, 20, RULE_subQuery);
int _la;
try {
setState(266);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SELECT:
enterOuterAlt(_localctx, 1);
{
setState(256);
subQuerySpecification();
}
break;
case LP:
enterOuterAlt(_localctx, 2);
{
setState(257);
match(LP);
setState(258);
subQuery();
setState(259);
match(RP);
setState(260);
_la = _input.LA(1);
if ( !(_la==EXCEPT || _la==INTERSECT || _la==UNION) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(262);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(261);
_la = _input.LA(1);
if ( !(_la==ALL || _la==DISTINCT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(264);
subQuery();
}
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 SubQuerySpecificationContext extends ParserRuleContext {
public SubQuerySelectClauseContext subQuerySelectClause() {
return getRuleContext(SubQuerySelectClauseContext.class,0);
}
public SubQueryFromClauseContext subQueryFromClause() {
return getRuleContext(SubQueryFromClauseContext.class,0);
}
public KeysetClauseContext keysetClause() {
return getRuleContext(KeysetClauseContext.class,0);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public GroupByClauseContext groupByClause() {
return getRuleContext(GroupByClauseContext.class,0);
}
public HavingClauseContext havingClause() {
return getRuleContext(HavingClauseContext.class,0);
}
public SubQueryContext subQuery() {
return getRuleContext(SubQueryContext.class,0);
}
public SubQueryOrderByClauseContext subQueryOrderByClause() {
return getRuleContext(SubQueryOrderByClauseContext.class,0);
}
public TerminalNode UNION() { return getToken(JPQLNextParser.UNION, 0); }
public TerminalNode INTERSECT() { return getToken(JPQLNextParser.INTERSECT, 0); }
public TerminalNode EXCEPT() { return getToken(JPQLNextParser.EXCEPT, 0); }
public TerminalNode ALL() { return getToken(JPQLNextParser.ALL, 0); }
public TerminalNode DISTINCT() { return getToken(JPQLNextParser.DISTINCT, 0); }
public SubQuerySpecificationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subQuerySpecification; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSubQuerySpecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSubQuerySpecification(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSubQuerySpecification(this);
else return visitor.visitChildren(this);
}
}
public final SubQuerySpecificationContext subQuerySpecification() throws RecognitionException {
SubQuerySpecificationContext _localctx = new SubQuerySpecificationContext(_ctx, getState());
enterRule(_localctx, 22, RULE_subQuerySpecification);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(268);
subQuerySelectClause();
setState(269);
subQueryFromClause();
setState(271);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AFTER || _la==BEFORE) {
{
setState(270);
keysetClause();
}
}
setState(274);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(273);
whereClause();
}
}
setState(277);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GROUP) {
{
setState(276);
groupByClause();
}
}
setState(280);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==HAVING) {
{
setState(279);
havingClause();
}
}
setState(287);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXCEPT || _la==INTERSECT || _la==UNION) {
{
setState(282);
_la = _input.LA(1);
if ( !(_la==EXCEPT || _la==INTERSECT || _la==UNION) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(284);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(283);
_la = _input.LA(1);
if ( !(_la==ALL || _la==DISTINCT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(286);
subQuery();
}
}
setState(290);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
case 1:
{
setState(289);
subQueryOrderByClause();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SubQueryOrderByClauseContext extends ParserRuleContext {
public OrderByClauseContext orderByClause() {
return getRuleContext(OrderByClauseContext.class,0);
}
public OffsetClauseContext offsetClause() {
return getRuleContext(OffsetClauseContext.class,0);
}
public LimitClauseContext limitClause() {
return getRuleContext(LimitClauseContext.class,0);
}
public SubQueryOrderByClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subQueryOrderByClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSubQueryOrderByClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSubQueryOrderByClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSubQueryOrderByClause(this);
else return visitor.visitChildren(this);
}
}
public final SubQueryOrderByClauseContext subQueryOrderByClause() throws RecognitionException {
SubQueryOrderByClauseContext _localctx = new SubQueryOrderByClauseContext(_ctx, getState());
enterRule(_localctx, 24, RULE_subQueryOrderByClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(292);
orderByClause();
setState(298);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LIMIT:
{
{
setState(293);
limitClause();
setState(295);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==JUMP || _la==OFFSET) {
{
setState(294);
offsetClause();
}
}
}
}
break;
case JUMP:
case OFFSET:
{
setState(297);
offsetClause();
}
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 DeleteStatementContext extends ParserRuleContext {
public TerminalNode DELETE() { return getToken(JPQLNextParser.DELETE, 0); }
public EntityNameContext entityName() {
return getRuleContext(EntityNameContext.class,0);
}
public TerminalNode FROM() { return getToken(JPQLNextParser.FROM, 0); }
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public SimpleSubpathContext simpleSubpath() {
return getRuleContext(SimpleSubpathContext.class,0);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public IdentificationVariableContext identificationVariable() {
return getRuleContext(IdentificationVariableContext.class,0);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public ReturningClauseContext returningClause() {
return getRuleContext(ReturningClauseContext.class,0);
}
public DeleteStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_deleteStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterDeleteStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitDeleteStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitDeleteStatement(this);
else return visitor.visitChildren(this);
}
}
public final DeleteStatementContext deleteStatement() throws RecognitionException {
DeleteStatementContext _localctx = new DeleteStatementContext(_ctx, getState());
enterRule(_localctx, 26, RULE_deleteStatement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(300);
match(DELETE);
setState(302);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
case 1:
{
setState(301);
match(FROM);
}
break;
}
setState(304);
entityName();
setState(309);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LP) {
{
setState(305);
match(LP);
setState(306);
simpleSubpath();
setState(307);
match(RP);
}
}
setState(312);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==IDENTIFIER) {
{
setState(311);
identificationVariable();
}
}
setState(315);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(314);
whereClause();
}
}
setState(318);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RETURNING) {
{
setState(317);
returningClause();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UpdateStatementContext extends ParserRuleContext {
public TerminalNode UPDATE() { return getToken(JPQLNextParser.UPDATE, 0); }
public EntityNameContext entityName() {
return getRuleContext(EntityNameContext.class,0);
}
public TerminalNode SET() { return getToken(JPQLNextParser.SET, 0); }
public List dmlAttributeName() {
return getRuleContexts(DmlAttributeNameContext.class);
}
public DmlAttributeNameContext dmlAttributeName(int i) {
return getRuleContext(DmlAttributeNameContext.class,i);
}
public List EQUAL() { return getTokens(JPQLNextParser.EQUAL); }
public TerminalNode EQUAL(int i) {
return getToken(JPQLNextParser.EQUAL, i);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode FROM() { return getToken(JPQLNextParser.FROM, 0); }
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public SimpleSubpathContext simpleSubpath() {
return getRuleContext(SimpleSubpathContext.class,0);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public IdentificationVariableContext identificationVariable() {
return getRuleContext(IdentificationVariableContext.class,0);
}
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public ReturningClauseContext returningClause() {
return getRuleContext(ReturningClauseContext.class,0);
}
public UpdateStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_updateStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterUpdateStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitUpdateStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitUpdateStatement(this);
else return visitor.visitChildren(this);
}
}
public final UpdateStatementContext updateStatement() throws RecognitionException {
UpdateStatementContext _localctx = new UpdateStatementContext(_ctx, getState());
enterRule(_localctx, 28, RULE_updateStatement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(320);
match(UPDATE);
setState(322);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
case 1:
{
setState(321);
match(FROM);
}
break;
}
setState(324);
entityName();
setState(329);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LP) {
{
setState(325);
match(LP);
setState(326);
simpleSubpath();
setState(327);
match(RP);
}
}
setState(332);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==IDENTIFIER) {
{
setState(331);
identificationVariable();
}
}
setState(334);
match(SET);
setState(335);
dmlAttributeName();
setState(336);
match(EQUAL);
setState(337);
expression(0);
setState(345);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(338);
match(COMMA);
setState(339);
dmlAttributeName();
setState(340);
match(EQUAL);
setState(341);
expression(0);
}
}
setState(347);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(349);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(348);
whereClause();
}
}
setState(352);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RETURNING) {
{
setState(351);
returningClause();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InsertStatementContext extends ParserRuleContext {
public TerminalNode INSERT() { return getToken(JPQLNextParser.INSERT, 0); }
public TerminalNode INTO() { return getToken(JPQLNextParser.INTO, 0); }
public EntityNameContext entityName() {
return getRuleContext(EntityNameContext.class,0);
}
public TargetFieldsSpecificationContext targetFieldsSpecification() {
return getRuleContext(TargetFieldsSpecificationContext.class,0);
}
public QuerySpecificationContext querySpecification() {
return getRuleContext(QuerySpecificationContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public SimpleSubpathContext simpleSubpath() {
return getRuleContext(SimpleSubpathContext.class,0);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public ReturningClauseContext returningClause() {
return getRuleContext(ReturningClauseContext.class,0);
}
public InsertStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_insertStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterInsertStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitInsertStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitInsertStatement(this);
else return visitor.visitChildren(this);
}
}
public final InsertStatementContext insertStatement() throws RecognitionException {
InsertStatementContext _localctx = new InsertStatementContext(_ctx, getState());
enterRule(_localctx, 30, RULE_insertStatement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(354);
match(INSERT);
setState(355);
match(INTO);
setState(356);
entityName();
setState(361);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
case 1:
{
setState(357);
match(LP);
setState(358);
simpleSubpath();
setState(359);
match(RP);
}
break;
}
setState(363);
targetFieldsSpecification();
setState(364);
querySpecification();
setState(366);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RETURNING) {
{
setState(365);
returningClause();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DmlAttributeNameContext extends ParserRuleContext {
public SimpleSubpathContext simpleSubpath() {
return getRuleContext(SimpleSubpathContext.class,0);
}
public TerminalNode KEY() { return getToken(JPQLNextParser.KEY, 0); }
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public PathContext path() {
return getRuleContext(PathContext.class,0);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public TerminalNode INDEX() { return getToken(JPQLNextParser.INDEX, 0); }
public DmlAttributeNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dmlAttributeName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterDmlAttributeName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitDmlAttributeName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitDmlAttributeName(this);
else return visitor.visitChildren(this);
}
}
public final DmlAttributeNameContext dmlAttributeName() throws RecognitionException {
DmlAttributeNameContext _localctx = new DmlAttributeNameContext(_ctx, getState());
enterRule(_localctx, 32, RULE_dmlAttributeName);
try {
setState(379);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(368);
simpleSubpath();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(369);
match(KEY);
setState(370);
match(LP);
setState(371);
path();
setState(372);
match(RP);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(374);
match(INDEX);
setState(375);
match(LP);
setState(376);
path();
setState(377);
match(RP);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TargetFieldsSpecificationContext extends ParserRuleContext {
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public List dmlAttributeName() {
return getRuleContexts(DmlAttributeNameContext.class);
}
public DmlAttributeNameContext dmlAttributeName(int i) {
return getRuleContext(DmlAttributeNameContext.class,i);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public TargetFieldsSpecificationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_targetFieldsSpecification; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterTargetFieldsSpecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitTargetFieldsSpecification(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitTargetFieldsSpecification(this);
else return visitor.visitChildren(this);
}
}
public final TargetFieldsSpecificationContext targetFieldsSpecification() throws RecognitionException {
TargetFieldsSpecificationContext _localctx = new TargetFieldsSpecificationContext(_ctx, getState());
enterRule(_localctx, 34, RULE_targetFieldsSpecification);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(381);
match(LP);
setState(382);
dmlAttributeName();
setState(387);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(383);
match(COMMA);
setState(384);
dmlAttributeName();
}
}
setState(389);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(390);
match(RP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReturningClauseContext extends ParserRuleContext {
public TerminalNode RETURNING() { return getToken(JPQLNextParser.RETURNING, 0); }
public List simpleSubpath() {
return getRuleContexts(SimpleSubpathContext.class);
}
public SimpleSubpathContext simpleSubpath(int i) {
return getRuleContext(SimpleSubpathContext.class,i);
}
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public ReturningClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_returningClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterReturningClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitReturningClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitReturningClause(this);
else return visitor.visitChildren(this);
}
}
public final ReturningClauseContext returningClause() throws RecognitionException {
ReturningClauseContext _localctx = new ReturningClauseContext(_ctx, getState());
enterRule(_localctx, 36, RULE_returningClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(392);
match(RETURNING);
setState(393);
simpleSubpath();
setState(398);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(394);
match(COMMA);
setState(395);
simpleSubpath();
}
}
setState(400);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QuerySpecificationContext extends ParserRuleContext {
public FromClauseContext fromClause() {
return getRuleContext(FromClauseContext.class,0);
}
public SelectClauseContext selectClause() {
return getRuleContext(SelectClauseContext.class,0);
}
public KeysetClauseContext keysetClause() {
return getRuleContext(KeysetClauseContext.class,0);
}
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public GroupByClauseContext groupByClause() {
return getRuleContext(GroupByClauseContext.class,0);
}
public HavingClauseContext havingClause() {
return getRuleContext(HavingClauseContext.class,0);
}
public WindowClauseContext windowClause() {
return getRuleContext(WindowClauseContext.class,0);
}
public QuerySpecificationContext querySpecification() {
return getRuleContext(QuerySpecificationContext.class,0);
}
public OrderByClauseContext orderByClause() {
return getRuleContext(OrderByClauseContext.class,0);
}
public LimitClauseContext limitClause() {
return getRuleContext(LimitClauseContext.class,0);
}
public OffsetClauseContext offsetClause() {
return getRuleContext(OffsetClauseContext.class,0);
}
public TerminalNode UNION() { return getToken(JPQLNextParser.UNION, 0); }
public TerminalNode INTERSECT() { return getToken(JPQLNextParser.INTERSECT, 0); }
public TerminalNode EXCEPT() { return getToken(JPQLNextParser.EXCEPT, 0); }
public TerminalNode ALL() { return getToken(JPQLNextParser.ALL, 0); }
public TerminalNode DISTINCT() { return getToken(JPQLNextParser.DISTINCT, 0); }
public QuerySpecificationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_querySpecification; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterQuerySpecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitQuerySpecification(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitQuerySpecification(this);
else return visitor.visitChildren(this);
}
}
public final QuerySpecificationContext querySpecification() throws RecognitionException {
QuerySpecificationContext _localctx = new QuerySpecificationContext(_ctx, getState());
enterRule(_localctx, 38, RULE_querySpecification);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(402);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SELECT) {
{
setState(401);
selectClause();
}
}
setState(404);
fromClause();
setState(406);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AFTER || _la==BEFORE) {
{
setState(405);
keysetClause();
}
}
setState(409);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(408);
whereClause();
}
}
setState(412);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GROUP) {
{
setState(411);
groupByClause();
}
}
setState(415);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==HAVING) {
{
setState(414);
havingClause();
}
}
setState(418);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WINDOW) {
{
setState(417);
windowClause();
}
}
setState(425);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXCEPT || _la==INTERSECT || _la==UNION) {
{
setState(420);
_la = _input.LA(1);
if ( !(_la==EXCEPT || _la==INTERSECT || _la==UNION) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(422);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(421);
_la = _input.LA(1);
if ( !(_la==ALL || _la==DISTINCT) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(424);
querySpecification();
}
}
setState(428);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) {
case 1:
{
setState(427);
orderByClause();
}
break;
}
setState(431);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
case 1:
{
setState(430);
limitClause();
}
break;
}
setState(434);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,46,_ctx) ) {
case 1:
{
setState(433);
offsetClause();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FromClauseContext extends ParserRuleContext {
public TerminalNode FROM() { return getToken(JPQLNextParser.FROM, 0); }
public List fromItem() {
return getRuleContexts(FromItemContext.class);
}
public FromItemContext fromItem(int i) {
return getRuleContext(FromItemContext.class,i);
}
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public FromClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fromClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterFromClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitFromClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitFromClause(this);
else return visitor.visitChildren(this);
}
}
public final FromClauseContext fromClause() throws RecognitionException {
FromClauseContext _localctx = new FromClauseContext(_ctx, getState());
enterRule(_localctx, 40, RULE_fromClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(436);
match(FROM);
setState(437);
fromItem();
setState(442);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(438);
match(COMMA);
setState(439);
fromItem();
}
}
setState(444);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SubQueryFromClauseContext extends ParserRuleContext {
public TerminalNode FROM() { return getToken(JPQLNextParser.FROM, 0); }
public List subQueryFromItem() {
return getRuleContexts(SubQueryFromItemContext.class);
}
public SubQueryFromItemContext subQueryFromItem(int i) {
return getRuleContext(SubQueryFromItemContext.class,i);
}
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public SubQueryFromClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subQueryFromClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSubQueryFromClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSubQueryFromClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSubQueryFromClause(this);
else return visitor.visitChildren(this);
}
}
public final SubQueryFromClauseContext subQueryFromClause() throws RecognitionException {
SubQueryFromClauseContext _localctx = new SubQueryFromClauseContext(_ctx, getState());
enterRule(_localctx, 42, RULE_subQueryFromClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(445);
match(FROM);
setState(446);
subQueryFromItem();
setState(451);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(447);
match(COMMA);
setState(448);
subQueryFromItem();
}
}
setState(453);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FromItemContext extends ParserRuleContext {
public FromItemElementContext fromItemElement() {
return getRuleContext(FromItemElementContext.class,0);
}
public List crossJoin() {
return getRuleContexts(CrossJoinContext.class);
}
public CrossJoinContext crossJoin(int i) {
return getRuleContext(CrossJoinContext.class,i);
}
public List inCollectionJoin() {
return getRuleContexts(InCollectionJoinContext.class);
}
public InCollectionJoinContext inCollectionJoin(int i) {
return getRuleContext(InCollectionJoinContext.class,i);
}
public List qualifiedJoin() {
return getRuleContexts(QualifiedJoinContext.class);
}
public QualifiedJoinContext qualifiedJoin(int i) {
return getRuleContext(QualifiedJoinContext.class,i);
}
public FromItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fromItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterFromItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitFromItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitFromItem(this);
else return visitor.visitChildren(this);
}
}
public final FromItemContext fromItem() throws RecognitionException {
FromItemContext _localctx = new FromItemContext(_ctx, getState());
enterRule(_localctx, 44, RULE_fromItem);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(454);
fromItemElement();
setState(460);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,50,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
setState(458);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CROSS:
{
setState(455);
crossJoin();
}
break;
case COMMA:
{
setState(456);
inCollectionJoin();
}
break;
case FULL:
case INNER:
case JOIN:
case LEFT:
case OUTER:
case RIGHT:
{
setState(457);
qualifiedJoin();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
setState(462);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,50,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SubQueryFromItemContext extends ParserRuleContext {
public FromItemElementContext fromItemElement() {
return getRuleContext(FromItemElementContext.class,0);
}
public List crossJoin() {
return getRuleContexts(CrossJoinContext.class);
}
public CrossJoinContext crossJoin(int i) {
return getRuleContext(CrossJoinContext.class,i);
}
public List inCollectionJoin() {
return getRuleContexts(InCollectionJoinContext.class);
}
public InCollectionJoinContext inCollectionJoin(int i) {
return getRuleContext(InCollectionJoinContext.class,i);
}
public List subQueryQualifiedJoin() {
return getRuleContexts(SubQueryQualifiedJoinContext.class);
}
public SubQueryQualifiedJoinContext subQueryQualifiedJoin(int i) {
return getRuleContext(SubQueryQualifiedJoinContext.class,i);
}
public SubQueryFromItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subQueryFromItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSubQueryFromItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSubQueryFromItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSubQueryFromItem(this);
else return visitor.visitChildren(this);
}
}
public final SubQueryFromItemContext subQueryFromItem() throws RecognitionException {
SubQueryFromItemContext _localctx = new SubQueryFromItemContext(_ctx, getState());
enterRule(_localctx, 46, RULE_subQueryFromItem);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(463);
fromItemElement();
setState(469);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,52,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
setState(467);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CROSS:
{
setState(464);
crossJoin();
}
break;
case COMMA:
{
setState(465);
inCollectionJoin();
}
break;
case FULL:
case INNER:
case JOIN:
case LEFT:
case OUTER:
case RIGHT:
{
setState(466);
subQueryQualifiedJoin();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
setState(471);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,52,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FromItemElementContext extends ParserRuleContext {
public FromItemElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fromItemElement; }
public FromItemElementContext() { }
public void copyFrom(FromItemElementContext ctx) {
super.copyFrom(ctx);
}
}
public static class FromValuesListContext extends FromItemElementContext {
public EntityNameContext entityName() {
return getRuleContext(EntityNameContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode VALUES() { return getToken(JPQLNextParser.VALUES, 0); }
public List fromItemValuesItem() {
return getRuleContexts(FromItemValuesItemContext.class);
}
public FromItemValuesItemContext fromItemValuesItem(int i) {
return getRuleContext(FromItemValuesItemContext.class,i);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public IdentificationVariableContext identificationVariable() {
return getRuleContext(IdentificationVariableContext.class,0);
}
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public FromValuesListContext(FromItemElementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterFromValuesList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitFromValuesList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitFromValuesList(this);
else return visitor.visitChildren(this);
}
}
public static class FromOldOrNewContext extends FromItemElementContext {
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public EntityNameContext entityName() {
return getRuleContext(EntityNameContext.class,0);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public TerminalNode OLD() { return getToken(JPQLNextParser.OLD, 0); }
public TerminalNode NEW() { return getToken(JPQLNextParser.NEW, 0); }
public IdentificationVariableContext identificationVariable() {
return getRuleContext(IdentificationVariableContext.class,0);
}
public FromOldOrNewContext(FromItemElementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterFromOldOrNew(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitFromOldOrNew(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitFromOldOrNew(this);
else return visitor.visitChildren(this);
}
}
public static class FromEntityContext extends FromItemElementContext {
public EntityNameContext entityName() {
return getRuleContext(EntityNameContext.class,0);
}
public IdentificationVariableContext identificationVariable() {
return getRuleContext(IdentificationVariableContext.class,0);
}
public FromEntityContext(FromItemElementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterFromEntity(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitFromEntity(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitFromEntity(this);
else return visitor.visitChildren(this);
}
}
public static class FromSimpleValuesLikeEntityAttributeContext extends FromItemElementContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode INTEGER_LITERAL() { return getToken(JPQLNextParser.INTEGER_LITERAL, 0); }
public TerminalNode VALUES() { return getToken(JPQLNextParser.VALUES, 0); }
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public IdentificationVariableContext identificationVariable() {
return getRuleContext(IdentificationVariableContext.class,0);
}
public TerminalNode LIKE() { return getToken(JPQLNextParser.LIKE, 0); }
public EntityNameContext entityName() {
return getRuleContext(EntityNameContext.class,0);
}
public FromSimpleValuesLikeEntityAttributeContext(FromItemElementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterFromSimpleValuesLikeEntityAttribute(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitFromSimpleValuesLikeEntityAttribute(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitFromSimpleValuesLikeEntityAttribute(this);
else return visitor.visitChildren(this);
}
}
public static class FromSimpleValuesListContext extends FromItemElementContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode VALUES() { return getToken(JPQLNextParser.VALUES, 0); }
public List fromItemValuesItem() {
return getRuleContexts(FromItemValuesItemContext.class);
}
public FromItemValuesItemContext fromItemValuesItem(int i) {
return getRuleContext(FromItemValuesItemContext.class,i);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public IdentificationVariableContext identificationVariable() {
return getRuleContext(IdentificationVariableContext.class,0);
}
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public FromSimpleValuesListContext(FromItemElementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterFromSimpleValuesList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitFromSimpleValuesList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitFromSimpleValuesList(this);
else return visitor.visitChildren(this);
}
}
public static class FromValuesContext extends FromItemElementContext {
public EntityNameContext entityName() {
return getRuleContext(EntityNameContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode INTEGER_LITERAL() { return getToken(JPQLNextParser.INTEGER_LITERAL, 0); }
public TerminalNode VALUES() { return getToken(JPQLNextParser.VALUES, 0); }
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public IdentificationVariableContext identificationVariable() {
return getRuleContext(IdentificationVariableContext.class,0);
}
public FromValuesContext(FromItemElementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterFromValues(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitFromValues(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitFromValues(this);
else return visitor.visitChildren(this);
}
}
public final FromItemElementContext fromItemElement() throws RecognitionException {
FromItemElementContext _localctx = new FromItemElementContext(_ctx, getState());
enterRule(_localctx, 48, RULE_fromItemElement);
int _la;
try {
setState(529);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,58,_ctx) ) {
case 1:
_localctx = new FromEntityContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(472);
entityName();
setState(474);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==IDENTIFIER) {
{
setState(473);
identificationVariable();
}
}
}
break;
case 2:
_localctx = new FromValuesContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(476);
entityName();
setState(477);
match(LP);
setState(478);
match(INTEGER_LITERAL);
setState(479);
match(VALUES);
setState(480);
match(RP);
setState(481);
identificationVariable();
}
break;
case 3:
_localctx = new FromValuesListContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(483);
entityName();
setState(484);
match(LP);
setState(485);
match(VALUES);
setState(486);
fromItemValuesItem();
setState(491);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(487);
match(COMMA);
setState(488);
fromItemValuesItem();
}
}
setState(493);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(494);
match(RP);
setState(495);
identificationVariable();
}
break;
case 4:
_localctx = new FromSimpleValuesLikeEntityAttributeContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(497);
identifier();
setState(498);
match(LP);
setState(499);
match(INTEGER_LITERAL);
setState(500);
match(VALUES);
setState(503);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LIKE) {
{
setState(501);
match(LIKE);
setState(502);
entityName();
}
}
setState(505);
match(RP);
setState(506);
identificationVariable();
}
break;
case 5:
_localctx = new FromSimpleValuesListContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(508);
identifier();
setState(509);
match(LP);
setState(510);
match(VALUES);
setState(511);
fromItemValuesItem();
setState(516);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(512);
match(COMMA);
setState(513);
fromItemValuesItem();
}
}
setState(518);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(519);
match(RP);
setState(520);
identificationVariable();
}
break;
case 6:
_localctx = new FromOldOrNewContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(522);
_la = _input.LA(1);
if ( !(_la==NEW || _la==OLD) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(523);
match(LP);
setState(524);
entityName();
setState(525);
match(RP);
setState(527);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==IDENTIFIER) {
{
setState(526);
identificationVariable();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FromItemValuesItemContext extends ParserRuleContext {
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public List literal() {
return getRuleContexts(LiteralContext.class);
}
public LiteralContext literal(int i) {
return getRuleContext(LiteralContext.class,i);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public FromItemValuesItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fromItemValuesItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterFromItemValuesItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitFromItemValuesItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitFromItemValuesItem(this);
else return visitor.visitChildren(this);
}
}
public final FromItemValuesItemContext fromItemValuesItem() throws RecognitionException {
FromItemValuesItemContext _localctx = new FromItemValuesItemContext(_ctx, getState());
enterRule(_localctx, 50, RULE_fromItemValuesItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(531);
match(LP);
setState(532);
literal();
setState(537);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(533);
match(COMMA);
setState(534);
literal();
}
}
setState(539);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(540);
match(RP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EntityNameContext extends ParserRuleContext {
public SimpleSubpathContext simpleSubpath() {
return getRuleContext(SimpleSubpathContext.class,0);
}
public EntityNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_entityName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterEntityName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitEntityName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitEntityName(this);
else return visitor.visitChildren(this);
}
}
public final EntityNameContext entityName() throws RecognitionException {
EntityNameContext _localctx = new EntityNameContext(_ctx, getState());
enterRule(_localctx, 52, RULE_entityName);
try {
enterOuterAlt(_localctx, 1);
{
setState(542);
simpleSubpath();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IdentificationVariableContext extends ParserRuleContext {
public TerminalNode AS() { return getToken(JPQLNextParser.AS, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode IDENTIFIER() { return getToken(JPQLNextParser.IDENTIFIER, 0); }
public IdentificationVariableContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identificationVariable; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterIdentificationVariable(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitIdentificationVariable(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitIdentificationVariable(this);
else return visitor.visitChildren(this);
}
}
public final IdentificationVariableContext identificationVariable() throws RecognitionException {
IdentificationVariableContext _localctx = new IdentificationVariableContext(_ctx, getState());
enterRule(_localctx, 54, RULE_identificationVariable);
try {
setState(547);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AS:
enterOuterAlt(_localctx, 1);
{
{
setState(544);
match(AS);
setState(545);
identifier();
}
}
break;
case IDENTIFIER:
enterOuterAlt(_localctx, 2);
{
setState(546);
match(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;
}
public static class CrossJoinContext extends ParserRuleContext {
public TerminalNode CROSS() { return getToken(JPQLNextParser.CROSS, 0); }
public TerminalNode JOIN() { return getToken(JPQLNextParser.JOIN, 0); }
public FromItemElementContext fromItemElement() {
return getRuleContext(FromItemElementContext.class,0);
}
public CrossJoinContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_crossJoin; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterCrossJoin(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitCrossJoin(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitCrossJoin(this);
else return visitor.visitChildren(this);
}
}
public final CrossJoinContext crossJoin() throws RecognitionException {
CrossJoinContext _localctx = new CrossJoinContext(_ctx, getState());
enterRule(_localctx, 56, RULE_crossJoin);
try {
enterOuterAlt(_localctx, 1);
{
setState(549);
match(CROSS);
setState(550);
match(JOIN);
setState(551);
fromItemElement();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InCollectionJoinContext extends ParserRuleContext {
public TerminalNode COMMA() { return getToken(JPQLNextParser.COMMA, 0); }
public TerminalNode IN() { return getToken(JPQLNextParser.IN, 0); }
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public PathContext path() {
return getRuleContext(PathContext.class,0);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public IdentificationVariableContext identificationVariable() {
return getRuleContext(IdentificationVariableContext.class,0);
}
public InCollectionJoinContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_inCollectionJoin; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterInCollectionJoin(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitInCollectionJoin(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitInCollectionJoin(this);
else return visitor.visitChildren(this);
}
}
public final InCollectionJoinContext inCollectionJoin() throws RecognitionException {
InCollectionJoinContext _localctx = new InCollectionJoinContext(_ctx, getState());
enterRule(_localctx, 58, RULE_inCollectionJoin);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(553);
match(COMMA);
setState(554);
match(IN);
setState(555);
match(LP);
setState(556);
path();
setState(557);
match(RP);
setState(559);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==IDENTIFIER) {
{
setState(558);
identificationVariable();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QualifiedJoinContext extends ParserRuleContext {
public JoinTypeQualifierContext joinTypeQualifier() {
return getRuleContext(JoinTypeQualifierContext.class,0);
}
public TerminalNode JOIN() { return getToken(JPQLNextParser.JOIN, 0); }
public JoinItemElementContext joinItemElement() {
return getRuleContext(JoinItemElementContext.class,0);
}
public TerminalNode FETCH() { return getToken(JPQLNextParser.FETCH, 0); }
public QualifiedJoinPredicateContext qualifiedJoinPredicate() {
return getRuleContext(QualifiedJoinPredicateContext.class,0);
}
public QualifiedJoinContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qualifiedJoin; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterQualifiedJoin(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitQualifiedJoin(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitQualifiedJoin(this);
else return visitor.visitChildren(this);
}
}
public final QualifiedJoinContext qualifiedJoin() throws RecognitionException {
QualifiedJoinContext _localctx = new QualifiedJoinContext(_ctx, getState());
enterRule(_localctx, 60, RULE_qualifiedJoin);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(561);
joinTypeQualifier();
setState(562);
match(JOIN);
setState(564);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) {
case 1:
{
setState(563);
match(FETCH);
}
break;
}
setState(566);
joinItemElement();
setState(568);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ON) {
{
setState(567);
qualifiedJoinPredicate();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SubQueryQualifiedJoinContext extends ParserRuleContext {
public JoinTypeQualifierContext joinTypeQualifier() {
return getRuleContext(JoinTypeQualifierContext.class,0);
}
public TerminalNode JOIN() { return getToken(JPQLNextParser.JOIN, 0); }
public JoinItemElementContext joinItemElement() {
return getRuleContext(JoinItemElementContext.class,0);
}
public QualifiedJoinPredicateContext qualifiedJoinPredicate() {
return getRuleContext(QualifiedJoinPredicateContext.class,0);
}
public SubQueryQualifiedJoinContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subQueryQualifiedJoin; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSubQueryQualifiedJoin(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSubQueryQualifiedJoin(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSubQueryQualifiedJoin(this);
else return visitor.visitChildren(this);
}
}
public final SubQueryQualifiedJoinContext subQueryQualifiedJoin() throws RecognitionException {
SubQueryQualifiedJoinContext _localctx = new SubQueryQualifiedJoinContext(_ctx, getState());
enterRule(_localctx, 62, RULE_subQueryQualifiedJoin);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(570);
joinTypeQualifier();
setState(571);
match(JOIN);
setState(572);
joinItemElement();
setState(574);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ON) {
{
setState(573);
qualifiedJoinPredicate();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class JoinItemElementContext extends ParserRuleContext {
public FromItemElementContext fromItemElement() {
return getRuleContext(FromItemElementContext.class,0);
}
public JoinExpressionContext joinExpression() {
return getRuleContext(JoinExpressionContext.class,0);
}
public JoinItemElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_joinItemElement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterJoinItemElement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitJoinItemElement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitJoinItemElement(this);
else return visitor.visitChildren(this);
}
}
public final JoinItemElementContext joinItemElement() throws RecognitionException {
JoinItemElementContext _localctx = new JoinItemElementContext(_ctx, getState());
enterRule(_localctx, 64, RULE_joinItemElement);
try {
setState(578);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(576);
fromItemElement();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(577);
joinExpression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class JoinExpressionContext extends ParserRuleContext {
public TerminalNode TREAT() { return getToken(JPQLNextParser.TREAT, 0); }
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public PathContext path() {
return getRuleContext(PathContext.class,0);
}
public TerminalNode AS() { return getToken(JPQLNextParser.AS, 0); }
public EntityNameContext entityName() {
return getRuleContext(EntityNameContext.class,0);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public TerminalNode DOT() { return getToken(JPQLNextParser.DOT, 0); }
public GeneralSubpathContext generalSubpath() {
return getRuleContext(GeneralSubpathContext.class,0);
}
public IdentificationVariableContext identificationVariable() {
return getRuleContext(IdentificationVariableContext.class,0);
}
public JoinExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_joinExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterJoinExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitJoinExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitJoinExpression(this);
else return visitor.visitChildren(this);
}
}
public final JoinExpressionContext joinExpression() throws RecognitionException {
JoinExpressionContext _localctx = new JoinExpressionContext(_ctx, getState());
enterRule(_localctx, 66, RULE_joinExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(580);
match(TREAT);
setState(581);
match(LP);
setState(582);
path();
setState(583);
match(AS);
setState(584);
entityName();
setState(585);
match(RP);
setState(588);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(586);
match(DOT);
setState(587);
generalSubpath();
}
}
setState(591);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==IDENTIFIER) {
{
setState(590);
identificationVariable();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class JoinTypeQualifierContext extends ParserRuleContext {
public TerminalNode INNER() { return getToken(JPQLNextParser.INNER, 0); }
public TerminalNode OUTER() { return getToken(JPQLNextParser.OUTER, 0); }
public TerminalNode LEFT() { return getToken(JPQLNextParser.LEFT, 0); }
public TerminalNode RIGHT() { return getToken(JPQLNextParser.RIGHT, 0); }
public TerminalNode FULL() { return getToken(JPQLNextParser.FULL, 0); }
public JoinTypeQualifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_joinTypeQualifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterJoinTypeQualifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitJoinTypeQualifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitJoinTypeQualifier(this);
else return visitor.visitChildren(this);
}
}
public final JoinTypeQualifierContext joinTypeQualifier() throws RecognitionException {
JoinTypeQualifierContext _localctx = new JoinTypeQualifierContext(_ctx, getState());
enterRule(_localctx, 68, RULE_joinTypeQualifier);
int _la;
try {
setState(602);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,71,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(594);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INNER) {
{
setState(593);
match(INNER);
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(597);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 47)) & ~0x3f) == 0 && ((1L << (_la - 47)) & ((1L << (FULL - 47)) | (1L << (LEFT - 47)) | (1L << (RIGHT - 47)))) != 0)) {
{
setState(596);
_la = _input.LA(1);
if ( !(((((_la - 47)) & ~0x3f) == 0 && ((1L << (_la - 47)) & ((1L << (FULL - 47)) | (1L << (LEFT - 47)) | (1L << (RIGHT - 47)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(600);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OUTER) {
{
setState(599);
match(OUTER);
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QualifiedJoinPredicateContext extends ParserRuleContext {
public TerminalNode ON() { return getToken(JPQLNextParser.ON, 0); }
public PredicateContext predicate() {
return getRuleContext(PredicateContext.class,0);
}
public QualifiedJoinPredicateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qualifiedJoinPredicate; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterQualifiedJoinPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitQualifiedJoinPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitQualifiedJoinPredicate(this);
else return visitor.visitChildren(this);
}
}
public final QualifiedJoinPredicateContext qualifiedJoinPredicate() throws RecognitionException {
QualifiedJoinPredicateContext _localctx = new QualifiedJoinPredicateContext(_ctx, getState());
enterRule(_localctx, 70, RULE_qualifiedJoinPredicate);
try {
enterOuterAlt(_localctx, 1);
{
setState(604);
match(ON);
setState(605);
predicate(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SelectClauseContext extends ParserRuleContext {
public TerminalNode SELECT() { return getToken(JPQLNextParser.SELECT, 0); }
public List selectItem() {
return getRuleContexts(SelectItemContext.class);
}
public SelectItemContext selectItem(int i) {
return getRuleContext(SelectItemContext.class,i);
}
public TerminalNode DISTINCT() { return getToken(JPQLNextParser.DISTINCT, 0); }
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public SelectClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSelectClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSelectClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSelectClause(this);
else return visitor.visitChildren(this);
}
}
public final SelectClauseContext selectClause() throws RecognitionException {
SelectClauseContext _localctx = new SelectClauseContext(_ctx, getState());
enterRule(_localctx, 72, RULE_selectClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(607);
match(SELECT);
setState(609);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) {
case 1:
{
setState(608);
match(DISTINCT);
}
break;
}
setState(611);
selectItem();
setState(616);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(612);
match(COMMA);
setState(613);
selectItem();
}
}
setState(618);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SubQuerySelectClauseContext extends ParserRuleContext {
public TerminalNode SELECT() { return getToken(JPQLNextParser.SELECT, 0); }
public List subQuerySelectItem() {
return getRuleContexts(SubQuerySelectItemContext.class);
}
public SubQuerySelectItemContext subQuerySelectItem(int i) {
return getRuleContext(SubQuerySelectItemContext.class,i);
}
public TerminalNode DISTINCT() { return getToken(JPQLNextParser.DISTINCT, 0); }
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public SubQuerySelectClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subQuerySelectClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSubQuerySelectClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSubQuerySelectClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSubQuerySelectClause(this);
else return visitor.visitChildren(this);
}
}
public final SubQuerySelectClauseContext subQuerySelectClause() throws RecognitionException {
SubQuerySelectClauseContext _localctx = new SubQuerySelectClauseContext(_ctx, getState());
enterRule(_localctx, 74, RULE_subQuerySelectClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(619);
match(SELECT);
setState(621);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,74,_ctx) ) {
case 1:
{
setState(620);
match(DISTINCT);
}
break;
}
setState(623);
subQuerySelectItem();
setState(628);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(624);
match(COMMA);
setState(625);
subQuerySelectItem();
}
}
setState(630);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SelectItemContext extends ParserRuleContext {
public SelectExpressionContext selectExpression() {
return getRuleContext(SelectExpressionContext.class,0);
}
public ResultIdentifierContext resultIdentifier() {
return getRuleContext(ResultIdentifierContext.class,0);
}
public SelectItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSelectItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSelectItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSelectItem(this);
else return visitor.visitChildren(this);
}
}
public final SelectItemContext selectItem() throws RecognitionException {
SelectItemContext _localctx = new SelectItemContext(_ctx, getState());
enterRule(_localctx, 76, RULE_selectItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(631);
selectExpression();
setState(633);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==IDENTIFIER) {
{
setState(632);
resultIdentifier();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SubQuerySelectItemContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public SubQuerySelectItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_subQuerySelectItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSubQuerySelectItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSubQuerySelectItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSubQuerySelectItem(this);
else return visitor.visitChildren(this);
}
}
public final SubQuerySelectItemContext subQuerySelectItem() throws RecognitionException {
SubQuerySelectItemContext _localctx = new SubQuerySelectItemContext(_ctx, getState());
enterRule(_localctx, 78, RULE_subQuerySelectItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(635);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SelectExpressionContext extends ParserRuleContext {
public ConstructorExpressionContext constructorExpression() {
return getRuleContext(ConstructorExpressionContext.class,0);
}
public ObjectSelectExpressionContext objectSelectExpression() {
return getRuleContext(ObjectSelectExpressionContext.class,0);
}
public MapEntrySelectExpressionContext mapEntrySelectExpression() {
return getRuleContext(MapEntrySelectExpressionContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public SelectExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSelectExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSelectExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSelectExpression(this);
else return visitor.visitChildren(this);
}
}
public final SelectExpressionContext selectExpression() throws RecognitionException {
SelectExpressionContext _localctx = new SelectExpressionContext(_ctx, getState());
enterRule(_localctx, 80, RULE_selectExpression);
try {
setState(641);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(637);
constructorExpression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(638);
objectSelectExpression();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(639);
mapEntrySelectExpression();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(640);
expression(0);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ResultIdentifierContext extends ParserRuleContext {
public TerminalNode AS() { return getToken(JPQLNextParser.AS, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode IDENTIFIER() { return getToken(JPQLNextParser.IDENTIFIER, 0); }
public ResultIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_resultIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterResultIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitResultIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitResultIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final ResultIdentifierContext resultIdentifier() throws RecognitionException {
ResultIdentifierContext _localctx = new ResultIdentifierContext(_ctx, getState());
enterRule(_localctx, 82, RULE_resultIdentifier);
try {
setState(646);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AS:
enterOuterAlt(_localctx, 1);
{
{
setState(643);
match(AS);
setState(644);
identifier();
}
}
break;
case IDENTIFIER:
enterOuterAlt(_localctx, 2);
{
setState(645);
match(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;
}
public static class MapEntrySelectExpressionContext extends ParserRuleContext {
public TerminalNode ENTRY() { return getToken(JPQLNextParser.ENTRY, 0); }
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public PathContext path() {
return getRuleContext(PathContext.class,0);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public MapEntrySelectExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_mapEntrySelectExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterMapEntrySelectExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitMapEntrySelectExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitMapEntrySelectExpression(this);
else return visitor.visitChildren(this);
}
}
public final MapEntrySelectExpressionContext mapEntrySelectExpression() throws RecognitionException {
MapEntrySelectExpressionContext _localctx = new MapEntrySelectExpressionContext(_ctx, getState());
enterRule(_localctx, 84, RULE_mapEntrySelectExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(648);
match(ENTRY);
setState(649);
match(LP);
setState(650);
path();
setState(651);
match(RP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstructorExpressionContext extends ParserRuleContext {
public TerminalNode NEW() { return getToken(JPQLNextParser.NEW, 0); }
public SimpleSubpathContext simpleSubpath() {
return getRuleContext(SimpleSubpathContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public List constructorItem() {
return getRuleContexts(ConstructorItemContext.class);
}
public ConstructorItemContext constructorItem(int i) {
return getRuleContext(ConstructorItemContext.class,i);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public ConstructorExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constructorExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterConstructorExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitConstructorExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitConstructorExpression(this);
else return visitor.visitChildren(this);
}
}
public final ConstructorExpressionContext constructorExpression() throws RecognitionException {
ConstructorExpressionContext _localctx = new ConstructorExpressionContext(_ctx, getState());
enterRule(_localctx, 86, RULE_constructorExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(653);
match(NEW);
setState(654);
simpleSubpath();
setState(655);
match(LP);
setState(656);
constructorItem();
setState(661);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(657);
match(COMMA);
setState(658);
constructorItem();
}
}
setState(663);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(664);
match(RP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstructorItemContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ConstructorItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constructorItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterConstructorItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitConstructorItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitConstructorItem(this);
else return visitor.visitChildren(this);
}
}
public final ConstructorItemContext constructorItem() throws RecognitionException {
ConstructorItemContext _localctx = new ConstructorItemContext(_ctx, getState());
enterRule(_localctx, 88, RULE_constructorItem);
try {
enterOuterAlt(_localctx, 1);
{
setState(666);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ObjectSelectExpressionContext extends ParserRuleContext {
public TerminalNode OBJECT() { return getToken(JPQLNextParser.OBJECT, 0); }
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public ObjectSelectExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_objectSelectExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterObjectSelectExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitObjectSelectExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitObjectSelectExpression(this);
else return visitor.visitChildren(this);
}
}
public final ObjectSelectExpressionContext objectSelectExpression() throws RecognitionException {
ObjectSelectExpressionContext _localctx = new ObjectSelectExpressionContext(_ctx, getState());
enterRule(_localctx, 90, RULE_objectSelectExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(668);
match(OBJECT);
setState(669);
match(LP);
setState(670);
identifier();
setState(671);
match(RP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PathContext extends ParserRuleContext {
public QualifiedPathContext qualifiedPath() {
return getRuleContext(QualifiedPathContext.class,0);
}
public TerminalNode DOT() { return getToken(JPQLNextParser.DOT, 0); }
public GeneralSubpathContext generalSubpath() {
return getRuleContext(GeneralSubpathContext.class,0);
}
public PathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_path; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterPath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitPath(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitPath(this);
else return visitor.visitChildren(this);
}
}
public final PathContext path() throws RecognitionException {
PathContext _localctx = new PathContext(_ctx, getState());
enterRule(_localctx, 92, RULE_path);
try {
setState(679);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,81,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(673);
qualifiedPath();
setState(676);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) {
case 1:
{
setState(674);
match(DOT);
setState(675);
generalSubpath();
}
break;
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(678);
generalSubpath();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MacroPathContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public MacroPathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_macroPath; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterMacroPath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitMacroPath(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitMacroPath(this);
else return visitor.visitChildren(this);
}
}
public final MacroPathContext macroPath() throws RecognitionException {
MacroPathContext _localctx = new MacroPathContext(_ctx, getState());
enterRule(_localctx, 94, RULE_macroPath);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(681);
identifier();
setState(682);
match(LP);
setState(691);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << INTEGER_LITERAL) | (1L << BIG_INTEGER_LITERAL) | (1L << LONG_LITERAL) | (1L << FLOAT_LITERAL) | (1L << DOUBLE_LITERAL) | (1L << BIG_DECIMAL_LITERAL) | (1L << CHARACTER_LITERAL) | (1L << STRING_LITERAL) | (1L << AFTER) | (1L << ALL) | (1L << AND) | (1L << ANY) | (1L << AS) | (1L << ASC) | (1L << BEFORE) | (1L << BETWEEN) | (1L << BOTH) | (1L << BY) | (1L << CASE) | (1L << COLLATE) | (1L << CONTAINING) | (1L << COUNT) | (1L << CROSS) | (1L << CURRENT) | (1L << CURRENT_DATE) | (1L << CURRENT_INSTANT) | (1L << CURRENT_TIME) | (1L << CURRENT_TIMESTAMP) | (1L << DELETE) | (1L << DESC) | (1L << DISTINCT) | (1L << ELSE) | (1L << EMPTY) | (1L << END) | (1L << ENTRY) | (1L << ESCAPE) | (1L << EXCEPT) | (1L << EXCLUDE) | (1L << EXISTS) | (1L << FALSE) | (1L << FETCH) | (1L << FILTER) | (1L << FIRST) | (1L << FOLLOWING) | (1L << FROM) | (1L << FULL) | (1L << GROUP) | (1L << GROUPS) | (1L << HAVING) | (1L << IN) | (1L << INDEX) | (1L << INNER) | (1L << INSERT) | (1L << INTERSECT) | (1L << INTO) | (1L << IS) | (1L << JOIN) | (1L << JUMP) | (1L << KEY) | (1L << LAST) | (1L << LEADING) | (1L << LEFT))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (LIKE - 64)) | (1L << (LIMIT - 64)) | (1L << (MEMBER - 64)) | (1L << (NEW - 64)) | (1L << (NO - 64)) | (1L << (NOT - 64)) | (1L << (NULL - 64)) | (1L << (NULLS - 64)) | (1L << (OBJECT - 64)) | (1L << (OF - 64)) | (1L << (OFFSET - 64)) | (1L << (ON - 64)) | (1L << (OR - 64)) | (1L << (ORDER - 64)) | (1L << (OTHERS - 64)) | (1L << (OUTER - 64)) | (1L << (OVER - 64)) | (1L << (PAGE - 64)) | (1L << (PARTITION - 64)) | (1L << (PRECEDING - 64)) | (1L << (RANGE - 64)) | (1L << (RECURSIVE - 64)) | (1L << (RETURNING - 64)) | (1L << (RIGHT - 64)) | (1L << (ROW - 64)) | (1L << (ROWS - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SOME - 64)) | (1L << (THEN - 64)) | (1L << (TIES - 64)) | (1L << (TO - 64)) | (1L << (TRAILING - 64)) | (1L << (TREAT - 64)) | (1L << (TRIM - 64)) | (1L << (TRUE - 64)) | (1L << (TYPE - 64)) | (1L << (UNBOUNDED - 64)) | (1L << (UNION - 64)) | (1L << (UPDATE - 64)) | (1L << (VALUE - 64)) | (1L << (VALUES - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (WINDOW - 64)) | (1L << (WITH - 64)) | (1L << (TIMESTAMP_ESCAPE_START - 64)) | (1L << (DATE_ESCAPE_START - 64)) | (1L << (TIME_ESCAPE_START - 64)) | (1L << (LP - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (PLUS - 128)) | (1L << (MINUS - 128)) | (1L << (COLON - 128)) | (1L << (QUESTION_MARK - 128)) | (1L << (IDENTIFIER - 128)))) != 0)) {
{
setState(683);
expression(0);
setState(688);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(684);
match(COMMA);
setState(685);
expression(0);
}
}
setState(690);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(693);
match(RP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OuterPathContext extends ParserRuleContext {
public TerminalNode OUTER() { return getToken(JPQLNextParser.OUTER, 0); }
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public SimpleSubpathContext simpleSubpath() {
return getRuleContext(SimpleSubpathContext.class,0);
}
public MacroPathContext macroPath() {
return getRuleContext(MacroPathContext.class,0);
}
public OuterPathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_outerPath; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterOuterPath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitOuterPath(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitOuterPath(this);
else return visitor.visitChildren(this);
}
}
public final OuterPathContext outerPath() throws RecognitionException {
OuterPathContext _localctx = new OuterPathContext(_ctx, getState());
enterRule(_localctx, 96, RULE_outerPath);
try {
enterOuterAlt(_localctx, 1);
{
setState(695);
match(OUTER);
setState(696);
match(LP);
setState(699);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,84,_ctx) ) {
case 1:
{
setState(697);
simpleSubpath();
}
break;
case 2:
{
setState(698);
macroPath();
}
break;
}
setState(701);
match(RP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QualifiedPathContext extends ParserRuleContext {
public QualifiedPathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qualifiedPath; }
public QualifiedPathContext() { }
public void copyFrom(QualifiedPathContext ctx) {
super.copyFrom(ctx);
}
}
public static class TreatPathContext extends QualifiedPathContext {
public TerminalNode TREAT() { return getToken(JPQLNextParser.TREAT, 0); }
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public PathContext path() {
return getRuleContext(PathContext.class,0);
}
public TerminalNode AS() { return getToken(JPQLNextParser.AS, 0); }
public EntityNameContext entityName() {
return getRuleContext(EntityNameContext.class,0);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public TreatPathContext(QualifiedPathContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterTreatPath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitTreatPath(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitTreatPath(this);
else return visitor.visitChildren(this);
}
}
public static class ValuePathContext extends QualifiedPathContext {
public TerminalNode VALUE() { return getToken(JPQLNextParser.VALUE, 0); }
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public PathContext path() {
return getRuleContext(PathContext.class,0);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public ValuePathContext(QualifiedPathContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterValuePath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitValuePath(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitValuePath(this);
else return visitor.visitChildren(this);
}
}
public static class MapKeyPathContext extends QualifiedPathContext {
public TerminalNode KEY() { return getToken(JPQLNextParser.KEY, 0); }
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public PathContext path() {
return getRuleContext(PathContext.class,0);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public MapKeyPathContext(QualifiedPathContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterMapKeyPath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitMapKeyPath(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitMapKeyPath(this);
else return visitor.visitChildren(this);
}
}
public final QualifiedPathContext qualifiedPath() throws RecognitionException {
QualifiedPathContext _localctx = new QualifiedPathContext(_ctx, getState());
enterRule(_localctx, 98, RULE_qualifiedPath);
try {
setState(720);
_errHandler.sync(this);
switch (_input.LA(1)) {
case TREAT:
_localctx = new TreatPathContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(703);
match(TREAT);
setState(704);
match(LP);
setState(705);
path();
setState(706);
match(AS);
setState(707);
entityName();
setState(708);
match(RP);
}
break;
case VALUE:
_localctx = new ValuePathContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(710);
match(VALUE);
setState(711);
match(LP);
setState(712);
path();
setState(713);
match(RP);
}
break;
case KEY:
_localctx = new MapKeyPathContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(715);
match(KEY);
setState(716);
match(LP);
setState(717);
path();
setState(718);
match(RP);
}
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 SimpleSubpathContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public List DOT() { return getTokens(JPQLNextParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(JPQLNextParser.DOT, i);
}
public List identifierNonStart() {
return getRuleContexts(IdentifierNonStartContext.class);
}
public IdentifierNonStartContext identifierNonStart(int i) {
return getRuleContext(IdentifierNonStartContext.class,i);
}
public SimpleSubpathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simpleSubpath; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSimpleSubpath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSimpleSubpath(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSimpleSubpath(this);
else return visitor.visitChildren(this);
}
}
public final SimpleSubpathContext simpleSubpath() throws RecognitionException {
SimpleSubpathContext _localctx = new SimpleSubpathContext(_ctx, getState());
enterRule(_localctx, 100, RULE_simpleSubpath);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(722);
identifier();
setState(727);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,86,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(723);
match(DOT);
setState(724);
identifierNonStart();
}
}
}
setState(729);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,86,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GeneralSubpathContext extends ParserRuleContext {
public SimpleSubpathContext simpleSubpath() {
return getRuleContext(SimpleSubpathContext.class,0);
}
public TerminalNode LB() { return getToken(JPQLNextParser.LB, 0); }
public PredicateOrExpressionContext predicateOrExpression() {
return getRuleContext(PredicateOrExpressionContext.class,0);
}
public TerminalNode RB() { return getToken(JPQLNextParser.RB, 0); }
public TerminalNode DOT() { return getToken(JPQLNextParser.DOT, 0); }
public GeneralSubpathContext generalSubpath() {
return getRuleContext(GeneralSubpathContext.class,0);
}
public GeneralSubpathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_generalSubpath; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterGeneralSubpath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitGeneralSubpath(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitGeneralSubpath(this);
else return visitor.visitChildren(this);
}
}
public final GeneralSubpathContext generalSubpath() throws RecognitionException {
GeneralSubpathContext _localctx = new GeneralSubpathContext(_ctx, getState());
enterRule(_localctx, 102, RULE_generalSubpath);
try {
enterOuterAlt(_localctx, 1);
{
setState(730);
simpleSubpath();
setState(738);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) {
case 1:
{
setState(731);
match(LB);
setState(732);
predicateOrExpression();
setState(733);
match(RB);
setState(736);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) {
case 1:
{
setState(734);
match(DOT);
setState(735);
generalSubpath();
}
break;
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GroupByClauseContext extends ParserRuleContext {
public TerminalNode GROUP() { return getToken(JPQLNextParser.GROUP, 0); }
public TerminalNode BY() { return getToken(JPQLNextParser.BY, 0); }
public List groupingValue() {
return getRuleContexts(GroupingValueContext.class);
}
public GroupingValueContext groupingValue(int i) {
return getRuleContext(GroupingValueContext.class,i);
}
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public GroupByClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupByClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterGroupByClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitGroupByClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitGroupByClause(this);
else return visitor.visitChildren(this);
}
}
public final GroupByClauseContext groupByClause() throws RecognitionException {
GroupByClauseContext _localctx = new GroupByClauseContext(_ctx, getState());
enterRule(_localctx, 104, RULE_groupByClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(740);
match(GROUP);
setState(741);
match(BY);
setState(742);
groupingValue();
setState(747);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(743);
match(COMMA);
setState(744);
groupingValue();
}
}
setState(749);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GroupingValueContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public GroupingValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_groupingValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterGroupingValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitGroupingValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitGroupingValue(this);
else return visitor.visitChildren(this);
}
}
public final GroupingValueContext groupingValue() throws RecognitionException {
GroupingValueContext _localctx = new GroupingValueContext(_ctx, getState());
enterRule(_localctx, 106, RULE_groupingValue);
try {
enterOuterAlt(_localctx, 1);
{
setState(750);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HavingClauseContext extends ParserRuleContext {
public TerminalNode HAVING() { return getToken(JPQLNextParser.HAVING, 0); }
public PredicateContext predicate() {
return getRuleContext(PredicateContext.class,0);
}
public HavingClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_havingClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterHavingClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitHavingClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitHavingClause(this);
else return visitor.visitChildren(this);
}
}
public final HavingClauseContext havingClause() throws RecognitionException {
HavingClauseContext _localctx = new HavingClauseContext(_ctx, getState());
enterRule(_localctx, 108, RULE_havingClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(752);
match(HAVING);
setState(753);
predicate(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OrderByClauseContext extends ParserRuleContext {
public TerminalNode ORDER() { return getToken(JPQLNextParser.ORDER, 0); }
public TerminalNode BY() { return getToken(JPQLNextParser.BY, 0); }
public List orderByItem() {
return getRuleContexts(OrderByItemContext.class);
}
public OrderByItemContext orderByItem(int i) {
return getRuleContext(OrderByItemContext.class,i);
}
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public OrderByClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_orderByClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterOrderByClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitOrderByClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitOrderByClause(this);
else return visitor.visitChildren(this);
}
}
public final OrderByClauseContext orderByClause() throws RecognitionException {
OrderByClauseContext _localctx = new OrderByClauseContext(_ctx, getState());
enterRule(_localctx, 110, RULE_orderByClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(755);
match(ORDER);
setState(756);
match(BY);
setState(757);
orderByItem();
setState(762);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(758);
match(COMMA);
setState(759);
orderByItem();
}
}
setState(764);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OrderByItemContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode COLLATE() { return getToken(JPQLNextParser.COLLATE, 0); }
public TerminalNode STRING_LITERAL() { return getToken(JPQLNextParser.STRING_LITERAL, 0); }
public TerminalNode ASC() { return getToken(JPQLNextParser.ASC, 0); }
public TerminalNode DESC() { return getToken(JPQLNextParser.DESC, 0); }
public TerminalNode NULLS() { return getToken(JPQLNextParser.NULLS, 0); }
public TerminalNode FIRST() { return getToken(JPQLNextParser.FIRST, 0); }
public TerminalNode LAST() { return getToken(JPQLNextParser.LAST, 0); }
public OrderByItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_orderByItem; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterOrderByItem(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitOrderByItem(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitOrderByItem(this);
else return visitor.visitChildren(this);
}
}
public final OrderByItemContext orderByItem() throws RecognitionException {
OrderByItemContext _localctx = new OrderByItemContext(_ctx, getState());
enterRule(_localctx, 112, RULE_orderByItem);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(765);
expression(0);
setState(768);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLLATE) {
{
setState(766);
match(COLLATE);
setState(767);
match(STRING_LITERAL);
}
}
setState(775);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASC || _la==DESC) {
{
setState(770);
_la = _input.LA(1);
if ( !(_la==ASC || _la==DESC) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(773);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NULLS) {
{
setState(771);
match(NULLS);
setState(772);
_la = _input.LA(1);
if ( !(_la==FIRST || _la==LAST) ) {
_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 WindowClauseContext extends ParserRuleContext {
public TerminalNode WINDOW() { return getToken(JPQLNextParser.WINDOW, 0); }
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public List AS() { return getTokens(JPQLNextParser.AS); }
public TerminalNode AS(int i) {
return getToken(JPQLNextParser.AS, i);
}
public List LP() { return getTokens(JPQLNextParser.LP); }
public TerminalNode LP(int i) {
return getToken(JPQLNextParser.LP, i);
}
public List windowDefinition() {
return getRuleContexts(WindowDefinitionContext.class);
}
public WindowDefinitionContext windowDefinition(int i) {
return getRuleContext(WindowDefinitionContext.class,i);
}
public List RP() { return getTokens(JPQLNextParser.RP); }
public TerminalNode RP(int i) {
return getToken(JPQLNextParser.RP, i);
}
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public WindowClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_windowClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterWindowClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitWindowClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitWindowClause(this);
else return visitor.visitChildren(this);
}
}
public final WindowClauseContext windowClause() throws RecognitionException {
WindowClauseContext _localctx = new WindowClauseContext(_ctx, getState());
enterRule(_localctx, 114, RULE_windowClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(777);
match(WINDOW);
setState(778);
identifier();
setState(779);
match(AS);
setState(780);
match(LP);
setState(781);
windowDefinition();
setState(782);
match(RP);
setState(792);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(783);
match(COMMA);
setState(784);
identifier();
setState(785);
match(AS);
setState(786);
match(LP);
setState(787);
windowDefinition();
setState(788);
match(RP);
}
}
setState(794);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WindowDefinitionContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public PartitionByClauseContext partitionByClause() {
return getRuleContext(PartitionByClauseContext.class,0);
}
public OrderByClauseContext orderByClause() {
return getRuleContext(OrderByClauseContext.class,0);
}
public FrameClauseContext frameClause() {
return getRuleContext(FrameClauseContext.class,0);
}
public WindowDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_windowDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterWindowDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitWindowDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitWindowDefinition(this);
else return visitor.visitChildren(this);
}
}
public final WindowDefinitionContext windowDefinition() throws RecognitionException {
WindowDefinitionContext _localctx = new WindowDefinitionContext(_ctx, getState());
enterRule(_localctx, 116, RULE_windowDefinition);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(796);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,95,_ctx) ) {
case 1:
{
setState(795);
identifier();
}
break;
}
setState(799);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(798);
partitionByClause();
}
}
setState(802);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(801);
orderByClause();
}
}
setState(805);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 49)) & ~0x3f) == 0 && ((1L << (_la - 49)) & ((1L << (GROUPS - 49)) | (1L << (RANGE - 49)) | (1L << (ROWS - 49)))) != 0)) {
{
setState(804);
frameClause();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PartitionByClauseContext extends ParserRuleContext {
public TerminalNode PARTITION() { return getToken(JPQLNextParser.PARTITION, 0); }
public TerminalNode BY() { return getToken(JPQLNextParser.BY, 0); }
public List groupingValue() {
return getRuleContexts(GroupingValueContext.class);
}
public GroupingValueContext groupingValue(int i) {
return getRuleContext(GroupingValueContext.class,i);
}
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public PartitionByClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_partitionByClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterPartitionByClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitPartitionByClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitPartitionByClause(this);
else return visitor.visitChildren(this);
}
}
public final PartitionByClauseContext partitionByClause() throws RecognitionException {
PartitionByClauseContext _localctx = new PartitionByClauseContext(_ctx, getState());
enterRule(_localctx, 118, RULE_partitionByClause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(807);
match(PARTITION);
setState(808);
match(BY);
setState(809);
groupingValue();
setState(814);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(810);
match(COMMA);
setState(811);
groupingValue();
}
}
setState(816);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FrameClauseContext extends ParserRuleContext {
public Token frameMode;
public FrameStartContext frameStart() {
return getRuleContext(FrameStartContext.class,0);
}
public TerminalNode RANGE() { return getToken(JPQLNextParser.RANGE, 0); }
public TerminalNode ROWS() { return getToken(JPQLNextParser.ROWS, 0); }
public TerminalNode GROUPS() { return getToken(JPQLNextParser.GROUPS, 0); }
public FrameExclusionClauseContext frameExclusionClause() {
return getRuleContext(FrameExclusionClauseContext.class,0);
}
public TerminalNode BETWEEN() { return getToken(JPQLNextParser.BETWEEN, 0); }
public TerminalNode AND() { return getToken(JPQLNextParser.AND, 0); }
public FrameEndContext frameEnd() {
return getRuleContext(FrameEndContext.class,0);
}
public FrameClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_frameClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterFrameClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitFrameClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitFrameClause(this);
else return visitor.visitChildren(this);
}
}
public final FrameClauseContext frameClause() throws RecognitionException {
FrameClauseContext _localctx = new FrameClauseContext(_ctx, getState());
enterRule(_localctx, 120, RULE_frameClause);
int _la;
try {
setState(830);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,102,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(817);
((FrameClauseContext)_localctx).frameMode = _input.LT(1);
_la = _input.LA(1);
if ( !(((((_la - 49)) & ~0x3f) == 0 && ((1L << (_la - 49)) & ((1L << (GROUPS - 49)) | (1L << (RANGE - 49)) | (1L << (ROWS - 49)))) != 0)) ) {
((FrameClauseContext)_localctx).frameMode = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(818);
frameStart();
setState(820);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXCLUDE) {
{
setState(819);
frameExclusionClause();
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(822);
((FrameClauseContext)_localctx).frameMode = _input.LT(1);
_la = _input.LA(1);
if ( !(((((_la - 49)) & ~0x3f) == 0 && ((1L << (_la - 49)) & ((1L << (GROUPS - 49)) | (1L << (RANGE - 49)) | (1L << (ROWS - 49)))) != 0)) ) {
((FrameClauseContext)_localctx).frameMode = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(823);
match(BETWEEN);
setState(824);
frameStart();
setState(825);
match(AND);
setState(826);
frameEnd();
setState(828);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXCLUDE) {
{
setState(827);
frameExclusionClause();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FrameStartContext extends ParserRuleContext {
public TerminalNode UNBOUNDED() { return getToken(JPQLNextParser.UNBOUNDED, 0); }
public TerminalNode PRECEDING() { return getToken(JPQLNextParser.PRECEDING, 0); }
public ParameterOrNumberLiteralContext parameterOrNumberLiteral() {
return getRuleContext(ParameterOrNumberLiteralContext.class,0);
}
public TerminalNode CURRENT() { return getToken(JPQLNextParser.CURRENT, 0); }
public TerminalNode ROW() { return getToken(JPQLNextParser.ROW, 0); }
public TerminalNode FOLLOWING() { return getToken(JPQLNextParser.FOLLOWING, 0); }
public FrameStartContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_frameStart; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterFrameStart(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitFrameStart(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitFrameStart(this);
else return visitor.visitChildren(this);
}
}
public final FrameStartContext frameStart() throws RecognitionException {
FrameStartContext _localctx = new FrameStartContext(_ctx, getState());
enterRule(_localctx, 122, RULE_frameStart);
try {
setState(842);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,103,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(832);
match(UNBOUNDED);
setState(833);
match(PRECEDING);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(834);
parameterOrNumberLiteral();
setState(835);
match(PRECEDING);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(837);
match(CURRENT);
setState(838);
match(ROW);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(839);
parameterOrNumberLiteral();
setState(840);
match(FOLLOWING);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FrameEndContext extends ParserRuleContext {
public TerminalNode UNBOUNDED() { return getToken(JPQLNextParser.UNBOUNDED, 0); }
public TerminalNode PRECEDING() { return getToken(JPQLNextParser.PRECEDING, 0); }
public ParameterOrNumberLiteralContext parameterOrNumberLiteral() {
return getRuleContext(ParameterOrNumberLiteralContext.class,0);
}
public TerminalNode CURRENT() { return getToken(JPQLNextParser.CURRENT, 0); }
public TerminalNode ROW() { return getToken(JPQLNextParser.ROW, 0); }
public TerminalNode FOLLOWING() { return getToken(JPQLNextParser.FOLLOWING, 0); }
public FrameEndContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_frameEnd; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterFrameEnd(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitFrameEnd(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitFrameEnd(this);
else return visitor.visitChildren(this);
}
}
public final FrameEndContext frameEnd() throws RecognitionException {
FrameEndContext _localctx = new FrameEndContext(_ctx, getState());
enterRule(_localctx, 124, RULE_frameEnd);
try {
setState(856);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,104,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(844);
match(UNBOUNDED);
setState(845);
match(PRECEDING);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(846);
parameterOrNumberLiteral();
setState(847);
match(PRECEDING);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(849);
match(CURRENT);
setState(850);
match(ROW);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(851);
parameterOrNumberLiteral();
setState(852);
match(FOLLOWING);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(854);
match(UNBOUNDED);
setState(855);
match(FOLLOWING);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FrameExclusionClauseContext extends ParserRuleContext {
public TerminalNode EXCLUDE() { return getToken(JPQLNextParser.EXCLUDE, 0); }
public TerminalNode CURRENT() { return getToken(JPQLNextParser.CURRENT, 0); }
public TerminalNode ROW() { return getToken(JPQLNextParser.ROW, 0); }
public TerminalNode GROUP() { return getToken(JPQLNextParser.GROUP, 0); }
public TerminalNode TIES() { return getToken(JPQLNextParser.TIES, 0); }
public TerminalNode NO() { return getToken(JPQLNextParser.NO, 0); }
public TerminalNode OTHERS() { return getToken(JPQLNextParser.OTHERS, 0); }
public FrameExclusionClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_frameExclusionClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterFrameExclusionClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitFrameExclusionClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitFrameExclusionClause(this);
else return visitor.visitChildren(this);
}
}
public final FrameExclusionClauseContext frameExclusionClause() throws RecognitionException {
FrameExclusionClauseContext _localctx = new FrameExclusionClauseContext(_ctx, getState());
enterRule(_localctx, 126, RULE_frameExclusionClause);
try {
setState(868);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,105,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(858);
match(EXCLUDE);
setState(859);
match(CURRENT);
setState(860);
match(ROW);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(861);
match(EXCLUDE);
setState(862);
match(GROUP);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(863);
match(EXCLUDE);
setState(864);
match(TIES);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(865);
match(EXCLUDE);
setState(866);
match(NO);
setState(867);
match(OTHERS);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LimitClauseContext extends ParserRuleContext {
public TerminalNode LIMIT() { return getToken(JPQLNextParser.LIMIT, 0); }
public ParameterOrNumberLiteralContext parameterOrNumberLiteral() {
return getRuleContext(ParameterOrNumberLiteralContext.class,0);
}
public LimitClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_limitClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterLimitClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitLimitClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitLimitClause(this);
else return visitor.visitChildren(this);
}
}
public final LimitClauseContext limitClause() throws RecognitionException {
LimitClauseContext _localctx = new LimitClauseContext(_ctx, getState());
enterRule(_localctx, 128, RULE_limitClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(870);
match(LIMIT);
setState(871);
parameterOrNumberLiteral();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OffsetClauseContext extends ParserRuleContext {
public TerminalNode OFFSET() { return getToken(JPQLNextParser.OFFSET, 0); }
public ParameterOrNumberLiteralContext parameterOrNumberLiteral() {
return getRuleContext(ParameterOrNumberLiteralContext.class,0);
}
public TerminalNode JUMP() { return getToken(JPQLNextParser.JUMP, 0); }
public TerminalNode TO() { return getToken(JPQLNextParser.TO, 0); }
public TerminalNode PAGE() { return getToken(JPQLNextParser.PAGE, 0); }
public TerminalNode CONTAINING() { return getToken(JPQLNextParser.CONTAINING, 0); }
public ParameterContext parameter() {
return getRuleContext(ParameterContext.class,0);
}
public OffsetClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_offsetClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterOffsetClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitOffsetClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitOffsetClause(this);
else return visitor.visitChildren(this);
}
}
public final OffsetClauseContext offsetClause() throws RecognitionException {
OffsetClauseContext _localctx = new OffsetClauseContext(_ctx, getState());
enterRule(_localctx, 130, RULE_offsetClause);
try {
setState(880);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OFFSET:
enterOuterAlt(_localctx, 1);
{
setState(873);
match(OFFSET);
setState(874);
parameterOrNumberLiteral();
}
break;
case JUMP:
enterOuterAlt(_localctx, 2);
{
setState(875);
match(JUMP);
setState(876);
match(TO);
setState(877);
match(PAGE);
setState(878);
match(CONTAINING);
setState(879);
parameter();
}
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 ParameterOrNumberLiteralContext extends ParserRuleContext {
public ParameterContext parameter() {
return getRuleContext(ParameterContext.class,0);
}
public TerminalNode INTEGER_LITERAL() { return getToken(JPQLNextParser.INTEGER_LITERAL, 0); }
public ParameterOrNumberLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameterOrNumberLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterParameterOrNumberLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitParameterOrNumberLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitParameterOrNumberLiteral(this);
else return visitor.visitChildren(this);
}
}
public final ParameterOrNumberLiteralContext parameterOrNumberLiteral() throws RecognitionException {
ParameterOrNumberLiteralContext _localctx = new ParameterOrNumberLiteralContext(_ctx, getState());
enterRule(_localctx, 132, RULE_parameterOrNumberLiteral);
try {
setState(884);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COLON:
case QUESTION_MARK:
enterOuterAlt(_localctx, 1);
{
setState(882);
parameter();
}
break;
case INTEGER_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(883);
match(INTEGER_LITERAL);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class KeysetClauseContext extends ParserRuleContext {
public List parameterOrLiteral() {
return getRuleContexts(ParameterOrLiteralContext.class);
}
public ParameterOrLiteralContext parameterOrLiteral(int i) {
return getRuleContext(ParameterOrLiteralContext.class,i);
}
public TerminalNode BEFORE() { return getToken(JPQLNextParser.BEFORE, 0); }
public TerminalNode AFTER() { return getToken(JPQLNextParser.AFTER, 0); }
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public KeysetClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_keysetClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterKeysetClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitKeysetClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitKeysetClause(this);
else return visitor.visitChildren(this);
}
}
public final KeysetClauseContext keysetClause() throws RecognitionException {
KeysetClauseContext _localctx = new KeysetClauseContext(_ctx, getState());
enterRule(_localctx, 134, RULE_keysetClause);
int _la;
try {
setState(900);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,109,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(886);
_la = _input.LA(1);
if ( !(_la==AFTER || _la==BEFORE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(887);
parameterOrLiteral();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(888);
_la = _input.LA(1);
if ( !(_la==AFTER || _la==BEFORE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(889);
match(LP);
setState(890);
parameterOrLiteral();
setState(895);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(891);
match(COMMA);
setState(892);
parameterOrLiteral();
}
}
setState(897);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(898);
match(RP);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParameterOrLiteralContext extends ParserRuleContext {
public ParameterContext parameter() {
return getRuleContext(ParameterContext.class,0);
}
public LiteralContext literal() {
return getRuleContext(LiteralContext.class,0);
}
public ParameterOrLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameterOrLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterParameterOrLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitParameterOrLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitParameterOrLiteral(this);
else return visitor.visitChildren(this);
}
}
public final ParameterOrLiteralContext parameterOrLiteral() throws RecognitionException {
ParameterOrLiteralContext _localctx = new ParameterOrLiteralContext(_ctx, getState());
enterRule(_localctx, 136, RULE_parameterOrLiteral);
try {
setState(904);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COLON:
case QUESTION_MARK:
enterOuterAlt(_localctx, 1);
{
setState(902);
parameter();
}
break;
case INTEGER_LITERAL:
case BIG_INTEGER_LITERAL:
case LONG_LITERAL:
case FLOAT_LITERAL:
case DOUBLE_LITERAL:
case BIG_DECIMAL_LITERAL:
case CHARACTER_LITERAL:
case STRING_LITERAL:
case FALSE:
case NULL:
case TRUE:
case TIMESTAMP_ESCAPE_START:
case DATE_ESCAPE_START:
case TIME_ESCAPE_START:
enterOuterAlt(_localctx, 2);
{
setState(903);
literal();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EntityTypeOrEnumLiteralContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public List identifierNonStart() {
return getRuleContexts(IdentifierNonStartContext.class);
}
public IdentifierNonStartContext identifierNonStart(int i) {
return getRuleContext(IdentifierNonStartContext.class,i);
}
public List DOT() { return getTokens(JPQLNextParser.DOT); }
public TerminalNode DOT(int i) {
return getToken(JPQLNextParser.DOT, i);
}
public List DOLLAR() { return getTokens(JPQLNextParser.DOLLAR); }
public TerminalNode DOLLAR(int i) {
return getToken(JPQLNextParser.DOLLAR, i);
}
public EntityTypeOrEnumLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_entityTypeOrEnumLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterEntityTypeOrEnumLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitEntityTypeOrEnumLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitEntityTypeOrEnumLiteral(this);
else return visitor.visitChildren(this);
}
}
public final EntityTypeOrEnumLiteralContext entityTypeOrEnumLiteral() throws RecognitionException {
EntityTypeOrEnumLiteralContext _localctx = new EntityTypeOrEnumLiteralContext(_ctx, getState());
enterRule(_localctx, 138, RULE_entityTypeOrEnumLiteral);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(906);
identifier();
setState(911);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT || _la==DOLLAR) {
{
{
setState(907);
_la = _input.LA(1);
if ( !(_la==DOT || _la==DOLLAR) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(908);
identifierNonStart();
}
}
setState(913);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WhereClauseContext extends ParserRuleContext {
public TerminalNode WHERE() { return getToken(JPQLNextParser.WHERE, 0); }
public PredicateContext predicate() {
return getRuleContext(PredicateContext.class,0);
}
public WhereClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_whereClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterWhereClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitWhereClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitWhereClause(this);
else return visitor.visitChildren(this);
}
}
public final WhereClauseContext whereClause() throws RecognitionException {
WhereClauseContext _localctx = new WhereClauseContext(_ctx, getState());
enterRule(_localctx, 140, RULE_whereClause);
try {
enterOuterAlt(_localctx, 1);
{
setState(914);
match(WHERE);
setState(915);
predicate(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionContext extends ParserRuleContext {
public ExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expression; }
public ExpressionContext() { }
public void copyFrom(ExpressionContext ctx) {
super.copyFrom(ctx);
}
}
public static class AdditiveExpressionContext extends ExpressionContext {
public ExpressionContext lhs;
public ExpressionContext rhs;
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode PLUS() { return getToken(JPQLNextParser.PLUS, 0); }
public TerminalNode MINUS() { return getToken(JPQLNextParser.MINUS, 0); }
public AdditiveExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterAdditiveExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitAdditiveExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitAdditiveExpression(this);
else return visitor.visitChildren(this);
}
}
public static class LiteralExpressionContext extends ExpressionContext {
public LiteralContext literal() {
return getRuleContext(LiteralContext.class,0);
}
public LiteralExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterLiteralExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitLiteralExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitLiteralExpression(this);
else return visitor.visitChildren(this);
}
}
public static class EntityTypeExpressionContext extends ExpressionContext {
public EntityTypeContext entityType() {
return getRuleContext(EntityTypeContext.class,0);
}
public EntityTypeExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterEntityTypeExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitEntityTypeExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitEntityTypeExpression(this);
else return visitor.visitChildren(this);
}
}
public static class GroupedExpressionContext extends ExpressionContext {
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public GroupedExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterGroupedExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitGroupedExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitGroupedExpression(this);
else return visitor.visitChildren(this);
}
}
public static class ConcatenationExpressionContext extends ExpressionContext {
public ExpressionContext lhs;
public ExpressionContext rhs;
public TerminalNode DOUBLE_PIPE() { return getToken(JPQLNextParser.DOUBLE_PIPE, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public ConcatenationExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterConcatenationExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitConcatenationExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitConcatenationExpression(this);
else return visitor.visitChildren(this);
}
}
public static class SimpleCaseExpressionContext extends ExpressionContext {
public ExpressionContext operand;
public ExpressionContext otherwise;
public TerminalNode CASE() { return getToken(JPQLNextParser.CASE, 0); }
public TerminalNode END() { return getToken(JPQLNextParser.END, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List simpleCaseWhen() {
return getRuleContexts(SimpleCaseWhenContext.class);
}
public SimpleCaseWhenContext simpleCaseWhen(int i) {
return getRuleContext(SimpleCaseWhenContext.class,i);
}
public TerminalNode ELSE() { return getToken(JPQLNextParser.ELSE, 0); }
public SimpleCaseExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSimpleCaseExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSimpleCaseExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSimpleCaseExpression(this);
else return visitor.visitChildren(this);
}
}
public static class FunctionExpressionContext extends ExpressionContext {
public FunctionContext function() {
return getRuleContext(FunctionContext.class,0);
}
public FunctionExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterFunctionExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitFunctionExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitFunctionExpression(this);
else return visitor.visitChildren(this);
}
}
public static class PathExpressionContext extends ExpressionContext {
public PathContext path() {
return getRuleContext(PathContext.class,0);
}
public PathExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterPathExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitPathExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitPathExpression(this);
else return visitor.visitChildren(this);
}
}
public static class UnaryMinusExpressionContext extends ExpressionContext {
public TerminalNode MINUS() { return getToken(JPQLNextParser.MINUS, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public UnaryMinusExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterUnaryMinusExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitUnaryMinusExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitUnaryMinusExpression(this);
else return visitor.visitChildren(this);
}
}
public static class ParameterExpressionContext extends ExpressionContext {
public ParameterContext parameter() {
return getRuleContext(ParameterContext.class,0);
}
public ParameterExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterParameterExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitParameterExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitParameterExpression(this);
else return visitor.visitChildren(this);
}
}
public static class TemporalFunctionExpressionContext extends ExpressionContext {
public Token name;
public TerminalNode CURRENT_DATE() { return getToken(JPQLNextParser.CURRENT_DATE, 0); }
public TerminalNode CURRENT_TIME() { return getToken(JPQLNextParser.CURRENT_TIME, 0); }
public TerminalNode CURRENT_TIMESTAMP() { return getToken(JPQLNextParser.CURRENT_TIMESTAMP, 0); }
public TerminalNode CURRENT_INSTANT() { return getToken(JPQLNextParser.CURRENT_INSTANT, 0); }
public TemporalFunctionExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterTemporalFunctionExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitTemporalFunctionExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitTemporalFunctionExpression(this);
else return visitor.visitChildren(this);
}
}
public static class UnaryPlusExpressionContext extends ExpressionContext {
public TerminalNode PLUS() { return getToken(JPQLNextParser.PLUS, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public UnaryPlusExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterUnaryPlusExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitUnaryPlusExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitUnaryPlusExpression(this);
else return visitor.visitChildren(this);
}
}
public static class GeneralCaseExpressionContext extends ExpressionContext {
public TerminalNode CASE() { return getToken(JPQLNextParser.CASE, 0); }
public TerminalNode END() { return getToken(JPQLNextParser.END, 0); }
public List searchedCaseWhen() {
return getRuleContexts(SearchedCaseWhenContext.class);
}
public SearchedCaseWhenContext searchedCaseWhen(int i) {
return getRuleContext(SearchedCaseWhenContext.class,i);
}
public TerminalNode ELSE() { return getToken(JPQLNextParser.ELSE, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public GeneralCaseExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterGeneralCaseExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitGeneralCaseExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitGeneralCaseExpression(this);
else return visitor.visitChildren(this);
}
}
public static class MultiplicativeExpressionContext extends ExpressionContext {
public ExpressionContext lhs;
public ExpressionContext rhs;
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode ASTERISK() { return getToken(JPQLNextParser.ASTERISK, 0); }
public TerminalNode SLASH() { return getToken(JPQLNextParser.SLASH, 0); }
public TerminalNode PERCENT() { return getToken(JPQLNextParser.PERCENT, 0); }
public MultiplicativeExpressionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterMultiplicativeExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitMultiplicativeExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitMultiplicativeExpression(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionContext expression() throws RecognitionException {
return expression(0);
}
private ExpressionContext expression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState);
ExpressionContext _prevctx = _localctx;
int _startState = 142;
enterRecursionRule(_localctx, 142, RULE_expression, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(957);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,116,_ctx) ) {
case 1:
{
_localctx = new GroupedExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(918);
match(LP);
setState(919);
expression(0);
setState(920);
match(RP);
}
break;
case 2:
{
_localctx = new SimpleCaseExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(922);
match(CASE);
setState(923);
((SimpleCaseExpressionContext)_localctx).operand = expression(0);
setState(925);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(924);
simpleCaseWhen();
}
}
setState(927);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==WHEN );
setState(931);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(929);
match(ELSE);
setState(930);
((SimpleCaseExpressionContext)_localctx).otherwise = expression(0);
}
}
setState(933);
match(END);
}
break;
case 3:
{
_localctx = new GeneralCaseExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(935);
match(CASE);
setState(937);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(936);
searchedCaseWhen();
}
}
setState(939);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==WHEN );
setState(943);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(941);
match(ELSE);
setState(942);
expression(0);
}
}
setState(945);
match(END);
}
break;
case 4:
{
_localctx = new LiteralExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(947);
literal();
}
break;
case 5:
{
_localctx = new ParameterExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(948);
parameter();
}
break;
case 6:
{
_localctx = new EntityTypeExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(949);
entityType();
}
break;
case 7:
{
_localctx = new TemporalFunctionExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(950);
((TemporalFunctionExpressionContext)_localctx).name = _input.LT(1);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << CURRENT_DATE) | (1L << CURRENT_INSTANT) | (1L << CURRENT_TIME) | (1L << CURRENT_TIMESTAMP))) != 0)) ) {
((TemporalFunctionExpressionContext)_localctx).name = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case 8:
{
_localctx = new PathExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(951);
path();
}
break;
case 9:
{
_localctx = new FunctionExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(952);
function();
}
break;
case 10:
{
_localctx = new UnaryMinusExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(953);
match(MINUS);
setState(954);
expression(5);
}
break;
case 11:
{
_localctx = new UnaryPlusExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(955);
match(PLUS);
setState(956);
expression(4);
}
break;
}
_ctx.stop = _input.LT(-1);
setState(970);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,118,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(968);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,117,_ctx) ) {
case 1:
{
_localctx = new MultiplicativeExpressionContext(new ExpressionContext(_parentctx, _parentState));
((MultiplicativeExpressionContext)_localctx).lhs = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(959);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(960);
_la = _input.LA(1);
if ( !(((((_la - 130)) & ~0x3f) == 0 && ((1L << (_la - 130)) & ((1L << (ASTERISK - 130)) | (1L << (SLASH - 130)) | (1L << (PERCENT - 130)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(961);
((MultiplicativeExpressionContext)_localctx).rhs = expression(4);
}
break;
case 2:
{
_localctx = new AdditiveExpressionContext(new ExpressionContext(_parentctx, _parentState));
((AdditiveExpressionContext)_localctx).lhs = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(962);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(963);
_la = _input.LA(1);
if ( !(_la==PLUS || _la==MINUS) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(964);
((AdditiveExpressionContext)_localctx).rhs = expression(3);
}
break;
case 3:
{
_localctx = new ConcatenationExpressionContext(new ExpressionContext(_parentctx, _parentState));
((ConcatenationExpressionContext)_localctx).lhs = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(965);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(966);
match(DOUBLE_PIPE);
setState(967);
((ConcatenationExpressionContext)_localctx).rhs = expression(2);
}
break;
}
}
}
setState(972);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,118,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class PredicateContext extends ParserRuleContext {
public PredicateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_predicate; }
public PredicateContext() { }
public void copyFrom(PredicateContext ctx) {
super.copyFrom(ctx);
}
}
public static class QuantifiedSimpleLessThanOrEqualPredicateContext extends PredicateContext {
public Token quantifier;
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode LESS_EQUAL() { return getToken(JPQLNextParser.LESS_EQUAL, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public TerminalNode ALL() { return getToken(JPQLNextParser.ALL, 0); }
public TerminalNode ANY() { return getToken(JPQLNextParser.ANY, 0); }
public TerminalNode SOME() { return getToken(JPQLNextParser.SOME, 0); }
public QuantifiedSimpleLessThanOrEqualPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterQuantifiedSimpleLessThanOrEqualPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitQuantifiedSimpleLessThanOrEqualPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitQuantifiedSimpleLessThanOrEqualPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class ExistsSimplePredicateContext extends PredicateContext {
public TerminalNode EXISTS() { return getToken(JPQLNextParser.EXISTS, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public TerminalNode NOT() { return getToken(JPQLNextParser.NOT, 0); }
public ExistsSimplePredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterExistsSimplePredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitExistsSimplePredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitExistsSimplePredicate(this);
else return visitor.visitChildren(this);
}
}
public static class BetweenPredicateContext extends PredicateContext {
public ExpressionContext lhs;
public ExpressionContext start;
public ExpressionContext end;
public TerminalNode BETWEEN() { return getToken(JPQLNextParser.BETWEEN, 0); }
public TerminalNode AND() { return getToken(JPQLNextParser.AND, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode NOT() { return getToken(JPQLNextParser.NOT, 0); }
public BetweenPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterBetweenPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitBetweenPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitBetweenPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class QuantifiedSimpleGreaterThanPredicateContext extends PredicateContext {
public Token quantifier;
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode GREATER() { return getToken(JPQLNextParser.GREATER, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public TerminalNode ALL() { return getToken(JPQLNextParser.ALL, 0); }
public TerminalNode ANY() { return getToken(JPQLNextParser.ANY, 0); }
public TerminalNode SOME() { return getToken(JPQLNextParser.SOME, 0); }
public QuantifiedSimpleGreaterThanPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterQuantifiedSimpleGreaterThanPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitQuantifiedSimpleGreaterThanPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitQuantifiedSimpleGreaterThanPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class AndPredicateContext extends PredicateContext {
public List predicate() {
return getRuleContexts(PredicateContext.class);
}
public PredicateContext predicate(int i) {
return getRuleContext(PredicateContext.class,i);
}
public TerminalNode AND() { return getToken(JPQLNextParser.AND, 0); }
public AndPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterAndPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitAndPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitAndPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class InequalityPredicateContext extends PredicateContext {
public ExpressionContext lhs;
public ExpressionContext rhs;
public TerminalNode NOT_EQUAL() { return getToken(JPQLNextParser.NOT_EQUAL, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public InequalityPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterInequalityPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitInequalityPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitInequalityPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class LessThanOrEqualPredicateContext extends PredicateContext {
public ExpressionContext lhs;
public ExpressionContext rhs;
public TerminalNode LESS_EQUAL() { return getToken(JPQLNextParser.LESS_EQUAL, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public LessThanOrEqualPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterLessThanOrEqualPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitLessThanOrEqualPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitLessThanOrEqualPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class GroupedPredicateContext extends PredicateContext {
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public PredicateContext predicate() {
return getRuleContext(PredicateContext.class,0);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public GroupedPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterGroupedPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitGroupedPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitGroupedPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class LikePredicateContext extends PredicateContext {
public ExpressionContext lhs;
public ExpressionContext like;
public ExpressionContext escape;
public TerminalNode LIKE() { return getToken(JPQLNextParser.LIKE, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode NOT() { return getToken(JPQLNextParser.NOT, 0); }
public TerminalNode ESCAPE() { return getToken(JPQLNextParser.ESCAPE, 0); }
public LikePredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterLikePredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitLikePredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitLikePredicate(this);
else return visitor.visitChildren(this);
}
}
public static class InPredicateContext extends PredicateContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode IN() { return getToken(JPQLNextParser.IN, 0); }
public InListContext inList() {
return getRuleContext(InListContext.class,0);
}
public TerminalNode NOT() { return getToken(JPQLNextParser.NOT, 0); }
public InPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterInPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitInPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitInPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class EqualityPredicateContext extends PredicateContext {
public ExpressionContext lhs;
public ExpressionContext rhs;
public TerminalNode EQUAL() { return getToken(JPQLNextParser.EQUAL, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public EqualityPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterEqualityPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitEqualityPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitEqualityPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class QuantifiedSimpleInequalityPredicateContext extends PredicateContext {
public Token quantifier;
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode NOT_EQUAL() { return getToken(JPQLNextParser.NOT_EQUAL, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public TerminalNode ALL() { return getToken(JPQLNextParser.ALL, 0); }
public TerminalNode ANY() { return getToken(JPQLNextParser.ANY, 0); }
public TerminalNode SOME() { return getToken(JPQLNextParser.SOME, 0); }
public QuantifiedSimpleInequalityPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterQuantifiedSimpleInequalityPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitQuantifiedSimpleInequalityPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitQuantifiedSimpleInequalityPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class GreaterThanPredicateContext extends PredicateContext {
public ExpressionContext lhs;
public ExpressionContext rhs;
public TerminalNode GREATER() { return getToken(JPQLNextParser.GREATER, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public GreaterThanPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterGreaterThanPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitGreaterThanPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitGreaterThanPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class NegatedPredicateContext extends PredicateContext {
public TerminalNode NOT() { return getToken(JPQLNextParser.NOT, 0); }
public PredicateContext predicate() {
return getRuleContext(PredicateContext.class,0);
}
public NegatedPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterNegatedPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitNegatedPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitNegatedPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class QuantifiedSimpleLessThanPredicateContext extends PredicateContext {
public Token quantifier;
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode LESS() { return getToken(JPQLNextParser.LESS, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public TerminalNode ALL() { return getToken(JPQLNextParser.ALL, 0); }
public TerminalNode ANY() { return getToken(JPQLNextParser.ANY, 0); }
public TerminalNode SOME() { return getToken(JPQLNextParser.SOME, 0); }
public QuantifiedSimpleLessThanPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterQuantifiedSimpleLessThanPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitQuantifiedSimpleLessThanPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitQuantifiedSimpleLessThanPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class OrPredicateContext extends PredicateContext {
public List predicate() {
return getRuleContexts(PredicateContext.class);
}
public PredicateContext predicate(int i) {
return getRuleContext(PredicateContext.class,i);
}
public TerminalNode OR() { return getToken(JPQLNextParser.OR, 0); }
public OrPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterOrPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitOrPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitOrPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class MemberOfPredicateContext extends PredicateContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode MEMBER() { return getToken(JPQLNextParser.MEMBER, 0); }
public TerminalNode OF() { return getToken(JPQLNextParser.OF, 0); }
public PathContext path() {
return getRuleContext(PathContext.class,0);
}
public TerminalNode NOT() { return getToken(JPQLNextParser.NOT, 0); }
public MemberOfPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterMemberOfPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitMemberOfPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitMemberOfPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class IsEmptyPredicateContext extends PredicateContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode IS() { return getToken(JPQLNextParser.IS, 0); }
public TerminalNode EMPTY() { return getToken(JPQLNextParser.EMPTY, 0); }
public TerminalNode NOT() { return getToken(JPQLNextParser.NOT, 0); }
public IsEmptyPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterIsEmptyPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitIsEmptyPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitIsEmptyPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class QuantifiedSimpleEqualityPredicateContext extends PredicateContext {
public Token quantifier;
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode EQUAL() { return getToken(JPQLNextParser.EQUAL, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public TerminalNode ALL() { return getToken(JPQLNextParser.ALL, 0); }
public TerminalNode ANY() { return getToken(JPQLNextParser.ANY, 0); }
public TerminalNode SOME() { return getToken(JPQLNextParser.SOME, 0); }
public QuantifiedSimpleEqualityPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterQuantifiedSimpleEqualityPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitQuantifiedSimpleEqualityPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitQuantifiedSimpleEqualityPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class LessThanPredicateContext extends PredicateContext {
public ExpressionContext lhs;
public ExpressionContext rhs;
public TerminalNode LESS() { return getToken(JPQLNextParser.LESS, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public LessThanPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterLessThanPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitLessThanPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitLessThanPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class IsNullPredicateContext extends PredicateContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode IS() { return getToken(JPQLNextParser.IS, 0); }
public TerminalNode NULL() { return getToken(JPQLNextParser.NULL, 0); }
public TerminalNode NOT() { return getToken(JPQLNextParser.NOT, 0); }
public IsNullPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterIsNullPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitIsNullPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitIsNullPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class GreaterThanOrEqualPredicateContext extends PredicateContext {
public ExpressionContext lhs;
public ExpressionContext rhs;
public TerminalNode GREATER_EQUAL() { return getToken(JPQLNextParser.GREATER_EQUAL, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public GreaterThanOrEqualPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterGreaterThanOrEqualPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitGreaterThanOrEqualPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitGreaterThanOrEqualPredicate(this);
else return visitor.visitChildren(this);
}
}
public static class QuantifiedSimpleGreaterThanOrEqualPredicateContext extends PredicateContext {
public Token quantifier;
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode GREATER_EQUAL() { return getToken(JPQLNextParser.GREATER_EQUAL, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public TerminalNode ALL() { return getToken(JPQLNextParser.ALL, 0); }
public TerminalNode ANY() { return getToken(JPQLNextParser.ANY, 0); }
public TerminalNode SOME() { return getToken(JPQLNextParser.SOME, 0); }
public QuantifiedSimpleGreaterThanOrEqualPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterQuantifiedSimpleGreaterThanOrEqualPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitQuantifiedSimpleGreaterThanOrEqualPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitQuantifiedSimpleGreaterThanOrEqualPredicate(this);
else return visitor.visitChildren(this);
}
}
public final PredicateContext predicate() throws RecognitionException {
return predicate(0);
}
private PredicateContext predicate(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
PredicateContext _localctx = new PredicateContext(_ctx, _parentState);
PredicateContext _prevctx = _localctx;
int _startState = 144;
enterRecursionRule(_localctx, 144, RULE_predicate, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1135);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) {
case 1:
{
_localctx = new GroupedPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(974);
match(LP);
setState(975);
predicate(0);
setState(976);
match(RP);
}
break;
case 2:
{
_localctx = new NegatedPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(978);
match(NOT);
setState(979);
predicate(22);
}
break;
case 3:
{
_localctx = new ExistsSimplePredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(981);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(980);
match(NOT);
}
}
setState(983);
match(EXISTS);
setState(989);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AFTER:
case ALL:
case AND:
case ANY:
case AS:
case ASC:
case BEFORE:
case BETWEEN:
case BOTH:
case BY:
case CASE:
case COLLATE:
case CONTAINING:
case COUNT:
case CROSS:
case CURRENT:
case DELETE:
case DESC:
case DISTINCT:
case ELSE:
case EMPTY:
case END:
case ENTRY:
case ESCAPE:
case EXCEPT:
case EXCLUDE:
case EXISTS:
case FETCH:
case FILTER:
case FIRST:
case FOLLOWING:
case FROM:
case FULL:
case GROUP:
case GROUPS:
case HAVING:
case IN:
case INDEX:
case INNER:
case INSERT:
case INTERSECT:
case INTO:
case IS:
case JOIN:
case JUMP:
case KEY:
case LAST:
case LEADING:
case LEFT:
case LIKE:
case LIMIT:
case MEMBER:
case NEW:
case NO:
case NOT:
case NULLS:
case OBJECT:
case OF:
case OFFSET:
case ON:
case OR:
case ORDER:
case OTHERS:
case OUTER:
case OVER:
case PAGE:
case PARTITION:
case PRECEDING:
case RANGE:
case RECURSIVE:
case RETURNING:
case RIGHT:
case ROW:
case ROWS:
case SELECT:
case SET:
case SOME:
case THEN:
case TIES:
case TO:
case TRAILING:
case TREAT:
case TRIM:
case TYPE:
case UNBOUNDED:
case UNION:
case UPDATE:
case VALUE:
case VALUES:
case WHEN:
case WHERE:
case WINDOW:
case WITH:
case IDENTIFIER:
{
setState(984);
identifier();
}
break;
case LP:
{
setState(985);
match(LP);
setState(986);
identifier();
setState(987);
match(RP);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 4:
{
_localctx = new IsNullPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(991);
expression(0);
setState(992);
match(IS);
setState(994);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(993);
match(NOT);
}
}
setState(996);
match(NULL);
}
break;
case 5:
{
_localctx = new IsEmptyPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(998);
expression(0);
setState(999);
match(IS);
setState(1001);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1000);
match(NOT);
}
}
setState(1003);
match(EMPTY);
}
break;
case 6:
{
_localctx = new QuantifiedSimpleEqualityPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1005);
expression(0);
setState(1006);
match(EQUAL);
setState(1008);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,123,_ctx) ) {
case 1:
{
setState(1007);
((QuantifiedSimpleEqualityPredicateContext)_localctx).quantifier = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==ALL || _la==ANY || _la==SOME) ) {
((QuantifiedSimpleEqualityPredicateContext)_localctx).quantifier = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
setState(1015);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AFTER:
case ALL:
case AND:
case ANY:
case AS:
case ASC:
case BEFORE:
case BETWEEN:
case BOTH:
case BY:
case CASE:
case COLLATE:
case CONTAINING:
case COUNT:
case CROSS:
case CURRENT:
case DELETE:
case DESC:
case DISTINCT:
case ELSE:
case EMPTY:
case END:
case ENTRY:
case ESCAPE:
case EXCEPT:
case EXCLUDE:
case EXISTS:
case FETCH:
case FILTER:
case FIRST:
case FOLLOWING:
case FROM:
case FULL:
case GROUP:
case GROUPS:
case HAVING:
case IN:
case INDEX:
case INNER:
case INSERT:
case INTERSECT:
case INTO:
case IS:
case JOIN:
case JUMP:
case KEY:
case LAST:
case LEADING:
case LEFT:
case LIKE:
case LIMIT:
case MEMBER:
case NEW:
case NO:
case NOT:
case NULLS:
case OBJECT:
case OF:
case OFFSET:
case ON:
case OR:
case ORDER:
case OTHERS:
case OUTER:
case OVER:
case PAGE:
case PARTITION:
case PRECEDING:
case RANGE:
case RECURSIVE:
case RETURNING:
case RIGHT:
case ROW:
case ROWS:
case SELECT:
case SET:
case SOME:
case THEN:
case TIES:
case TO:
case TRAILING:
case TREAT:
case TRIM:
case TYPE:
case UNBOUNDED:
case UNION:
case UPDATE:
case VALUE:
case VALUES:
case WHEN:
case WHERE:
case WINDOW:
case WITH:
case IDENTIFIER:
{
setState(1010);
identifier();
}
break;
case LP:
{
{
setState(1011);
match(LP);
setState(1012);
identifier();
setState(1013);
match(RP);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 7:
{
_localctx = new QuantifiedSimpleInequalityPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1017);
expression(0);
setState(1018);
match(NOT_EQUAL);
setState(1020);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) {
case 1:
{
setState(1019);
((QuantifiedSimpleInequalityPredicateContext)_localctx).quantifier = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==ALL || _la==ANY || _la==SOME) ) {
((QuantifiedSimpleInequalityPredicateContext)_localctx).quantifier = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
setState(1027);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AFTER:
case ALL:
case AND:
case ANY:
case AS:
case ASC:
case BEFORE:
case BETWEEN:
case BOTH:
case BY:
case CASE:
case COLLATE:
case CONTAINING:
case COUNT:
case CROSS:
case CURRENT:
case DELETE:
case DESC:
case DISTINCT:
case ELSE:
case EMPTY:
case END:
case ENTRY:
case ESCAPE:
case EXCEPT:
case EXCLUDE:
case EXISTS:
case FETCH:
case FILTER:
case FIRST:
case FOLLOWING:
case FROM:
case FULL:
case GROUP:
case GROUPS:
case HAVING:
case IN:
case INDEX:
case INNER:
case INSERT:
case INTERSECT:
case INTO:
case IS:
case JOIN:
case JUMP:
case KEY:
case LAST:
case LEADING:
case LEFT:
case LIKE:
case LIMIT:
case MEMBER:
case NEW:
case NO:
case NOT:
case NULLS:
case OBJECT:
case OF:
case OFFSET:
case ON:
case OR:
case ORDER:
case OTHERS:
case OUTER:
case OVER:
case PAGE:
case PARTITION:
case PRECEDING:
case RANGE:
case RECURSIVE:
case RETURNING:
case RIGHT:
case ROW:
case ROWS:
case SELECT:
case SET:
case SOME:
case THEN:
case TIES:
case TO:
case TRAILING:
case TREAT:
case TRIM:
case TYPE:
case UNBOUNDED:
case UNION:
case UPDATE:
case VALUE:
case VALUES:
case WHEN:
case WHERE:
case WINDOW:
case WITH:
case IDENTIFIER:
{
setState(1022);
identifier();
}
break;
case LP:
{
{
setState(1023);
match(LP);
setState(1024);
identifier();
setState(1025);
match(RP);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 8:
{
_localctx = new QuantifiedSimpleGreaterThanPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1029);
expression(0);
setState(1030);
match(GREATER);
setState(1032);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) {
case 1:
{
setState(1031);
((QuantifiedSimpleGreaterThanPredicateContext)_localctx).quantifier = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==ALL || _la==ANY || _la==SOME) ) {
((QuantifiedSimpleGreaterThanPredicateContext)_localctx).quantifier = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
setState(1039);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AFTER:
case ALL:
case AND:
case ANY:
case AS:
case ASC:
case BEFORE:
case BETWEEN:
case BOTH:
case BY:
case CASE:
case COLLATE:
case CONTAINING:
case COUNT:
case CROSS:
case CURRENT:
case DELETE:
case DESC:
case DISTINCT:
case ELSE:
case EMPTY:
case END:
case ENTRY:
case ESCAPE:
case EXCEPT:
case EXCLUDE:
case EXISTS:
case FETCH:
case FILTER:
case FIRST:
case FOLLOWING:
case FROM:
case FULL:
case GROUP:
case GROUPS:
case HAVING:
case IN:
case INDEX:
case INNER:
case INSERT:
case INTERSECT:
case INTO:
case IS:
case JOIN:
case JUMP:
case KEY:
case LAST:
case LEADING:
case LEFT:
case LIKE:
case LIMIT:
case MEMBER:
case NEW:
case NO:
case NOT:
case NULLS:
case OBJECT:
case OF:
case OFFSET:
case ON:
case OR:
case ORDER:
case OTHERS:
case OUTER:
case OVER:
case PAGE:
case PARTITION:
case PRECEDING:
case RANGE:
case RECURSIVE:
case RETURNING:
case RIGHT:
case ROW:
case ROWS:
case SELECT:
case SET:
case SOME:
case THEN:
case TIES:
case TO:
case TRAILING:
case TREAT:
case TRIM:
case TYPE:
case UNBOUNDED:
case UNION:
case UPDATE:
case VALUE:
case VALUES:
case WHEN:
case WHERE:
case WINDOW:
case WITH:
case IDENTIFIER:
{
setState(1034);
identifier();
}
break;
case LP:
{
{
setState(1035);
match(LP);
setState(1036);
identifier();
setState(1037);
match(RP);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 9:
{
_localctx = new QuantifiedSimpleGreaterThanOrEqualPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1041);
expression(0);
setState(1042);
match(GREATER_EQUAL);
setState(1044);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) {
case 1:
{
setState(1043);
((QuantifiedSimpleGreaterThanOrEqualPredicateContext)_localctx).quantifier = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==ALL || _la==ANY || _la==SOME) ) {
((QuantifiedSimpleGreaterThanOrEqualPredicateContext)_localctx).quantifier = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
setState(1051);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AFTER:
case ALL:
case AND:
case ANY:
case AS:
case ASC:
case BEFORE:
case BETWEEN:
case BOTH:
case BY:
case CASE:
case COLLATE:
case CONTAINING:
case COUNT:
case CROSS:
case CURRENT:
case DELETE:
case DESC:
case DISTINCT:
case ELSE:
case EMPTY:
case END:
case ENTRY:
case ESCAPE:
case EXCEPT:
case EXCLUDE:
case EXISTS:
case FETCH:
case FILTER:
case FIRST:
case FOLLOWING:
case FROM:
case FULL:
case GROUP:
case GROUPS:
case HAVING:
case IN:
case INDEX:
case INNER:
case INSERT:
case INTERSECT:
case INTO:
case IS:
case JOIN:
case JUMP:
case KEY:
case LAST:
case LEADING:
case LEFT:
case LIKE:
case LIMIT:
case MEMBER:
case NEW:
case NO:
case NOT:
case NULLS:
case OBJECT:
case OF:
case OFFSET:
case ON:
case OR:
case ORDER:
case OTHERS:
case OUTER:
case OVER:
case PAGE:
case PARTITION:
case PRECEDING:
case RANGE:
case RECURSIVE:
case RETURNING:
case RIGHT:
case ROW:
case ROWS:
case SELECT:
case SET:
case SOME:
case THEN:
case TIES:
case TO:
case TRAILING:
case TREAT:
case TRIM:
case TYPE:
case UNBOUNDED:
case UNION:
case UPDATE:
case VALUE:
case VALUES:
case WHEN:
case WHERE:
case WINDOW:
case WITH:
case IDENTIFIER:
{
setState(1046);
identifier();
}
break;
case LP:
{
{
setState(1047);
match(LP);
setState(1048);
identifier();
setState(1049);
match(RP);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 10:
{
_localctx = new QuantifiedSimpleLessThanPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1053);
expression(0);
setState(1054);
match(LESS);
setState(1056);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) {
case 1:
{
setState(1055);
((QuantifiedSimpleLessThanPredicateContext)_localctx).quantifier = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==ALL || _la==ANY || _la==SOME) ) {
((QuantifiedSimpleLessThanPredicateContext)_localctx).quantifier = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
setState(1063);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AFTER:
case ALL:
case AND:
case ANY:
case AS:
case ASC:
case BEFORE:
case BETWEEN:
case BOTH:
case BY:
case CASE:
case COLLATE:
case CONTAINING:
case COUNT:
case CROSS:
case CURRENT:
case DELETE:
case DESC:
case DISTINCT:
case ELSE:
case EMPTY:
case END:
case ENTRY:
case ESCAPE:
case EXCEPT:
case EXCLUDE:
case EXISTS:
case FETCH:
case FILTER:
case FIRST:
case FOLLOWING:
case FROM:
case FULL:
case GROUP:
case GROUPS:
case HAVING:
case IN:
case INDEX:
case INNER:
case INSERT:
case INTERSECT:
case INTO:
case IS:
case JOIN:
case JUMP:
case KEY:
case LAST:
case LEADING:
case LEFT:
case LIKE:
case LIMIT:
case MEMBER:
case NEW:
case NO:
case NOT:
case NULLS:
case OBJECT:
case OF:
case OFFSET:
case ON:
case OR:
case ORDER:
case OTHERS:
case OUTER:
case OVER:
case PAGE:
case PARTITION:
case PRECEDING:
case RANGE:
case RECURSIVE:
case RETURNING:
case RIGHT:
case ROW:
case ROWS:
case SELECT:
case SET:
case SOME:
case THEN:
case TIES:
case TO:
case TRAILING:
case TREAT:
case TRIM:
case TYPE:
case UNBOUNDED:
case UNION:
case UPDATE:
case VALUE:
case VALUES:
case WHEN:
case WHERE:
case WINDOW:
case WITH:
case IDENTIFIER:
{
setState(1058);
identifier();
}
break;
case LP:
{
{
setState(1059);
match(LP);
setState(1060);
identifier();
setState(1061);
match(RP);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 11:
{
_localctx = new QuantifiedSimpleLessThanOrEqualPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1065);
expression(0);
setState(1066);
match(LESS_EQUAL);
setState(1068);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,133,_ctx) ) {
case 1:
{
setState(1067);
((QuantifiedSimpleLessThanOrEqualPredicateContext)_localctx).quantifier = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==ALL || _la==ANY || _la==SOME) ) {
((QuantifiedSimpleLessThanOrEqualPredicateContext)_localctx).quantifier = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
setState(1075);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AFTER:
case ALL:
case AND:
case ANY:
case AS:
case ASC:
case BEFORE:
case BETWEEN:
case BOTH:
case BY:
case CASE:
case COLLATE:
case CONTAINING:
case COUNT:
case CROSS:
case CURRENT:
case DELETE:
case DESC:
case DISTINCT:
case ELSE:
case EMPTY:
case END:
case ENTRY:
case ESCAPE:
case EXCEPT:
case EXCLUDE:
case EXISTS:
case FETCH:
case FILTER:
case FIRST:
case FOLLOWING:
case FROM:
case FULL:
case GROUP:
case GROUPS:
case HAVING:
case IN:
case INDEX:
case INNER:
case INSERT:
case INTERSECT:
case INTO:
case IS:
case JOIN:
case JUMP:
case KEY:
case LAST:
case LEADING:
case LEFT:
case LIKE:
case LIMIT:
case MEMBER:
case NEW:
case NO:
case NOT:
case NULLS:
case OBJECT:
case OF:
case OFFSET:
case ON:
case OR:
case ORDER:
case OTHERS:
case OUTER:
case OVER:
case PAGE:
case PARTITION:
case PRECEDING:
case RANGE:
case RECURSIVE:
case RETURNING:
case RIGHT:
case ROW:
case ROWS:
case SELECT:
case SET:
case SOME:
case THEN:
case TIES:
case TO:
case TRAILING:
case TREAT:
case TRIM:
case TYPE:
case UNBOUNDED:
case UNION:
case UPDATE:
case VALUE:
case VALUES:
case WHEN:
case WHERE:
case WINDOW:
case WITH:
case IDENTIFIER:
{
setState(1070);
identifier();
}
break;
case LP:
{
{
setState(1071);
match(LP);
setState(1072);
identifier();
setState(1073);
match(RP);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 12:
{
_localctx = new EqualityPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1077);
((EqualityPredicateContext)_localctx).lhs = expression(0);
setState(1078);
match(EQUAL);
setState(1079);
((EqualityPredicateContext)_localctx).rhs = expression(0);
}
break;
case 13:
{
_localctx = new InequalityPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1081);
((InequalityPredicateContext)_localctx).lhs = expression(0);
setState(1082);
match(NOT_EQUAL);
setState(1083);
((InequalityPredicateContext)_localctx).rhs = expression(0);
}
break;
case 14:
{
_localctx = new GreaterThanPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1085);
((GreaterThanPredicateContext)_localctx).lhs = expression(0);
setState(1086);
match(GREATER);
setState(1087);
((GreaterThanPredicateContext)_localctx).rhs = expression(0);
}
break;
case 15:
{
_localctx = new GreaterThanOrEqualPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1089);
((GreaterThanOrEqualPredicateContext)_localctx).lhs = expression(0);
setState(1090);
match(GREATER_EQUAL);
setState(1091);
((GreaterThanOrEqualPredicateContext)_localctx).rhs = expression(0);
}
break;
case 16:
{
_localctx = new LessThanPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1093);
((LessThanPredicateContext)_localctx).lhs = expression(0);
setState(1094);
match(LESS);
setState(1095);
((LessThanPredicateContext)_localctx).rhs = expression(0);
}
break;
case 17:
{
_localctx = new LessThanOrEqualPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1097);
((LessThanOrEqualPredicateContext)_localctx).lhs = expression(0);
setState(1098);
match(LESS_EQUAL);
setState(1099);
((LessThanOrEqualPredicateContext)_localctx).rhs = expression(0);
}
break;
case 18:
{
_localctx = new InPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1101);
expression(0);
setState(1103);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1102);
match(NOT);
}
}
setState(1105);
match(IN);
setState(1106);
inList();
}
break;
case 19:
{
_localctx = new BetweenPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1108);
((BetweenPredicateContext)_localctx).lhs = expression(0);
setState(1110);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1109);
match(NOT);
}
}
setState(1112);
match(BETWEEN);
setState(1113);
((BetweenPredicateContext)_localctx).start = expression(0);
setState(1114);
match(AND);
setState(1115);
((BetweenPredicateContext)_localctx).end = expression(0);
}
break;
case 20:
{
_localctx = new LikePredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1117);
((LikePredicateContext)_localctx).lhs = expression(0);
setState(1119);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1118);
match(NOT);
}
}
setState(1121);
match(LIKE);
setState(1122);
((LikePredicateContext)_localctx).like = expression(0);
setState(1125);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) {
case 1:
{
setState(1123);
match(ESCAPE);
setState(1124);
((LikePredicateContext)_localctx).escape = expression(0);
}
break;
}
}
break;
case 21:
{
_localctx = new MemberOfPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1127);
expression(0);
setState(1129);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1128);
match(NOT);
}
}
setState(1131);
match(MEMBER);
setState(1132);
match(OF);
setState(1133);
path();
}
break;
}
_ctx.stop = _input.LT(-1);
setState(1145);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,142,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(1143);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,141,_ctx) ) {
case 1:
{
_localctx = new AndPredicateContext(new PredicateContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_predicate);
setState(1137);
if (!(precpred(_ctx, 21))) throw new FailedPredicateException(this, "precpred(_ctx, 21)");
setState(1138);
match(AND);
setState(1139);
predicate(22);
}
break;
case 2:
{
_localctx = new OrPredicateContext(new PredicateContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_predicate);
setState(1140);
if (!(precpred(_ctx, 20))) throw new FailedPredicateException(this, "precpred(_ctx, 20)");
setState(1141);
match(OR);
setState(1142);
predicate(21);
}
break;
}
}
}
setState(1147);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,142,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class PredicateOrExpressionContext extends ParserRuleContext {
public PredicateContext predicate() {
return getRuleContext(PredicateContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public PredicateOrExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_predicateOrExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterPredicateOrExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitPredicateOrExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitPredicateOrExpression(this);
else return visitor.visitChildren(this);
}
}
public final PredicateOrExpressionContext predicateOrExpression() throws RecognitionException {
PredicateOrExpressionContext _localctx = new PredicateOrExpressionContext(_ctx, getState());
enterRule(_localctx, 146, RULE_predicateOrExpression);
try {
setState(1150);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1148);
predicate(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1149);
expression(0);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InListContext extends ParserRuleContext {
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public InListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_inList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterInList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitInList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitInList(this);
else return visitor.visitChildren(this);
}
}
public final InListContext inList() throws RecognitionException {
InListContext _localctx = new InListContext(_ctx, getState());
enterRule(_localctx, 148, RULE_inList);
int _la;
try {
setState(1164);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,145,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1152);
match(LP);
setState(1153);
expression(0);
setState(1158);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1154);
match(COMMA);
setState(1155);
expression(0);
}
}
setState(1160);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1161);
match(RP);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1163);
expression(0);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EntityTypeContext extends ParserRuleContext {
public TerminalNode TYPE() { return getToken(JPQLNextParser.TYPE, 0); }
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public PathContext path() {
return getRuleContext(PathContext.class,0);
}
public ParameterContext parameter() {
return getRuleContext(ParameterContext.class,0);
}
public EntityTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_entityType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterEntityType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitEntityType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitEntityType(this);
else return visitor.visitChildren(this);
}
}
public final EntityTypeContext entityType() throws RecognitionException {
EntityTypeContext _localctx = new EntityTypeContext(_ctx, getState());
enterRule(_localctx, 150, RULE_entityType);
try {
enterOuterAlt(_localctx, 1);
{
setState(1166);
match(TYPE);
setState(1167);
match(LP);
setState(1170);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AFTER:
case ALL:
case AND:
case ANY:
case AS:
case ASC:
case BEFORE:
case BETWEEN:
case BOTH:
case BY:
case CASE:
case COLLATE:
case CONTAINING:
case COUNT:
case CROSS:
case CURRENT:
case DELETE:
case DESC:
case DISTINCT:
case ELSE:
case EMPTY:
case END:
case ENTRY:
case ESCAPE:
case EXCEPT:
case EXCLUDE:
case EXISTS:
case FETCH:
case FILTER:
case FIRST:
case FOLLOWING:
case FROM:
case FULL:
case GROUP:
case GROUPS:
case HAVING:
case IN:
case INDEX:
case INNER:
case INSERT:
case INTERSECT:
case INTO:
case IS:
case JOIN:
case JUMP:
case KEY:
case LAST:
case LEADING:
case LEFT:
case LIKE:
case LIMIT:
case MEMBER:
case NEW:
case NO:
case NOT:
case NULLS:
case OBJECT:
case OF:
case OFFSET:
case ON:
case OR:
case ORDER:
case OTHERS:
case OUTER:
case OVER:
case PAGE:
case PARTITION:
case PRECEDING:
case RANGE:
case RECURSIVE:
case RETURNING:
case RIGHT:
case ROW:
case ROWS:
case SELECT:
case SET:
case SOME:
case THEN:
case TIES:
case TO:
case TRAILING:
case TREAT:
case TRIM:
case TYPE:
case UNBOUNDED:
case UNION:
case UPDATE:
case VALUE:
case VALUES:
case WHEN:
case WHERE:
case WINDOW:
case WITH:
case IDENTIFIER:
{
setState(1168);
path();
}
break;
case COLON:
case QUESTION_MARK:
{
setState(1169);
parameter();
}
break;
default:
throw new NoViableAltException(this);
}
setState(1172);
match(RP);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SimpleCaseWhenContext extends ParserRuleContext {
public ExpressionContext when;
public ExpressionContext then;
public TerminalNode WHEN() { return getToken(JPQLNextParser.WHEN, 0); }
public TerminalNode THEN() { return getToken(JPQLNextParser.THEN, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public SimpleCaseWhenContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simpleCaseWhen; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSimpleCaseWhen(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSimpleCaseWhen(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSimpleCaseWhen(this);
else return visitor.visitChildren(this);
}
}
public final SimpleCaseWhenContext simpleCaseWhen() throws RecognitionException {
SimpleCaseWhenContext _localctx = new SimpleCaseWhenContext(_ctx, getState());
enterRule(_localctx, 152, RULE_simpleCaseWhen);
try {
enterOuterAlt(_localctx, 1);
{
setState(1174);
match(WHEN);
setState(1175);
((SimpleCaseWhenContext)_localctx).when = expression(0);
setState(1176);
match(THEN);
setState(1177);
((SimpleCaseWhenContext)_localctx).then = expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SearchedCaseWhenContext extends ParserRuleContext {
public TerminalNode WHEN() { return getToken(JPQLNextParser.WHEN, 0); }
public PredicateContext predicate() {
return getRuleContext(PredicateContext.class,0);
}
public TerminalNode THEN() { return getToken(JPQLNextParser.THEN, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public SearchedCaseWhenContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_searchedCaseWhen; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterSearchedCaseWhen(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitSearchedCaseWhen(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitSearchedCaseWhen(this);
else return visitor.visitChildren(this);
}
}
public final SearchedCaseWhenContext searchedCaseWhen() throws RecognitionException {
SearchedCaseWhenContext _localctx = new SearchedCaseWhenContext(_ctx, getState());
enterRule(_localctx, 154, RULE_searchedCaseWhen);
try {
enterOuterAlt(_localctx, 1);
{
setState(1179);
match(WHEN);
setState(1180);
predicate(0);
setState(1181);
match(THEN);
setState(1182);
expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LiteralContext extends ParserRuleContext {
public TerminalNode STRING_LITERAL() { return getToken(JPQLNextParser.STRING_LITERAL, 0); }
public TerminalNode CHARACTER_LITERAL() { return getToken(JPQLNextParser.CHARACTER_LITERAL, 0); }
public TerminalNode INTEGER_LITERAL() { return getToken(JPQLNextParser.INTEGER_LITERAL, 0); }
public TerminalNode LONG_LITERAL() { return getToken(JPQLNextParser.LONG_LITERAL, 0); }
public TerminalNode BIG_INTEGER_LITERAL() { return getToken(JPQLNextParser.BIG_INTEGER_LITERAL, 0); }
public TerminalNode FLOAT_LITERAL() { return getToken(JPQLNextParser.FLOAT_LITERAL, 0); }
public TerminalNode DOUBLE_LITERAL() { return getToken(JPQLNextParser.DOUBLE_LITERAL, 0); }
public TerminalNode BIG_DECIMAL_LITERAL() { return getToken(JPQLNextParser.BIG_DECIMAL_LITERAL, 0); }
public TerminalNode NULL() { return getToken(JPQLNextParser.NULL, 0); }
public TerminalNode TRUE() { return getToken(JPQLNextParser.TRUE, 0); }
public TerminalNode FALSE() { return getToken(JPQLNextParser.FALSE, 0); }
public TimestampLiteralContext timestampLiteral() {
return getRuleContext(TimestampLiteralContext.class,0);
}
public DateLiteralContext dateLiteral() {
return getRuleContext(DateLiteralContext.class,0);
}
public TimeLiteralContext timeLiteral() {
return getRuleContext(TimeLiteralContext.class,0);
}
public LiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_literal; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitLiteral(this);
else return visitor.visitChildren(this);
}
}
public final LiteralContext literal() throws RecognitionException {
LiteralContext _localctx = new LiteralContext(_ctx, getState());
enterRule(_localctx, 156, RULE_literal);
try {
setState(1198);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING_LITERAL:
enterOuterAlt(_localctx, 1);
{
setState(1184);
match(STRING_LITERAL);
}
break;
case CHARACTER_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(1185);
match(CHARACTER_LITERAL);
}
break;
case INTEGER_LITERAL:
enterOuterAlt(_localctx, 3);
{
setState(1186);
match(INTEGER_LITERAL);
}
break;
case LONG_LITERAL:
enterOuterAlt(_localctx, 4);
{
setState(1187);
match(LONG_LITERAL);
}
break;
case BIG_INTEGER_LITERAL:
enterOuterAlt(_localctx, 5);
{
setState(1188);
match(BIG_INTEGER_LITERAL);
}
break;
case FLOAT_LITERAL:
enterOuterAlt(_localctx, 6);
{
setState(1189);
match(FLOAT_LITERAL);
}
break;
case DOUBLE_LITERAL:
enterOuterAlt(_localctx, 7);
{
setState(1190);
match(DOUBLE_LITERAL);
}
break;
case BIG_DECIMAL_LITERAL:
enterOuterAlt(_localctx, 8);
{
setState(1191);
match(BIG_DECIMAL_LITERAL);
}
break;
case NULL:
enterOuterAlt(_localctx, 9);
{
setState(1192);
match(NULL);
}
break;
case TRUE:
enterOuterAlt(_localctx, 10);
{
setState(1193);
match(TRUE);
}
break;
case FALSE:
enterOuterAlt(_localctx, 11);
{
setState(1194);
match(FALSE);
}
break;
case TIMESTAMP_ESCAPE_START:
enterOuterAlt(_localctx, 12);
{
setState(1195);
timestampLiteral();
}
break;
case DATE_ESCAPE_START:
enterOuterAlt(_localctx, 13);
{
setState(1196);
dateLiteral();
}
break;
case TIME_ESCAPE_START:
enterOuterAlt(_localctx, 14);
{
setState(1197);
timeLiteral();
}
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 TimestampLiteralContext extends ParserRuleContext {
public TerminalNode TIMESTAMP_ESCAPE_START() { return getToken(JPQLNextParser.TIMESTAMP_ESCAPE_START, 0); }
public DateTimeLiteralTextContext dateTimeLiteralText() {
return getRuleContext(DateTimeLiteralTextContext.class,0);
}
public TerminalNode TEMPORAL_ESCAPE_END() { return getToken(JPQLNextParser.TEMPORAL_ESCAPE_END, 0); }
public TimestampLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_timestampLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterTimestampLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitTimestampLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitTimestampLiteral(this);
else return visitor.visitChildren(this);
}
}
public final TimestampLiteralContext timestampLiteral() throws RecognitionException {
TimestampLiteralContext _localctx = new TimestampLiteralContext(_ctx, getState());
enterRule(_localctx, 158, RULE_timestampLiteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(1200);
match(TIMESTAMP_ESCAPE_START);
setState(1201);
dateTimeLiteralText();
setState(1202);
match(TEMPORAL_ESCAPE_END);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DateLiteralContext extends ParserRuleContext {
public TerminalNode DATE_ESCAPE_START() { return getToken(JPQLNextParser.DATE_ESCAPE_START, 0); }
public DateTimeLiteralTextContext dateTimeLiteralText() {
return getRuleContext(DateTimeLiteralTextContext.class,0);
}
public TerminalNode TEMPORAL_ESCAPE_END() { return getToken(JPQLNextParser.TEMPORAL_ESCAPE_END, 0); }
public DateLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dateLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterDateLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitDateLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitDateLiteral(this);
else return visitor.visitChildren(this);
}
}
public final DateLiteralContext dateLiteral() throws RecognitionException {
DateLiteralContext _localctx = new DateLiteralContext(_ctx, getState());
enterRule(_localctx, 160, RULE_dateLiteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(1204);
match(DATE_ESCAPE_START);
setState(1205);
dateTimeLiteralText();
setState(1206);
match(TEMPORAL_ESCAPE_END);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TimeLiteralContext extends ParserRuleContext {
public TerminalNode TIME_ESCAPE_START() { return getToken(JPQLNextParser.TIME_ESCAPE_START, 0); }
public DateTimeLiteralTextContext dateTimeLiteralText() {
return getRuleContext(DateTimeLiteralTextContext.class,0);
}
public TerminalNode TEMPORAL_ESCAPE_END() { return getToken(JPQLNextParser.TEMPORAL_ESCAPE_END, 0); }
public TimeLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_timeLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterTimeLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitTimeLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitTimeLiteral(this);
else return visitor.visitChildren(this);
}
}
public final TimeLiteralContext timeLiteral() throws RecognitionException {
TimeLiteralContext _localctx = new TimeLiteralContext(_ctx, getState());
enterRule(_localctx, 162, RULE_timeLiteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(1208);
match(TIME_ESCAPE_START);
setState(1209);
dateTimeLiteralText();
setState(1210);
match(TEMPORAL_ESCAPE_END);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DateTimeLiteralTextContext extends ParserRuleContext {
public TerminalNode STRING_LITERAL() { return getToken(JPQLNextParser.STRING_LITERAL, 0); }
public TerminalNode CHARACTER_LITERAL() { return getToken(JPQLNextParser.CHARACTER_LITERAL, 0); }
public DateTimeLiteralTextContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dateTimeLiteralText; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterDateTimeLiteralText(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitDateTimeLiteralText(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitDateTimeLiteralText(this);
else return visitor.visitChildren(this);
}
}
public final DateTimeLiteralTextContext dateTimeLiteralText() throws RecognitionException {
DateTimeLiteralTextContext _localctx = new DateTimeLiteralTextContext(_ctx, getState());
enterRule(_localctx, 164, RULE_dateTimeLiteralText);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1212);
_la = _input.LA(1);
if ( !(_la==CHARACTER_LITERAL || _la==STRING_LITERAL) ) {
_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 ParameterContext extends ParserRuleContext {
public ParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameter; }
public ParameterContext() { }
public void copyFrom(ParameterContext ctx) {
super.copyFrom(ctx);
}
}
public static class NamedParameterContext extends ParameterContext {
public TerminalNode COLON() { return getToken(JPQLNextParser.COLON, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public NamedParameterContext(ParameterContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterNamedParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitNamedParameter(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitNamedParameter(this);
else return visitor.visitChildren(this);
}
}
public static class PositionalParameterContext extends ParameterContext {
public TerminalNode QUESTION_MARK() { return getToken(JPQLNextParser.QUESTION_MARK, 0); }
public TerminalNode INTEGER_LITERAL() { return getToken(JPQLNextParser.INTEGER_LITERAL, 0); }
public PositionalParameterContext(ParameterContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterPositionalParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitPositionalParameter(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitPositionalParameter(this);
else return visitor.visitChildren(this);
}
}
public final ParameterContext parameter() throws RecognitionException {
ParameterContext _localctx = new ParameterContext(_ctx, getState());
enterRule(_localctx, 166, RULE_parameter);
try {
setState(1218);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COLON:
_localctx = new NamedParameterContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1214);
match(COLON);
setState(1215);
identifier();
}
break;
case QUESTION_MARK:
_localctx = new PositionalParameterContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1216);
match(QUESTION_MARK);
setState(1217);
match(INTEGER_LITERAL);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FunctionContext extends ParserRuleContext {
public FunctionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_function; }
public FunctionContext() { }
public void copyFrom(FunctionContext ctx) {
super.copyFrom(ctx);
}
}
public static class TemporalFunctionContext extends FunctionContext {
public Token name;
public TerminalNode CURRENT_DATE() { return getToken(JPQLNextParser.CURRENT_DATE, 0); }
public TerminalNode CURRENT_TIME() { return getToken(JPQLNextParser.CURRENT_TIME, 0); }
public TerminalNode CURRENT_TIMESTAMP() { return getToken(JPQLNextParser.CURRENT_TIMESTAMP, 0); }
public TerminalNode CURRENT_INSTANT() { return getToken(JPQLNextParser.CURRENT_INSTANT, 0); }
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public TemporalFunctionContext(FunctionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterTemporalFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitTemporalFunction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitTemporalFunction(this);
else return visitor.visitChildren(this);
}
}
public static class TrimFunctionContext extends FunctionContext {
public TerminalNode TRIM() { return getToken(JPQLNextParser.TRIM, 0); }
public TerminalNode LP() { return getToken(JPQLNextParser.LP, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RP() { return getToken(JPQLNextParser.RP, 0); }
public TrimSpecificationContext trimSpecification() {
return getRuleContext(TrimSpecificationContext.class,0);
}
public TrimCharacterContext trimCharacter() {
return getRuleContext(TrimCharacterContext.class,0);
}
public TerminalNode FROM() { return getToken(JPQLNextParser.FROM, 0); }
public TrimFunctionContext(FunctionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterTrimFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitTrimFunction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitTrimFunction(this);
else return visitor.visitChildren(this);
}
}
public static class CountFunctionContext extends FunctionContext {
public IdentifierContext windowName;
public TerminalNode COUNT() { return getToken(JPQLNextParser.COUNT, 0); }
public List LP() { return getTokens(JPQLNextParser.LP); }
public TerminalNode LP(int i) {
return getToken(JPQLNextParser.LP, i);
}
public List RP() { return getTokens(JPQLNextParser.RP); }
public TerminalNode RP(int i) {
return getToken(JPQLNextParser.RP, i);
}
public TerminalNode ASTERISK() { return getToken(JPQLNextParser.ASTERISK, 0); }
public TerminalNode FILTER() { return getToken(JPQLNextParser.FILTER, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public TerminalNode OVER() { return getToken(JPQLNextParser.OVER, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode DISTINCT() { return getToken(JPQLNextParser.DISTINCT, 0); }
public WindowDefinitionContext windowDefinition() {
return getRuleContext(WindowDefinitionContext.class,0);
}
public CountFunctionContext(FunctionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterCountFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitCountFunction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitCountFunction(this);
else return visitor.visitChildren(this);
}
}
public static class GenericFunctionInvocationContext extends FunctionContext {
public IdentifierContext name;
public IdentifierContext windowName;
public List LP() { return getTokens(JPQLNextParser.LP); }
public TerminalNode LP(int i) {
return getToken(JPQLNextParser.LP, i);
}
public List RP() { return getTokens(JPQLNextParser.RP); }
public TerminalNode RP(int i) {
return getToken(JPQLNextParser.RP, i);
}
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public TerminalNode DISTINCT() { return getToken(JPQLNextParser.DISTINCT, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode WITHIN() { return getToken(JPQLNextParser.WITHIN, 0); }
public TerminalNode GROUP() { return getToken(JPQLNextParser.GROUP, 0); }
public OrderByClauseContext orderByClause() {
return getRuleContext(OrderByClauseContext.class,0);
}
public TerminalNode FILTER() { return getToken(JPQLNextParser.FILTER, 0); }
public WhereClauseContext whereClause() {
return getRuleContext(WhereClauseContext.class,0);
}
public TerminalNode OVER() { return getToken(JPQLNextParser.OVER, 0); }
public List COMMA() { return getTokens(JPQLNextParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(JPQLNextParser.COMMA, i);
}
public WindowDefinitionContext windowDefinition() {
return getRuleContext(WindowDefinitionContext.class,0);
}
public GenericFunctionInvocationContext(FunctionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterGenericFunctionInvocation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitGenericFunctionInvocation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitGenericFunctionInvocation(this);
else return visitor.visitChildren(this);
}
}
public final FunctionContext function() throws RecognitionException {
FunctionContext _localctx = new FunctionContext(_ctx, getState());
enterRule(_localctx, 168, RULE_function);
int _la;
try {
setState(1307);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,165,_ctx) ) {
case 1:
_localctx = new TrimFunctionContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1220);
match(TRIM);
setState(1221);
match(LP);
setState(1223);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,149,_ctx) ) {
case 1:
{
setState(1222);
trimSpecification();
}
break;
}
setState(1226);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) {
case 1:
{
setState(1225);
trimCharacter();
}
break;
}
setState(1229);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,151,_ctx) ) {
case 1:
{
setState(1228);
match(FROM);
}
break;
}
setState(1231);
expression(0);
setState(1232);
match(RP);
}
break;
case 2:
_localctx = new TemporalFunctionContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1234);
((TemporalFunctionContext)_localctx).name = _input.LT(1);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << CURRENT_DATE) | (1L << CURRENT_INSTANT) | (1L << CURRENT_TIME) | (1L << CURRENT_TIMESTAMP))) != 0)) ) {
((TemporalFunctionContext)_localctx).name = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(1237);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,152,_ctx) ) {
case 1:
{
setState(1235);
match(LP);
setState(1236);
match(RP);
}
break;
}
}
break;
case 3:
_localctx = new CountFunctionContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(1239);
match(COUNT);
setState(1240);
match(LP);
setState(1246);
_errHandler.sync(this);
switch (_input.LA(1)) {
case INTEGER_LITERAL:
case BIG_INTEGER_LITERAL:
case LONG_LITERAL:
case FLOAT_LITERAL:
case DOUBLE_LITERAL:
case BIG_DECIMAL_LITERAL:
case CHARACTER_LITERAL:
case STRING_LITERAL:
case AFTER:
case ALL:
case AND:
case ANY:
case AS:
case ASC:
case BEFORE:
case BETWEEN:
case BOTH:
case BY:
case CASE:
case COLLATE:
case CONTAINING:
case COUNT:
case CROSS:
case CURRENT:
case CURRENT_DATE:
case CURRENT_INSTANT:
case CURRENT_TIME:
case CURRENT_TIMESTAMP:
case DELETE:
case DESC:
case DISTINCT:
case ELSE:
case EMPTY:
case END:
case ENTRY:
case ESCAPE:
case EXCEPT:
case EXCLUDE:
case EXISTS:
case FALSE:
case FETCH:
case FILTER:
case FIRST:
case FOLLOWING:
case FROM:
case FULL:
case GROUP:
case GROUPS:
case HAVING:
case IN:
case INDEX:
case INNER:
case INSERT:
case INTERSECT:
case INTO:
case IS:
case JOIN:
case JUMP:
case KEY:
case LAST:
case LEADING:
case LEFT:
case LIKE:
case LIMIT:
case MEMBER:
case NEW:
case NO:
case NOT:
case NULL:
case NULLS:
case OBJECT:
case OF:
case OFFSET:
case ON:
case OR:
case ORDER:
case OTHERS:
case OUTER:
case OVER:
case PAGE:
case PARTITION:
case PRECEDING:
case RANGE:
case RECURSIVE:
case RETURNING:
case RIGHT:
case ROW:
case ROWS:
case SELECT:
case SET:
case SOME:
case THEN:
case TIES:
case TO:
case TRAILING:
case TREAT:
case TRIM:
case TRUE:
case TYPE:
case UNBOUNDED:
case UNION:
case UPDATE:
case VALUE:
case VALUES:
case WHEN:
case WHERE:
case WINDOW:
case WITH:
case TIMESTAMP_ESCAPE_START:
case DATE_ESCAPE_START:
case TIME_ESCAPE_START:
case LP:
case PLUS:
case MINUS:
case COLON:
case QUESTION_MARK:
case IDENTIFIER:
{
{
setState(1242);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,153,_ctx) ) {
case 1:
{
setState(1241);
match(DISTINCT);
}
break;
}
setState(1244);
expression(0);
}
}
break;
case ASTERISK:
{
setState(1245);
match(ASTERISK);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1248);
match(RP);
setState(1254);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,155,_ctx) ) {
case 1:
{
setState(1249);
match(FILTER);
setState(1250);
match(LP);
setState(1251);
whereClause();
setState(1252);
match(RP);
}
break;
}
setState(1264);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) {
case 1:
{
setState(1256);
match(OVER);
setState(1262);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AFTER:
case ALL:
case AND:
case ANY:
case AS:
case ASC:
case BEFORE:
case BETWEEN:
case BOTH:
case BY:
case CASE:
case COLLATE:
case CONTAINING:
case COUNT:
case CROSS:
case CURRENT:
case DELETE:
case DESC:
case DISTINCT:
case ELSE:
case EMPTY:
case END:
case ENTRY:
case ESCAPE:
case EXCEPT:
case EXCLUDE:
case EXISTS:
case FETCH:
case FILTER:
case FIRST:
case FOLLOWING:
case FROM:
case FULL:
case GROUP:
case GROUPS:
case HAVING:
case IN:
case INDEX:
case INNER:
case INSERT:
case INTERSECT:
case INTO:
case IS:
case JOIN:
case JUMP:
case KEY:
case LAST:
case LEADING:
case LEFT:
case LIKE:
case LIMIT:
case MEMBER:
case NEW:
case NO:
case NOT:
case NULLS:
case OBJECT:
case OF:
case OFFSET:
case ON:
case OR:
case ORDER:
case OTHERS:
case OUTER:
case OVER:
case PAGE:
case PARTITION:
case PRECEDING:
case RANGE:
case RECURSIVE:
case RETURNING:
case RIGHT:
case ROW:
case ROWS:
case SELECT:
case SET:
case SOME:
case THEN:
case TIES:
case TO:
case TRAILING:
case TREAT:
case TRIM:
case TYPE:
case UNBOUNDED:
case UNION:
case UPDATE:
case VALUE:
case VALUES:
case WHEN:
case WHERE:
case WINDOW:
case WITH:
case IDENTIFIER:
{
setState(1257);
((CountFunctionContext)_localctx).windowName = identifier();
}
break;
case LP:
{
{
setState(1258);
match(LP);
setState(1259);
windowDefinition();
setState(1260);
match(RP);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
}
}
break;
case 4:
_localctx = new GenericFunctionInvocationContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(1266);
((GenericFunctionInvocationContext)_localctx).name = identifier();
setState(1267);
match(LP);
setState(1269);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,158,_ctx) ) {
case 1:
{
setState(1268);
match(DISTINCT);
}
break;
}
setState(1279);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << INTEGER_LITERAL) | (1L << BIG_INTEGER_LITERAL) | (1L << LONG_LITERAL) | (1L << FLOAT_LITERAL) | (1L << DOUBLE_LITERAL) | (1L << BIG_DECIMAL_LITERAL) | (1L << CHARACTER_LITERAL) | (1L << STRING_LITERAL) | (1L << AFTER) | (1L << ALL) | (1L << AND) | (1L << ANY) | (1L << AS) | (1L << ASC) | (1L << BEFORE) | (1L << BETWEEN) | (1L << BOTH) | (1L << BY) | (1L << CASE) | (1L << COLLATE) | (1L << CONTAINING) | (1L << COUNT) | (1L << CROSS) | (1L << CURRENT) | (1L << CURRENT_DATE) | (1L << CURRENT_INSTANT) | (1L << CURRENT_TIME) | (1L << CURRENT_TIMESTAMP) | (1L << DELETE) | (1L << DESC) | (1L << DISTINCT) | (1L << ELSE) | (1L << EMPTY) | (1L << END) | (1L << ENTRY) | (1L << ESCAPE) | (1L << EXCEPT) | (1L << EXCLUDE) | (1L << EXISTS) | (1L << FALSE) | (1L << FETCH) | (1L << FILTER) | (1L << FIRST) | (1L << FOLLOWING) | (1L << FROM) | (1L << FULL) | (1L << GROUP) | (1L << GROUPS) | (1L << HAVING) | (1L << IN) | (1L << INDEX) | (1L << INNER) | (1L << INSERT) | (1L << INTERSECT) | (1L << INTO) | (1L << IS) | (1L << JOIN) | (1L << JUMP) | (1L << KEY) | (1L << LAST) | (1L << LEADING) | (1L << LEFT))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (LIKE - 64)) | (1L << (LIMIT - 64)) | (1L << (MEMBER - 64)) | (1L << (NEW - 64)) | (1L << (NO - 64)) | (1L << (NOT - 64)) | (1L << (NULL - 64)) | (1L << (NULLS - 64)) | (1L << (OBJECT - 64)) | (1L << (OF - 64)) | (1L << (OFFSET - 64)) | (1L << (ON - 64)) | (1L << (OR - 64)) | (1L << (ORDER - 64)) | (1L << (OTHERS - 64)) | (1L << (OUTER - 64)) | (1L << (OVER - 64)) | (1L << (PAGE - 64)) | (1L << (PARTITION - 64)) | (1L << (PRECEDING - 64)) | (1L << (RANGE - 64)) | (1L << (RECURSIVE - 64)) | (1L << (RETURNING - 64)) | (1L << (RIGHT - 64)) | (1L << (ROW - 64)) | (1L << (ROWS - 64)) | (1L << (SELECT - 64)) | (1L << (SET - 64)) | (1L << (SOME - 64)) | (1L << (THEN - 64)) | (1L << (TIES - 64)) | (1L << (TO - 64)) | (1L << (TRAILING - 64)) | (1L << (TREAT - 64)) | (1L << (TRIM - 64)) | (1L << (TRUE - 64)) | (1L << (TYPE - 64)) | (1L << (UNBOUNDED - 64)) | (1L << (UNION - 64)) | (1L << (UPDATE - 64)) | (1L << (VALUE - 64)) | (1L << (VALUES - 64)) | (1L << (WHEN - 64)) | (1L << (WHERE - 64)) | (1L << (WINDOW - 64)) | (1L << (WITH - 64)) | (1L << (TIMESTAMP_ESCAPE_START - 64)) | (1L << (DATE_ESCAPE_START - 64)) | (1L << (TIME_ESCAPE_START - 64)) | (1L << (LP - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (PLUS - 128)) | (1L << (MINUS - 128)) | (1L << (COLON - 128)) | (1L << (QUESTION_MARK - 128)) | (1L << (IDENTIFIER - 128)))) != 0)) {
{
setState(1271);
expression(0);
setState(1276);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1272);
match(COMMA);
setState(1273);
expression(0);
}
}
setState(1278);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(1281);
match(RP);
setState(1288);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,161,_ctx) ) {
case 1:
{
setState(1282);
match(WITHIN);
setState(1283);
match(GROUP);
setState(1284);
match(LP);
setState(1285);
orderByClause();
setState(1286);
match(RP);
}
break;
}
setState(1295);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,162,_ctx) ) {
case 1:
{
setState(1290);
match(FILTER);
setState(1291);
match(LP);
setState(1292);
whereClause();
setState(1293);
match(RP);
}
break;
}
setState(1305);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,164,_ctx) ) {
case 1:
{
setState(1297);
match(OVER);
setState(1303);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AFTER:
case ALL:
case AND:
case ANY:
case AS:
case ASC:
case BEFORE:
case BETWEEN:
case BOTH:
case BY:
case CASE:
case COLLATE:
case CONTAINING:
case COUNT:
case CROSS:
case CURRENT:
case DELETE:
case DESC:
case DISTINCT:
case ELSE:
case EMPTY:
case END:
case ENTRY:
case ESCAPE:
case EXCEPT:
case EXCLUDE:
case EXISTS:
case FETCH:
case FILTER:
case FIRST:
case FOLLOWING:
case FROM:
case FULL:
case GROUP:
case GROUPS:
case HAVING:
case IN:
case INDEX:
case INNER:
case INSERT:
case INTERSECT:
case INTO:
case IS:
case JOIN:
case JUMP:
case KEY:
case LAST:
case LEADING:
case LEFT:
case LIKE:
case LIMIT:
case MEMBER:
case NEW:
case NO:
case NOT:
case NULLS:
case OBJECT:
case OF:
case OFFSET:
case ON:
case OR:
case ORDER:
case OTHERS:
case OUTER:
case OVER:
case PAGE:
case PARTITION:
case PRECEDING:
case RANGE:
case RECURSIVE:
case RETURNING:
case RIGHT:
case ROW:
case ROWS:
case SELECT:
case SET:
case SOME:
case THEN:
case TIES:
case TO:
case TRAILING:
case TREAT:
case TRIM:
case TYPE:
case UNBOUNDED:
case UNION:
case UPDATE:
case VALUE:
case VALUES:
case WHEN:
case WHERE:
case WINDOW:
case WITH:
case IDENTIFIER:
{
setState(1298);
((GenericFunctionInvocationContext)_localctx).windowName = identifier();
}
break;
case LP:
{
{
setState(1299);
match(LP);
setState(1300);
windowDefinition();
setState(1301);
match(RP);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TrimSpecificationContext extends ParserRuleContext {
public TerminalNode LEADING() { return getToken(JPQLNextParser.LEADING, 0); }
public TerminalNode TRAILING() { return getToken(JPQLNextParser.TRAILING, 0); }
public TerminalNode BOTH() { return getToken(JPQLNextParser.BOTH, 0); }
public TrimSpecificationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_trimSpecification; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterTrimSpecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitTrimSpecification(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitTrimSpecification(this);
else return visitor.visitChildren(this);
}
}
public final TrimSpecificationContext trimSpecification() throws RecognitionException {
TrimSpecificationContext _localctx = new TrimSpecificationContext(_ctx, getState());
enterRule(_localctx, 170, RULE_trimSpecification);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1309);
_la = _input.LA(1);
if ( !(_la==BOTH || _la==LEADING || _la==TRAILING) ) {
_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 TrimCharacterContext extends ParserRuleContext {
public TerminalNode CHARACTER_LITERAL() { return getToken(JPQLNextParser.CHARACTER_LITERAL, 0); }
public TerminalNode STRING_LITERAL() { return getToken(JPQLNextParser.STRING_LITERAL, 0); }
public ParameterContext parameter() {
return getRuleContext(ParameterContext.class,0);
}
public TrimCharacterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_trimCharacter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterTrimCharacter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitTrimCharacter(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitTrimCharacter(this);
else return visitor.visitChildren(this);
}
}
public final TrimCharacterContext trimCharacter() throws RecognitionException {
TrimCharacterContext _localctx = new TrimCharacterContext(_ctx, getState());
enterRule(_localctx, 172, RULE_trimCharacter);
try {
setState(1314);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CHARACTER_LITERAL:
enterOuterAlt(_localctx, 1);
{
setState(1311);
match(CHARACTER_LITERAL);
}
break;
case STRING_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(1312);
match(STRING_LITERAL);
}
break;
case COLON:
case QUESTION_MARK:
enterOuterAlt(_localctx, 3);
{
setState(1313);
parameter();
}
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 IdentifierContext extends ParserRuleContext {
public TerminalNode IDENTIFIER() { return getToken(JPQLNextParser.IDENTIFIER, 0); }
public TerminalNode AFTER() { return getToken(JPQLNextParser.AFTER, 0); }
public TerminalNode ALL() { return getToken(JPQLNextParser.ALL, 0); }
public TerminalNode AND() { return getToken(JPQLNextParser.AND, 0); }
public TerminalNode ANY() { return getToken(JPQLNextParser.ANY, 0); }
public TerminalNode AS() { return getToken(JPQLNextParser.AS, 0); }
public TerminalNode ASC() { return getToken(JPQLNextParser.ASC, 0); }
public TerminalNode BEFORE() { return getToken(JPQLNextParser.BEFORE, 0); }
public TerminalNode BETWEEN() { return getToken(JPQLNextParser.BETWEEN, 0); }
public TerminalNode BOTH() { return getToken(JPQLNextParser.BOTH, 0); }
public TerminalNode BY() { return getToken(JPQLNextParser.BY, 0); }
public TerminalNode CASE() { return getToken(JPQLNextParser.CASE, 0); }
public TerminalNode COLLATE() { return getToken(JPQLNextParser.COLLATE, 0); }
public TerminalNode CONTAINING() { return getToken(JPQLNextParser.CONTAINING, 0); }
public TerminalNode COUNT() { return getToken(JPQLNextParser.COUNT, 0); }
public TerminalNode CROSS() { return getToken(JPQLNextParser.CROSS, 0); }
public TerminalNode CURRENT() { return getToken(JPQLNextParser.CURRENT, 0); }
public TerminalNode DELETE() { return getToken(JPQLNextParser.DELETE, 0); }
public TerminalNode DESC() { return getToken(JPQLNextParser.DESC, 0); }
public TerminalNode DISTINCT() { return getToken(JPQLNextParser.DISTINCT, 0); }
public TerminalNode ELSE() { return getToken(JPQLNextParser.ELSE, 0); }
public TerminalNode EMPTY() { return getToken(JPQLNextParser.EMPTY, 0); }
public TerminalNode END() { return getToken(JPQLNextParser.END, 0); }
public TerminalNode ENTRY() { return getToken(JPQLNextParser.ENTRY, 0); }
public TerminalNode ESCAPE() { return getToken(JPQLNextParser.ESCAPE, 0); }
public TerminalNode EXCEPT() { return getToken(JPQLNextParser.EXCEPT, 0); }
public TerminalNode EXCLUDE() { return getToken(JPQLNextParser.EXCLUDE, 0); }
public TerminalNode EXISTS() { return getToken(JPQLNextParser.EXISTS, 0); }
public TerminalNode FETCH() { return getToken(JPQLNextParser.FETCH, 0); }
public TerminalNode FILTER() { return getToken(JPQLNextParser.FILTER, 0); }
public TerminalNode FIRST() { return getToken(JPQLNextParser.FIRST, 0); }
public TerminalNode FOLLOWING() { return getToken(JPQLNextParser.FOLLOWING, 0); }
public TerminalNode FROM() { return getToken(JPQLNextParser.FROM, 0); }
public TerminalNode FULL() { return getToken(JPQLNextParser.FULL, 0); }
public TerminalNode GROUP() { return getToken(JPQLNextParser.GROUP, 0); }
public TerminalNode GROUPS() { return getToken(JPQLNextParser.GROUPS, 0); }
public TerminalNode HAVING() { return getToken(JPQLNextParser.HAVING, 0); }
public TerminalNode IN() { return getToken(JPQLNextParser.IN, 0); }
public TerminalNode INDEX() { return getToken(JPQLNextParser.INDEX, 0); }
public TerminalNode INNER() { return getToken(JPQLNextParser.INNER, 0); }
public TerminalNode INSERT() { return getToken(JPQLNextParser.INSERT, 0); }
public TerminalNode INTERSECT() { return getToken(JPQLNextParser.INTERSECT, 0); }
public TerminalNode INTO() { return getToken(JPQLNextParser.INTO, 0); }
public TerminalNode IS() { return getToken(JPQLNextParser.IS, 0); }
public TerminalNode JOIN() { return getToken(JPQLNextParser.JOIN, 0); }
public TerminalNode JUMP() { return getToken(JPQLNextParser.JUMP, 0); }
public TerminalNode KEY() { return getToken(JPQLNextParser.KEY, 0); }
public TerminalNode LAST() { return getToken(JPQLNextParser.LAST, 0); }
public TerminalNode LEADING() { return getToken(JPQLNextParser.LEADING, 0); }
public TerminalNode LEFT() { return getToken(JPQLNextParser.LEFT, 0); }
public TerminalNode LIKE() { return getToken(JPQLNextParser.LIKE, 0); }
public TerminalNode LIMIT() { return getToken(JPQLNextParser.LIMIT, 0); }
public TerminalNode MEMBER() { return getToken(JPQLNextParser.MEMBER, 0); }
public TerminalNode NEW() { return getToken(JPQLNextParser.NEW, 0); }
public TerminalNode NO() { return getToken(JPQLNextParser.NO, 0); }
public TerminalNode NOT() { return getToken(JPQLNextParser.NOT, 0); }
public TerminalNode NULLS() { return getToken(JPQLNextParser.NULLS, 0); }
public TerminalNode OBJECT() { return getToken(JPQLNextParser.OBJECT, 0); }
public TerminalNode OF() { return getToken(JPQLNextParser.OF, 0); }
public TerminalNode OFFSET() { return getToken(JPQLNextParser.OFFSET, 0); }
public TerminalNode ON() { return getToken(JPQLNextParser.ON, 0); }
public TerminalNode OR() { return getToken(JPQLNextParser.OR, 0); }
public TerminalNode ORDER() { return getToken(JPQLNextParser.ORDER, 0); }
public TerminalNode OTHERS() { return getToken(JPQLNextParser.OTHERS, 0); }
public TerminalNode OUTER() { return getToken(JPQLNextParser.OUTER, 0); }
public TerminalNode OVER() { return getToken(JPQLNextParser.OVER, 0); }
public TerminalNode PAGE() { return getToken(JPQLNextParser.PAGE, 0); }
public TerminalNode PARTITION() { return getToken(JPQLNextParser.PARTITION, 0); }
public TerminalNode PRECEDING() { return getToken(JPQLNextParser.PRECEDING, 0); }
public TerminalNode RANGE() { return getToken(JPQLNextParser.RANGE, 0); }
public TerminalNode RECURSIVE() { return getToken(JPQLNextParser.RECURSIVE, 0); }
public TerminalNode RETURNING() { return getToken(JPQLNextParser.RETURNING, 0); }
public TerminalNode RIGHT() { return getToken(JPQLNextParser.RIGHT, 0); }
public TerminalNode ROW() { return getToken(JPQLNextParser.ROW, 0); }
public TerminalNode ROWS() { return getToken(JPQLNextParser.ROWS, 0); }
public TerminalNode SELECT() { return getToken(JPQLNextParser.SELECT, 0); }
public TerminalNode SET() { return getToken(JPQLNextParser.SET, 0); }
public TerminalNode SOME() { return getToken(JPQLNextParser.SOME, 0); }
public TerminalNode THEN() { return getToken(JPQLNextParser.THEN, 0); }
public TerminalNode TIES() { return getToken(JPQLNextParser.TIES, 0); }
public TerminalNode TO() { return getToken(JPQLNextParser.TO, 0); }
public TerminalNode TRAILING() { return getToken(JPQLNextParser.TRAILING, 0); }
public TerminalNode TREAT() { return getToken(JPQLNextParser.TREAT, 0); }
public TerminalNode TRIM() { return getToken(JPQLNextParser.TRIM, 0); }
public TerminalNode TYPE() { return getToken(JPQLNextParser.TYPE, 0); }
public TerminalNode UNBOUNDED() { return getToken(JPQLNextParser.UNBOUNDED, 0); }
public TerminalNode UNION() { return getToken(JPQLNextParser.UNION, 0); }
public TerminalNode UPDATE() { return getToken(JPQLNextParser.UPDATE, 0); }
public TerminalNode VALUE() { return getToken(JPQLNextParser.VALUE, 0); }
public TerminalNode VALUES() { return getToken(JPQLNextParser.VALUES, 0); }
public TerminalNode WHEN() { return getToken(JPQLNextParser.WHEN, 0); }
public TerminalNode WHERE() { return getToken(JPQLNextParser.WHERE, 0); }
public TerminalNode WINDOW() { return getToken(JPQLNextParser.WINDOW, 0); }
public TerminalNode WITH() { return getToken(JPQLNextParser.WITH, 0); }
public IdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final IdentifierContext identifier() throws RecognitionException {
IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
enterRule(_localctx, 174, RULE_identifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1316);
_la = _input.LA(1);
if ( !(((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (AFTER - 10)) | (1L << (ALL - 10)) | (1L << (AND - 10)) | (1L << (ANY - 10)) | (1L << (AS - 10)) | (1L << (ASC - 10)) | (1L << (BEFORE - 10)) | (1L << (BETWEEN - 10)) | (1L << (BOTH - 10)) | (1L << (BY - 10)) | (1L << (CASE - 10)) | (1L << (COLLATE - 10)) | (1L << (CONTAINING - 10)) | (1L << (COUNT - 10)) | (1L << (CROSS - 10)) | (1L << (CURRENT - 10)) | (1L << (DELETE - 10)) | (1L << (DESC - 10)) | (1L << (DISTINCT - 10)) | (1L << (ELSE - 10)) | (1L << (EMPTY - 10)) | (1L << (END - 10)) | (1L << (ENTRY - 10)) | (1L << (ESCAPE - 10)) | (1L << (EXCEPT - 10)) | (1L << (EXCLUDE - 10)) | (1L << (EXISTS - 10)) | (1L << (FETCH - 10)) | (1L << (FILTER - 10)) | (1L << (FIRST - 10)) | (1L << (FOLLOWING - 10)) | (1L << (FROM - 10)) | (1L << (FULL - 10)) | (1L << (GROUP - 10)) | (1L << (GROUPS - 10)) | (1L << (HAVING - 10)) | (1L << (IN - 10)) | (1L << (INDEX - 10)) | (1L << (INNER - 10)) | (1L << (INSERT - 10)) | (1L << (INTERSECT - 10)) | (1L << (INTO - 10)) | (1L << (IS - 10)) | (1L << (JOIN - 10)) | (1L << (JUMP - 10)) | (1L << (KEY - 10)) | (1L << (LAST - 10)) | (1L << (LEADING - 10)) | (1L << (LEFT - 10)) | (1L << (LIKE - 10)) | (1L << (LIMIT - 10)) | (1L << (MEMBER - 10)) | (1L << (NEW - 10)) | (1L << (NO - 10)) | (1L << (NOT - 10)) | (1L << (NULLS - 10)) | (1L << (OBJECT - 10)) | (1L << (OF - 10)))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (OFFSET - 74)) | (1L << (ON - 74)) | (1L << (OR - 74)) | (1L << (ORDER - 74)) | (1L << (OTHERS - 74)) | (1L << (OUTER - 74)) | (1L << (OVER - 74)) | (1L << (PAGE - 74)) | (1L << (PARTITION - 74)) | (1L << (PRECEDING - 74)) | (1L << (RANGE - 74)) | (1L << (RECURSIVE - 74)) | (1L << (RETURNING - 74)) | (1L << (RIGHT - 74)) | (1L << (ROW - 74)) | (1L << (ROWS - 74)) | (1L << (SELECT - 74)) | (1L << (SET - 74)) | (1L << (SOME - 74)) | (1L << (THEN - 74)) | (1L << (TIES - 74)) | (1L << (TO - 74)) | (1L << (TRAILING - 74)) | (1L << (TREAT - 74)) | (1L << (TRIM - 74)) | (1L << (TYPE - 74)) | (1L << (UNBOUNDED - 74)) | (1L << (UNION - 74)) | (1L << (UPDATE - 74)) | (1L << (VALUE - 74)) | (1L << (VALUES - 74)) | (1L << (WHEN - 74)) | (1L << (WHERE - 74)) | (1L << (WINDOW - 74)) | (1L << (WITH - 74)) | (1L << (IDENTIFIER - 74)))) != 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 IdentifierNonStartContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode TRUE() { return getToken(JPQLNextParser.TRUE, 0); }
public TerminalNode FALSE() { return getToken(JPQLNextParser.FALSE, 0); }
public IdentifierNonStartContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifierNonStart; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterIdentifierNonStart(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitIdentifierNonStart(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitIdentifierNonStart(this);
else return visitor.visitChildren(this);
}
}
public final IdentifierNonStartContext identifierNonStart() throws RecognitionException {
IdentifierNonStartContext _localctx = new IdentifierNonStartContext(_ctx, getState());
enterRule(_localctx, 176, RULE_identifierNonStart);
try {
setState(1321);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AFTER:
case ALL:
case AND:
case ANY:
case AS:
case ASC:
case BEFORE:
case BETWEEN:
case BOTH:
case BY:
case CASE:
case COLLATE:
case CONTAINING:
case COUNT:
case CROSS:
case CURRENT:
case DELETE:
case DESC:
case DISTINCT:
case ELSE:
case EMPTY:
case END:
case ENTRY:
case ESCAPE:
case EXCEPT:
case EXCLUDE:
case EXISTS:
case FETCH:
case FILTER:
case FIRST:
case FOLLOWING:
case FROM:
case FULL:
case GROUP:
case GROUPS:
case HAVING:
case IN:
case INDEX:
case INNER:
case INSERT:
case INTERSECT:
case INTO:
case IS:
case JOIN:
case JUMP:
case KEY:
case LAST:
case LEADING:
case LEFT:
case LIKE:
case LIMIT:
case MEMBER:
case NEW:
case NO:
case NOT:
case NULLS:
case OBJECT:
case OF:
case OFFSET:
case ON:
case OR:
case ORDER:
case OTHERS:
case OUTER:
case OVER:
case PAGE:
case PARTITION:
case PRECEDING:
case RANGE:
case RECURSIVE:
case RETURNING:
case RIGHT:
case ROW:
case ROWS:
case SELECT:
case SET:
case SOME:
case THEN:
case TIES:
case TO:
case TRAILING:
case TREAT:
case TRIM:
case TYPE:
case UNBOUNDED:
case UNION:
case UPDATE:
case VALUE:
case VALUES:
case WHEN:
case WHERE:
case WINDOW:
case WITH:
case IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(1318);
identifier();
}
break;
case TRUE:
enterOuterAlt(_localctx, 2);
{
setState(1319);
match(TRUE);
}
break;
case FALSE:
enterOuterAlt(_localctx, 3);
{
setState(1320);
match(FALSE);
}
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 boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
switch (ruleIndex) {
case 71:
return expression_sempred((ExpressionContext)_localctx, predIndex);
case 72:
return predicate_sempred((PredicateContext)_localctx, predIndex);
}
return true;
}
private boolean expression_sempred(ExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return precpred(_ctx, 3);
case 1:
return precpred(_ctx, 2);
case 2:
return precpred(_ctx, 1);
}
return true;
}
private boolean predicate_sempred(PredicateContext _localctx, int predIndex) {
switch (predIndex) {
case 3:
return precpred(_ctx, 21);
case 4:
return precpred(_ctx, 20);
}
return true;
}
public static final String _serializedATN =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u008c\u052e\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(\4)\t)\4*\t*\4+\t+\4"+
",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
"\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
"\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
"\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+
"\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\3\2\3\2\5\2\u00b7\n\2\3\2\5\2\u00ba"+
"\n\2\3\2\3\2\3\2\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\5\4\u00cb"+
"\n\4\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\6\5\6\u00d6\n\6\3\7\3\7\3\7\3\7"+
"\5\7\u00dc\n\7\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\7\t\u00e6\n\t\f\t\16\t"+
"\u00e9\13\t\3\t\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\5\n\u00f5\n\n\3\13"+
"\3\13\3\13\3\13\3\13\3\13\5\13\u00fd\n\13\3\13\3\13\5\13\u0101\n\13\3"+
"\f\3\f\3\f\3\f\3\f\3\f\5\f\u0109\n\f\3\f\3\f\5\f\u010d\n\f\3\r\3\r\3\r"+
"\5\r\u0112\n\r\3\r\5\r\u0115\n\r\3\r\5\r\u0118\n\r\3\r\5\r\u011b\n\r\3"+
"\r\3\r\5\r\u011f\n\r\3\r\5\r\u0122\n\r\3\r\5\r\u0125\n\r\3\16\3\16\3\16"+
"\5\16\u012a\n\16\3\16\5\16\u012d\n\16\3\17\3\17\5\17\u0131\n\17\3\17\3"+
"\17\3\17\3\17\3\17\5\17\u0138\n\17\3\17\5\17\u013b\n\17\3\17\5\17\u013e"+
"\n\17\3\17\5\17\u0141\n\17\3\20\3\20\5\20\u0145\n\20\3\20\3\20\3\20\3"+
"\20\3\20\5\20\u014c\n\20\3\20\5\20\u014f\n\20\3\20\3\20\3\20\3\20\3\20"+
"\3\20\3\20\3\20\3\20\7\20\u015a\n\20\f\20\16\20\u015d\13\20\3\20\5\20"+
"\u0160\n\20\3\20\5\20\u0163\n\20\3\21\3\21\3\21\3\21\3\21\3\21\3\21\5"+
"\21\u016c\n\21\3\21\3\21\3\21\5\21\u0171\n\21\3\22\3\22\3\22\3\22\3\22"+
"\3\22\3\22\3\22\3\22\3\22\3\22\5\22\u017e\n\22\3\23\3\23\3\23\3\23\7\23"+
"\u0184\n\23\f\23\16\23\u0187\13\23\3\23\3\23\3\24\3\24\3\24\3\24\7\24"+
"\u018f\n\24\f\24\16\24\u0192\13\24\3\25\5\25\u0195\n\25\3\25\3\25\5\25"+
"\u0199\n\25\3\25\5\25\u019c\n\25\3\25\5\25\u019f\n\25\3\25\5\25\u01a2"+
"\n\25\3\25\5\25\u01a5\n\25\3\25\3\25\5\25\u01a9\n\25\3\25\5\25\u01ac\n"+
"\25\3\25\5\25\u01af\n\25\3\25\5\25\u01b2\n\25\3\25\5\25\u01b5\n\25\3\26"+
"\3\26\3\26\3\26\7\26\u01bb\n\26\f\26\16\26\u01be\13\26\3\27\3\27\3\27"+
"\3\27\7\27\u01c4\n\27\f\27\16\27\u01c7\13\27\3\30\3\30\3\30\3\30\7\30"+
"\u01cd\n\30\f\30\16\30\u01d0\13\30\3\31\3\31\3\31\3\31\7\31\u01d6\n\31"+
"\f\31\16\31\u01d9\13\31\3\32\3\32\5\32\u01dd\n\32\3\32\3\32\3\32\3\32"+
"\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\7\32\u01ec\n\32\f\32\16"+
"\32\u01ef\13\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\5\32\u01fa"+
"\n\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\7\32\u0205\n\32\f\32"+
"\16\32\u0208\13\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\5\32\u0212"+
"\n\32\5\32\u0214\n\32\3\33\3\33\3\33\3\33\7\33\u021a\n\33\f\33\16\33\u021d"+
"\13\33\3\33\3\33\3\34\3\34\3\35\3\35\3\35\5\35\u0226\n\35\3\36\3\36\3"+
"\36\3\36\3\37\3\37\3\37\3\37\3\37\3\37\5\37\u0232\n\37\3 \3 \3 \5 \u0237"+
"\n \3 \3 \5 \u023b\n \3!\3!\3!\3!\5!\u0241\n!\3\"\3\"\5\"\u0245\n\"\3"+
"#\3#\3#\3#\3#\3#\3#\3#\5#\u024f\n#\3#\5#\u0252\n#\3$\5$\u0255\n$\3$\5"+
"$\u0258\n$\3$\5$\u025b\n$\5$\u025d\n$\3%\3%\3%\3&\3&\5&\u0264\n&\3&\3"+
"&\3&\7&\u0269\n&\f&\16&\u026c\13&\3\'\3\'\5\'\u0270\n\'\3\'\3\'\3\'\7"+
"\'\u0275\n\'\f\'\16\'\u0278\13\'\3(\3(\5(\u027c\n(\3)\3)\3*\3*\3*\3*\5"+
"*\u0284\n*\3+\3+\3+\5+\u0289\n+\3,\3,\3,\3,\3,\3-\3-\3-\3-\3-\3-\7-\u0296"+
"\n-\f-\16-\u0299\13-\3-\3-\3.\3.\3/\3/\3/\3/\3/\3\60\3\60\3\60\5\60\u02a7"+
"\n\60\3\60\5\60\u02aa\n\60\3\61\3\61\3\61\3\61\3\61\7\61\u02b1\n\61\f"+
"\61\16\61\u02b4\13\61\5\61\u02b6\n\61\3\61\3\61\3\62\3\62\3\62\3\62\5"+
"\62\u02be\n\62\3\62\3\62\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63"+
"\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63\5\63\u02d3\n\63\3\64\3\64\3\64"+
"\7\64\u02d8\n\64\f\64\16\64\u02db\13\64\3\65\3\65\3\65\3\65\3\65\3\65"+
"\5\65\u02e3\n\65\5\65\u02e5\n\65\3\66\3\66\3\66\3\66\3\66\7\66\u02ec\n"+
"\66\f\66\16\66\u02ef\13\66\3\67\3\67\38\38\38\39\39\39\39\39\79\u02fb"+
"\n9\f9\169\u02fe\139\3:\3:\3:\5:\u0303\n:\3:\3:\3:\5:\u0308\n:\5:\u030a"+
"\n:\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\7;\u0319\n;\f;\16;\u031c\13"+
";\3<\5<\u031f\n<\3<\5<\u0322\n<\3<\5<\u0325\n<\3<\5<\u0328\n<\3=\3=\3"+
"=\3=\3=\7=\u032f\n=\f=\16=\u0332\13=\3>\3>\3>\5>\u0337\n>\3>\3>\3>\3>"+
"\3>\3>\5>\u033f\n>\5>\u0341\n>\3?\3?\3?\3?\3?\3?\3?\3?\3?\3?\5?\u034d"+
"\n?\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\5@\u035b\n@\3A\3A\3A\3A\3A\3A"+
"\3A\3A\3A\3A\5A\u0367\nA\3B\3B\3B\3C\3C\3C\3C\3C\3C\3C\5C\u0373\nC\3D"+
"\3D\5D\u0377\nD\3E\3E\3E\3E\3E\3E\3E\7E\u0380\nE\fE\16E\u0383\13E\3E\3"+
"E\5E\u0387\nE\3F\3F\5F\u038b\nF\3G\3G\3G\7G\u0390\nG\fG\16G\u0393\13G"+
"\3H\3H\3H\3I\3I\3I\3I\3I\3I\3I\3I\6I\u03a0\nI\rI\16I\u03a1\3I\3I\5I\u03a6"+
"\nI\3I\3I\3I\3I\6I\u03ac\nI\rI\16I\u03ad\3I\3I\5I\u03b2\nI\3I\3I\3I\3"+
"I\3I\3I\3I\3I\3I\3I\3I\3I\5I\u03c0\nI\3I\3I\3I\3I\3I\3I\3I\3I\3I\7I\u03cb"+
"\nI\fI\16I\u03ce\13I\3J\3J\3J\3J\3J\3J\3J\3J\5J\u03d8\nJ\3J\3J\3J\3J\3"+
"J\3J\5J\u03e0\nJ\3J\3J\3J\5J\u03e5\nJ\3J\3J\3J\3J\3J\5J\u03ec\nJ\3J\3"+
"J\3J\3J\3J\5J\u03f3\nJ\3J\3J\3J\3J\3J\5J\u03fa\nJ\3J\3J\3J\5J\u03ff\n"+
"J\3J\3J\3J\3J\3J\5J\u0406\nJ\3J\3J\3J\5J\u040b\nJ\3J\3J\3J\3J\3J\5J\u0412"+
"\nJ\3J\3J\3J\5J\u0417\nJ\3J\3J\3J\3J\3J\5J\u041e\nJ\3J\3J\3J\5J\u0423"+
"\nJ\3J\3J\3J\3J\3J\5J\u042a\nJ\3J\3J\3J\5J\u042f\nJ\3J\3J\3J\3J\3J\5J"+
"\u0436\nJ\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J\3J"+
"\3J\3J\3J\3J\3J\3J\5J\u0452\nJ\3J\3J\3J\3J\3J\5J\u0459\nJ\3J\3J\3J\3J"+
"\3J\3J\3J\5J\u0462\nJ\3J\3J\3J\3J\5J\u0468\nJ\3J\3J\5J\u046c\nJ\3J\3J"+
"\3J\3J\5J\u0472\nJ\3J\3J\3J\3J\3J\3J\7J\u047a\nJ\fJ\16J\u047d\13J\3K\3"+
"K\5K\u0481\nK\3L\3L\3L\3L\7L\u0487\nL\fL\16L\u048a\13L\3L\3L\3L\5L\u048f"+
"\nL\3M\3M\3M\3M\5M\u0495\nM\3M\3M\3N\3N\3N\3N\3N\3O\3O\3O\3O\3O\3P\3P"+
"\3P\3P\3P\3P\3P\3P\3P\3P\3P\3P\3P\3P\5P\u04b1\nP\3Q\3Q\3Q\3Q\3R\3R\3R"+
"\3R\3S\3S\3S\3S\3T\3T\3U\3U\3U\3U\5U\u04c5\nU\3V\3V\3V\5V\u04ca\nV\3V"+
"\5V\u04cd\nV\3V\5V\u04d0\nV\3V\3V\3V\3V\3V\3V\5V\u04d8\nV\3V\3V\3V\5V"+
"\u04dd\nV\3V\3V\5V\u04e1\nV\3V\3V\3V\3V\3V\3V\5V\u04e9\nV\3V\3V\3V\3V"+
"\3V\3V\5V\u04f1\nV\5V\u04f3\nV\3V\3V\3V\5V\u04f8\nV\3V\3V\3V\7V\u04fd"+
"\nV\fV\16V\u0500\13V\5V\u0502\nV\3V\3V\3V\3V\3V\3V\3V\5V\u050b\nV\3V\3"+
"V\3V\3V\3V\5V\u0512\nV\3V\3V\3V\3V\3V\3V\5V\u051a\nV\5V\u051c\nV\5V\u051e"+
"\nV\3W\3W\3X\3X\3X\5X\u0525\nX\3Y\3Y\3Z\3Z\3Z\5Z\u052c\nZ\3Z\2\4\u0090"+
"\u0092[\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:"+
"<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a"+
"\u008c\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2"+
"\u00a4\u00a6\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\2\22\5\2((99ii\4\2\r"+
"\r\"\"\4\2EEMM\5\2\61\61AAZZ\4\2\21\21!!\4\2..??\5\2\63\63WW\\\\\4\2\f"+
"\f\22\22\4\2}}\u008a\u008a\3\2\34\37\3\2\u0084\u0086\3\2\u0082\u0083\5"+
"\2\r\r\17\17__\3\2\n\13\5\2\24\24@@cc\t\2\f\33 *,GILNegp\u008b\u008b\2"+
"\u05bd\2\u00b9\3\2\2\2\4\u00be\3\2\2\2\6\u00ca\3\2\2\2\b\u00cc\3\2\2\2"+
"\n\u00d5\3\2\2\2\f\u00db\3\2\2\2\16\u00dd\3\2\2\2\20\u00e0\3\2\2\2\22"+
"\u00f4\3\2\2\2\24\u0100\3\2\2\2\26\u010c\3\2\2\2\30\u010e\3\2\2\2\32\u0126"+
"\3\2\2\2\34\u012e\3\2\2\2\36\u0142\3\2\2\2 \u0164\3\2\2\2\"\u017d\3\2"+
"\2\2$\u017f\3\2\2\2&\u018a\3\2\2\2(\u0194\3\2\2\2*\u01b6\3\2\2\2,\u01bf"+
"\3\2\2\2.\u01c8\3\2\2\2\60\u01d1\3\2\2\2\62\u0213\3\2\2\2\64\u0215\3\2"+
"\2\2\66\u0220\3\2\2\28\u0225\3\2\2\2:\u0227\3\2\2\2<\u022b\3\2\2\2>\u0233"+
"\3\2\2\2@\u023c\3\2\2\2B\u0244\3\2\2\2D\u0246\3\2\2\2F\u025c\3\2\2\2H"+
"\u025e\3\2\2\2J\u0261\3\2\2\2L\u026d\3\2\2\2N\u0279\3\2\2\2P\u027d\3\2"+
"\2\2R\u0283\3\2\2\2T\u0288\3\2\2\2V\u028a\3\2\2\2X\u028f\3\2\2\2Z\u029c"+
"\3\2\2\2\\\u029e\3\2\2\2^\u02a9\3\2\2\2`\u02ab\3\2\2\2b\u02b9\3\2\2\2"+
"d\u02d2\3\2\2\2f\u02d4\3\2\2\2h\u02dc\3\2\2\2j\u02e6\3\2\2\2l\u02f0\3"+
"\2\2\2n\u02f2\3\2\2\2p\u02f5\3\2\2\2r\u02ff\3\2\2\2t\u030b\3\2\2\2v\u031e"+
"\3\2\2\2x\u0329\3\2\2\2z\u0340\3\2\2\2|\u034c\3\2\2\2~\u035a\3\2\2\2\u0080"+
"\u0366\3\2\2\2\u0082\u0368\3\2\2\2\u0084\u0372\3\2\2\2\u0086\u0376\3\2"+
"\2\2\u0088\u0386\3\2\2\2\u008a\u038a\3\2\2\2\u008c\u038c\3\2\2\2\u008e"+
"\u0394\3\2\2\2\u0090\u03bf\3\2\2\2\u0092\u0471\3\2\2\2\u0094\u0480\3\2"+
"\2\2\u0096\u048e\3\2\2\2\u0098\u0490\3\2\2\2\u009a\u0498\3\2\2\2\u009c"+
"\u049d\3\2\2\2\u009e\u04b0\3\2\2\2\u00a0\u04b2\3\2\2\2\u00a2\u04b6\3\2"+
"\2\2\u00a4\u04ba\3\2\2\2\u00a6\u04be\3\2\2\2\u00a8\u04c4\3\2\2\2\u00aa"+
"\u051d\3\2\2\2\u00ac\u051f\3\2\2\2\u00ae\u0524\3\2\2\2\u00b0\u0526\3\2"+
"\2\2\u00b2\u052b\3\2\2\2\u00b4\u00b6\7p\2\2\u00b5\u00b7\7X\2\2\u00b6\u00b5"+
"\3\2\2\2\u00b6\u00b7\3\2\2\2\u00b7\u00b8\3\2\2\2\u00b8\u00ba\5\20\t\2"+
"\u00b9\u00b4\3\2\2\2\u00b9\u00ba\3\2\2\2\u00ba\u00bb\3\2\2\2\u00bb\u00bc"+
"\5\22\n\2\u00bc\u00bd\7\2\2\3\u00bd\3\3\2\2\2\u00be\u00bf\5R*\2\u00bf"+
"\u00c0\7\2\2\3\u00c0\5\3\2\2\2\u00c1\u00c2\5^\60\2\u00c2\u00c3\7\2\2\3"+
"\u00c3\u00cb\3\2\2\2\u00c4\u00c5\5b\62\2\u00c5\u00c6\7\2\2\3\u00c6\u00cb"+
"\3\2\2\2\u00c7\u00c8\5`\61\2\u00c8\u00c9\7\2\2\3\u00c9\u00cb\3\2\2\2\u00ca"+
"\u00c1\3\2\2\2\u00ca\u00c4\3\2\2\2\u00ca\u00c7\3\2\2\2\u00cb\7\3\2\2\2"+
"\u00cc\u00cd\5\u0090I\2\u00cd\u00ce\7\2\2\3\u00ce\t\3\2\2\2\u00cf\u00d0"+
"\5\u008aF\2\u00d0\u00d1\7\2\2\3\u00d1\u00d6\3\2\2\2\u00d2\u00d3\5\u008c"+
"G\2\u00d3\u00d4\7\2\2\3\u00d4\u00d6\3\2\2\2\u00d5\u00cf\3\2\2\2\u00d5"+
"\u00d2\3\2\2\2\u00d6\13\3\2\2\2\u00d7\u00d8\5\u008aF\2\u00d8\u00d9\7\2"+
"\2\3\u00d9\u00dc\3\2\2\2\u00da\u00dc\5\6\4\2\u00db\u00d7\3\2\2\2\u00db"+
"\u00da\3\2\2\2\u00dc\r\3\2\2\2\u00dd\u00de\5\u0092J\2\u00de\u00df\7\2"+
"\2\3\u00df\17\3\2\2\2\u00e0\u00e1\5\66\34\2\u00e1\u00e2\7~\2\2\u00e2\u00e7"+
"\5\u00b0Y\2\u00e3\u00e4\7|\2\2\u00e4\u00e6\5\u00b0Y\2\u00e5\u00e3\3\2"+
"\2\2\u00e6\u00e9\3\2\2\2\u00e7\u00e5\3\2\2\2\u00e7\u00e8\3\2\2\2\u00e8"+
"\u00ea\3\2\2\2\u00e9\u00e7\3\2\2\2\u00ea\u00eb\7\177\2\2\u00eb\u00ec\7"+
"\20\2\2\u00ec\u00ed\7~\2\2\u00ed\u00ee\5\22\n\2\u00ee\u00ef\7\177\2\2"+
"\u00ef\21\3\2\2\2\u00f0\u00f5\5\24\13\2\u00f1\u00f5\5\36\20\2\u00f2\u00f5"+
"\5\34\17\2\u00f3\u00f5\5 \21\2\u00f4\u00f0\3\2\2\2\u00f4\u00f1\3\2\2\2"+
"\u00f4\u00f2\3\2\2\2\u00f4\u00f3\3\2\2\2\u00f5\23\3\2\2\2\u00f6\u0101"+
"\5(\25\2\u00f7\u00f8\7~\2\2\u00f8\u00f9\5\24\13\2\u00f9\u00fa\7\177\2"+
"\2\u00fa\u00fc\t\2\2\2\u00fb\u00fd\t\3\2\2\u00fc\u00fb\3\2\2\2\u00fc\u00fd"+
"\3\2\2\2\u00fd\u00fe\3\2\2\2\u00fe\u00ff\5\24\13\2\u00ff\u0101\3\2\2\2"+
"\u0100\u00f6\3\2\2\2\u0100\u00f7\3\2\2\2\u0101\25\3\2\2\2\u0102\u010d"+
"\5\30\r\2\u0103\u0104\7~\2\2\u0104\u0105\5\26\f\2\u0105\u0106\7\177\2"+
"\2\u0106\u0108\t\2\2\2\u0107\u0109\t\3\2\2\u0108\u0107\3\2\2\2\u0108\u0109"+
"\3\2\2\2\u0109\u010a\3\2\2\2\u010a\u010b\5\26\f\2\u010b\u010d\3\2\2\2"+
"\u010c\u0102\3\2\2\2\u010c\u0103\3\2\2\2\u010d\27\3\2\2\2\u010e\u010f"+
"\5L\'\2\u010f\u0111\5,\27\2\u0110\u0112\5\u0088E\2\u0111\u0110\3\2\2\2"+
"\u0111\u0112\3\2\2\2\u0112\u0114\3\2\2\2\u0113\u0115\5\u008eH\2\u0114"+
"\u0113\3\2\2\2\u0114\u0115\3\2\2\2\u0115\u0117\3\2\2\2\u0116\u0118\5j"+
"\66\2\u0117\u0116\3\2\2\2\u0117\u0118\3\2\2\2\u0118\u011a\3\2\2\2\u0119"+
"\u011b\5n8\2\u011a\u0119\3\2\2\2\u011a\u011b\3\2\2\2\u011b\u0121\3\2\2"+
"\2\u011c\u011e\t\2\2\2\u011d\u011f\t\3\2\2\u011e\u011d\3\2\2\2\u011e\u011f"+
"\3\2\2\2\u011f\u0120\3\2\2\2\u0120\u0122\5\26\f\2\u0121\u011c\3\2\2\2"+
"\u0121\u0122\3\2\2\2\u0122\u0124\3\2\2\2\u0123\u0125\5\32\16\2\u0124\u0123"+
"\3\2\2\2\u0124\u0125\3\2\2\2\u0125\31\3\2\2\2\u0126\u012c\5p9\2\u0127"+
"\u0129\5\u0082B\2\u0128\u012a\5\u0084C\2\u0129\u0128\3\2\2\2\u0129\u012a"+
"\3\2\2\2\u012a\u012d\3\2\2\2\u012b\u012d\5\u0084C\2\u012c\u0127\3\2\2"+
"\2\u012c\u012b\3\2\2\2\u012d\33\3\2\2\2\u012e\u0130\7 \2\2\u012f\u0131"+
"\7\60\2\2\u0130\u012f\3\2\2\2\u0130\u0131\3\2\2\2\u0131\u0132\3\2\2\2"+
"\u0132\u0137\5\66\34\2\u0133\u0134\7~\2\2\u0134\u0135\5f\64\2\u0135\u0136"+
"\7\177\2\2\u0136\u0138\3\2\2\2\u0137\u0133\3\2\2\2\u0137\u0138\3\2\2\2"+
"\u0138\u013a\3\2\2\2\u0139\u013b\58\35\2\u013a\u0139\3\2\2\2\u013a\u013b"+
"\3\2\2\2\u013b\u013d\3\2\2\2\u013c\u013e\5\u008eH\2\u013d\u013c\3\2\2"+
"\2\u013d\u013e\3\2\2\2\u013e\u0140\3\2\2\2\u013f\u0141\5&\24\2\u0140\u013f"+
"\3\2\2\2\u0140\u0141\3\2\2\2\u0141\35\3\2\2\2\u0142\u0144\7j\2\2\u0143"+
"\u0145\7\60\2\2\u0144\u0143\3\2\2\2\u0144\u0145\3\2\2\2\u0145\u0146\3"+
"\2\2\2\u0146\u014b\5\66\34\2\u0147\u0148\7~\2\2\u0148\u0149\5f\64\2\u0149"+
"\u014a\7\177\2\2\u014a\u014c\3\2\2\2\u014b\u0147\3\2\2\2\u014b\u014c\3"+
"\2\2\2\u014c\u014e\3\2\2\2\u014d\u014f\58\35\2\u014e\u014d\3\2\2\2\u014e"+
"\u014f\3\2\2\2\u014f\u0150\3\2\2\2\u0150\u0151\7^\2\2\u0151\u0152\5\""+
"\22\2\u0152\u0153\7v\2\2\u0153\u015b\5\u0090I\2\u0154\u0155\7|\2\2\u0155"+
"\u0156\5\"\22\2\u0156\u0157\7v\2\2\u0157\u0158\5\u0090I\2\u0158\u015a"+
"\3\2\2\2\u0159\u0154\3\2\2\2\u015a\u015d\3\2\2\2\u015b\u0159\3\2\2\2\u015b"+
"\u015c\3\2\2\2\u015c\u015f\3\2\2\2\u015d\u015b\3\2\2\2\u015e\u0160\5\u008e"+
"H\2\u015f\u015e\3\2\2\2\u015f\u0160\3\2\2\2\u0160\u0162\3\2\2\2\u0161"+
"\u0163\5&\24\2\u0162\u0161\3\2\2\2\u0162\u0163\3\2\2\2\u0163\37\3\2\2"+
"\2\u0164\u0165\78\2\2\u0165\u0166\7:\2\2\u0166\u016b\5\66\34\2\u0167\u0168"+
"\7~\2\2\u0168\u0169\5f\64\2\u0169\u016a\7\177\2\2\u016a\u016c\3\2\2\2"+
"\u016b\u0167\3\2\2\2\u016b\u016c\3\2\2\2\u016c\u016d\3\2\2\2\u016d\u016e"+
"\5$\23\2\u016e\u0170\5(\25\2\u016f\u0171\5&\24\2\u0170\u016f\3\2\2\2\u0170"+
"\u0171\3\2\2\2\u0171!\3\2\2\2\u0172\u017e\5f\64\2\u0173\u0174\7>\2\2\u0174"+
"\u0175\7~\2\2\u0175\u0176\5^\60\2\u0176\u0177\7\177\2\2\u0177\u017e\3"+
"\2\2\2\u0178\u0179\7\66\2\2\u0179\u017a\7~\2\2\u017a\u017b\5^\60\2\u017b"+
"\u017c\7\177\2\2\u017c\u017e\3\2\2\2\u017d\u0172\3\2\2\2\u017d\u0173\3"+
"\2\2\2\u017d\u0178\3\2\2\2\u017e#\3\2\2\2\u017f\u0180\7~\2\2\u0180\u0185"+
"\5\"\22\2\u0181\u0182\7|\2\2\u0182\u0184\5\"\22\2\u0183\u0181\3\2\2\2"+
"\u0184\u0187\3\2\2\2\u0185\u0183\3\2\2\2\u0185\u0186\3\2\2\2\u0186\u0188"+
"\3\2\2\2\u0187\u0185\3\2\2\2\u0188\u0189\7\177\2\2\u0189%\3\2\2\2\u018a"+
"\u018b\7Y\2\2\u018b\u0190\5f\64\2\u018c\u018d\7|\2\2\u018d\u018f\5f\64"+
"\2\u018e\u018c\3\2\2\2\u018f\u0192\3\2\2\2\u0190\u018e\3\2\2\2\u0190\u0191"+
"\3\2\2\2\u0191\'\3\2\2\2\u0192\u0190\3\2\2\2\u0193\u0195\5J&\2\u0194\u0193"+
"\3\2\2\2\u0194\u0195\3\2\2\2\u0195\u0196\3\2\2\2\u0196\u0198\5*\26\2\u0197"+
"\u0199\5\u0088E\2\u0198\u0197\3\2\2\2\u0198\u0199\3\2\2\2\u0199\u019b"+
"\3\2\2\2\u019a\u019c\5\u008eH\2\u019b\u019a\3\2\2\2\u019b\u019c\3\2\2"+
"\2\u019c\u019e\3\2\2\2\u019d\u019f\5j\66\2\u019e\u019d\3\2\2\2\u019e\u019f"+
"\3\2\2\2\u019f\u01a1\3\2\2\2\u01a0\u01a2\5n8\2\u01a1\u01a0\3\2\2\2\u01a1"+
"\u01a2\3\2\2\2\u01a2\u01a4\3\2\2\2\u01a3\u01a5\5t;\2\u01a4\u01a3\3\2\2"+
"\2\u01a4\u01a5\3\2\2\2\u01a5\u01ab\3\2\2\2\u01a6\u01a8\t\2\2\2\u01a7\u01a9"+
"\t\3\2\2\u01a8\u01a7\3\2\2\2\u01a8\u01a9\3\2\2\2\u01a9\u01aa\3\2\2\2\u01aa"+
"\u01ac\5(\25\2\u01ab\u01a6\3\2\2\2\u01ab\u01ac\3\2\2\2\u01ac\u01ae\3\2"+
"\2\2\u01ad\u01af\5p9\2\u01ae\u01ad\3\2\2\2\u01ae\u01af\3\2\2\2\u01af\u01b1"+
"\3\2\2\2\u01b0\u01b2\5\u0082B\2\u01b1\u01b0\3\2\2\2\u01b1\u01b2\3\2\2"+
"\2\u01b2\u01b4\3\2\2\2\u01b3\u01b5\5\u0084C\2\u01b4\u01b3\3\2\2\2\u01b4"+
"\u01b5\3\2\2\2\u01b5)\3\2\2\2\u01b6\u01b7\7\60\2\2\u01b7\u01bc\5.\30\2"+
"\u01b8\u01b9\7|\2\2\u01b9\u01bb\5.\30\2\u01ba\u01b8\3\2\2\2\u01bb\u01be"+
"\3\2\2\2\u01bc\u01ba\3\2\2\2\u01bc\u01bd\3\2\2\2\u01bd+\3\2\2\2\u01be"+
"\u01bc\3\2\2\2\u01bf\u01c0\7\60\2\2\u01c0\u01c5\5\60\31\2\u01c1\u01c2"+
"\7|\2\2\u01c2\u01c4\5\60\31\2\u01c3\u01c1\3\2\2\2\u01c4\u01c7\3\2\2\2"+
"\u01c5\u01c3\3\2\2\2\u01c5\u01c6\3\2\2\2\u01c6-\3\2\2\2\u01c7\u01c5\3"+
"\2\2\2\u01c8\u01ce\5\62\32\2\u01c9\u01cd\5:\36\2\u01ca\u01cd\5<\37\2\u01cb"+
"\u01cd\5> \2\u01cc\u01c9\3\2\2\2\u01cc\u01ca\3\2\2\2\u01cc\u01cb\3\2\2"+
"\2\u01cd\u01d0\3\2\2\2\u01ce\u01cc\3\2\2\2\u01ce\u01cf\3\2\2\2\u01cf/"+
"\3\2\2\2\u01d0\u01ce\3\2\2\2\u01d1\u01d7\5\62\32\2\u01d2\u01d6\5:\36\2"+
"\u01d3\u01d6\5<\37\2\u01d4\u01d6\5@!\2\u01d5\u01d2\3\2\2\2\u01d5\u01d3"+
"\3\2\2\2\u01d5\u01d4\3\2\2\2\u01d6\u01d9\3\2\2\2\u01d7\u01d5\3\2\2\2\u01d7"+
"\u01d8\3\2\2\2\u01d8\61\3\2\2\2\u01d9\u01d7\3\2\2\2\u01da\u01dc\5\66\34"+
"\2\u01db\u01dd\58\35\2\u01dc\u01db\3\2\2\2\u01dc\u01dd\3\2\2\2\u01dd\u0214"+
"\3\2\2\2\u01de\u01df\5\66\34\2\u01df\u01e0\7~\2\2\u01e0\u01e1\7\4\2\2"+
"\u01e1\u01e2\7l\2\2\u01e2\u01e3\7\177\2\2\u01e3\u01e4\58\35\2\u01e4\u0214"+
"\3\2\2\2\u01e5\u01e6\5\66\34\2\u01e6\u01e7\7~\2\2\u01e7\u01e8\7l\2\2\u01e8"+
"\u01ed\5\64\33\2\u01e9\u01ea\7|\2\2\u01ea\u01ec\5\64\33\2\u01eb\u01e9"+
"\3\2\2\2\u01ec\u01ef\3\2\2\2\u01ed\u01eb\3\2\2\2\u01ed\u01ee\3\2\2\2\u01ee"+
"\u01f0\3\2\2\2\u01ef\u01ed\3\2\2\2\u01f0\u01f1\7\177\2\2\u01f1\u01f2\5"+
"8\35\2\u01f2\u0214\3\2\2\2\u01f3\u01f4\5\u00b0Y\2\u01f4\u01f5\7~\2\2\u01f5"+
"\u01f6\7\4\2\2\u01f6\u01f9\7l\2\2\u01f7\u01f8\7B\2\2\u01f8\u01fa\5\66"+
"\34\2\u01f9\u01f7\3\2\2\2\u01f9\u01fa\3\2\2\2\u01fa\u01fb\3\2\2\2\u01fb"+
"\u01fc\7\177\2\2\u01fc\u01fd\58\35\2\u01fd\u0214\3\2\2\2\u01fe\u01ff\5"+
"\u00b0Y\2\u01ff\u0200\7~\2\2\u0200\u0201\7l\2\2\u0201\u0206\5\64\33\2"+
"\u0202\u0203\7|\2\2\u0203\u0205\5\64\33\2\u0204\u0202\3\2\2\2\u0205\u0208"+
"\3\2\2\2\u0206\u0204\3\2\2\2\u0206\u0207\3\2\2\2\u0207\u0209\3\2\2\2\u0208"+
"\u0206\3\2\2\2\u0209\u020a\7\177\2\2\u020a\u020b\58\35\2\u020b\u0214\3"+
"\2\2\2\u020c\u020d\t\4\2\2\u020d\u020e\7~\2\2\u020e\u020f\5\66\34\2\u020f"+
"\u0211\7\177\2\2\u0210\u0212\58\35\2\u0211\u0210\3\2\2\2\u0211\u0212\3"+
"\2\2\2\u0212\u0214\3\2\2\2\u0213\u01da\3\2\2\2\u0213\u01de\3\2\2\2\u0213"+
"\u01e5\3\2\2\2\u0213\u01f3\3\2\2\2\u0213\u01fe\3\2\2\2\u0213\u020c\3\2"+
"\2\2\u0214\63\3\2\2\2\u0215\u0216\7~\2\2\u0216\u021b\5\u009eP\2\u0217"+
"\u0218\7|\2\2\u0218\u021a\5\u009eP\2\u0219\u0217\3\2\2\2\u021a\u021d\3"+
"\2\2\2\u021b\u0219\3\2\2\2\u021b\u021c\3\2\2\2\u021c\u021e\3\2\2\2\u021d"+
"\u021b\3\2\2\2\u021e\u021f\7\177\2\2\u021f\65\3\2\2\2\u0220\u0221\5f\64"+
"\2\u0221\67\3\2\2\2\u0222\u0223\7\20\2\2\u0223\u0226\5\u00b0Y\2\u0224"+
"\u0226\7\u008b\2\2\u0225\u0222\3\2\2\2\u0225\u0224\3\2\2\2\u02269\3\2"+
"\2\2\u0227\u0228\7\32\2\2\u0228\u0229\7<\2\2\u0229\u022a\5\62\32\2\u022a"+
";\3\2\2\2\u022b\u022c\7|\2\2\u022c\u022d\7\65\2\2\u022d\u022e\7~\2\2\u022e"+
"\u022f\5^\60\2\u022f\u0231\7\177\2\2\u0230\u0232\58\35\2\u0231\u0230\3"+
"\2\2\2\u0231\u0232\3\2\2\2\u0232=\3\2\2\2\u0233\u0234\5F$\2\u0234\u0236"+
"\7<\2\2\u0235\u0237\7,\2\2\u0236\u0235\3\2\2\2\u0236\u0237\3\2\2\2\u0237"+
"\u0238\3\2\2\2\u0238\u023a\5B\"\2\u0239\u023b\5H%\2\u023a\u0239\3\2\2"+
"\2\u023a\u023b\3\2\2\2\u023b?\3\2\2\2\u023c\u023d\5F$\2\u023d\u023e\7"+
"<\2\2\u023e\u0240\5B\"\2\u023f\u0241\5H%\2\u0240\u023f\3\2\2\2\u0240\u0241"+
"\3\2\2\2\u0241A\3\2\2\2\u0242\u0245\5\62\32\2\u0243\u0245\5D#\2\u0244"+
"\u0242\3\2\2\2\u0244\u0243\3\2\2\2\u0245C\3\2\2\2\u0246\u0247\7d\2\2\u0247"+
"\u0248\7~\2\2\u0248\u0249\5^\60\2\u0249\u024a\7\20\2\2\u024a\u024b\5\66"+
"\34\2\u024b\u024e\7\177\2\2\u024c\u024d\7}\2\2\u024d\u024f\5h\65\2\u024e"+
"\u024c\3\2\2\2\u024e\u024f\3\2\2\2\u024f\u0251\3\2\2\2\u0250\u0252\58"+
"\35\2\u0251\u0250\3\2\2\2\u0251\u0252\3\2\2\2\u0252E\3\2\2\2\u0253\u0255"+
"\7\67\2\2\u0254\u0253\3\2\2\2\u0254\u0255\3\2\2\2\u0255\u025d\3\2\2\2"+
"\u0256\u0258\t\5\2\2\u0257\u0256\3\2\2\2\u0257\u0258\3\2\2\2\u0258\u025a"+
"\3\2\2\2\u0259\u025b\7R\2\2\u025a\u0259\3\2\2\2\u025a\u025b\3\2\2\2\u025b"+
"\u025d\3\2\2\2\u025c\u0254\3\2\2\2\u025c\u0257\3\2\2\2\u025dG\3\2\2\2"+
"\u025e\u025f\7N\2\2\u025f\u0260\5\u0092J\2\u0260I\3\2\2\2\u0261\u0263"+
"\7]\2\2\u0262\u0264\7\"\2\2\u0263\u0262\3\2\2\2\u0263\u0264\3\2\2\2\u0264"+
"\u0265\3\2\2\2\u0265\u026a\5N(\2\u0266\u0267\7|\2\2\u0267\u0269\5N(\2"+
"\u0268\u0266\3\2\2\2\u0269\u026c\3\2\2\2\u026a\u0268\3\2\2\2\u026a\u026b"+
"\3\2\2\2\u026bK\3\2\2\2\u026c\u026a\3\2\2\2\u026d\u026f\7]\2\2\u026e\u0270"+
"\7\"\2\2\u026f\u026e\3\2\2\2\u026f\u0270\3\2\2\2\u0270\u0271\3\2\2\2\u0271"+
"\u0276\5P)\2\u0272\u0273\7|\2\2\u0273\u0275\5P)\2\u0274\u0272\3\2\2\2"+
"\u0275\u0278\3\2\2\2\u0276\u0274\3\2\2\2\u0276\u0277\3\2\2\2\u0277M\3"+
"\2\2\2\u0278\u0276\3\2\2\2\u0279\u027b\5R*\2\u027a\u027c\5T+\2\u027b\u027a"+
"\3\2\2\2\u027b\u027c\3\2\2\2\u027cO\3\2\2\2\u027d\u027e\5\u0090I\2\u027e"+
"Q\3\2\2\2\u027f\u0284\5X-\2\u0280\u0284\5\\/\2\u0281\u0284\5V,\2\u0282"+
"\u0284\5\u0090I\2\u0283\u027f\3\2\2\2\u0283\u0280\3\2\2\2\u0283\u0281"+
"\3\2\2\2\u0283\u0282\3\2\2\2\u0284S\3\2\2\2\u0285\u0286\7\20\2\2\u0286"+
"\u0289\5\u00b0Y\2\u0287\u0289\7\u008b\2\2\u0288\u0285\3\2\2\2\u0288\u0287"+
"\3\2\2\2\u0289U\3\2\2\2\u028a\u028b\7&\2\2\u028b\u028c\7~\2\2\u028c\u028d"+
"\5^\60\2\u028d\u028e\7\177\2\2\u028eW\3\2\2\2\u028f\u0290\7E\2\2\u0290"+
"\u0291\5f\64\2\u0291\u0292\7~\2\2\u0292\u0297\5Z.\2\u0293\u0294\7|\2\2"+
"\u0294\u0296\5Z.\2\u0295\u0293\3\2\2\2\u0296\u0299\3\2\2\2\u0297\u0295"+
"\3\2\2\2\u0297\u0298\3\2\2\2\u0298\u029a\3\2\2\2\u0299\u0297\3\2\2\2\u029a"+
"\u029b\7\177\2\2\u029bY\3\2\2\2\u029c\u029d\5\u0090I\2\u029d[\3\2\2\2"+
"\u029e\u029f\7J\2\2\u029f\u02a0\7~\2\2\u02a0\u02a1\5\u00b0Y\2\u02a1\u02a2"+
"\7\177\2\2\u02a2]\3\2\2\2\u02a3\u02a6\5d\63\2\u02a4\u02a5\7}\2\2\u02a5"+
"\u02a7\5h\65\2\u02a6\u02a4\3\2\2\2\u02a6\u02a7\3\2\2\2\u02a7\u02aa\3\2"+
"\2\2\u02a8\u02aa\5h\65\2\u02a9\u02a3\3\2\2\2\u02a9\u02a8\3\2\2\2\u02aa"+
"_\3\2\2\2\u02ab\u02ac\5\u00b0Y\2\u02ac\u02b5\7~\2\2\u02ad\u02b2\5\u0090"+
"I\2\u02ae\u02af\7|\2\2\u02af\u02b1\5\u0090I\2\u02b0\u02ae\3\2\2\2\u02b1"+
"\u02b4\3\2\2\2\u02b2\u02b0\3\2\2\2\u02b2\u02b3\3\2\2\2\u02b3\u02b6\3\2"+
"\2\2\u02b4\u02b2\3\2\2\2\u02b5\u02ad\3\2\2\2\u02b5\u02b6\3\2\2\2\u02b6"+
"\u02b7\3\2\2\2\u02b7\u02b8\7\177\2\2\u02b8a\3\2\2\2\u02b9\u02ba\7R\2\2"+
"\u02ba\u02bd\7~\2\2\u02bb\u02be\5f\64\2\u02bc\u02be\5`\61\2\u02bd\u02bb"+
"\3\2\2\2\u02bd\u02bc\3\2\2\2\u02be\u02bf\3\2\2\2\u02bf\u02c0\7\177\2\2"+
"\u02c0c\3\2\2\2\u02c1\u02c2\7d\2\2\u02c2\u02c3\7~\2\2\u02c3\u02c4\5^\60"+
"\2\u02c4\u02c5\7\20\2\2\u02c5\u02c6\5\66\34\2\u02c6\u02c7\7\177\2\2\u02c7"+
"\u02d3\3\2\2\2\u02c8\u02c9\7k\2\2\u02c9\u02ca\7~\2\2\u02ca\u02cb\5^\60"+
"\2\u02cb\u02cc\7\177\2\2\u02cc\u02d3\3\2\2\2\u02cd\u02ce\7>\2\2\u02ce"+
"\u02cf\7~\2\2\u02cf\u02d0\5^\60\2\u02d0\u02d1\7\177\2\2\u02d1\u02d3\3"+
"\2\2\2\u02d2\u02c1\3\2\2\2\u02d2\u02c8\3\2\2\2\u02d2\u02cd\3\2\2\2\u02d3"+
"e\3\2\2\2\u02d4\u02d9\5\u00b0Y\2\u02d5\u02d6\7}\2\2\u02d6\u02d8\5\u00b2"+
"Z\2\u02d7\u02d5\3\2\2\2\u02d8\u02db\3\2\2\2\u02d9\u02d7\3\2\2\2\u02d9"+
"\u02da\3\2\2\2\u02dag\3\2\2\2\u02db\u02d9\3\2\2\2\u02dc\u02e4\5f\64\2"+
"\u02dd\u02de\7\u0080\2\2\u02de\u02df\5\u0094K\2\u02df\u02e2\7\u0081\2"+
"\2\u02e0\u02e1\7}\2\2\u02e1\u02e3\5h\65\2\u02e2\u02e0\3\2\2\2\u02e2\u02e3"+
"\3\2\2\2\u02e3\u02e5\3\2\2\2\u02e4\u02dd\3\2\2\2\u02e4\u02e5\3\2\2\2\u02e5"+
"i\3\2\2\2\u02e6\u02e7\7\62\2\2\u02e7\u02e8\7\25\2\2\u02e8\u02ed\5l\67"+
"\2\u02e9\u02ea\7|\2\2\u02ea\u02ec\5l\67\2\u02eb\u02e9\3\2\2\2\u02ec\u02ef"+
"\3\2\2\2\u02ed\u02eb\3\2\2\2\u02ed\u02ee\3\2\2\2\u02eek\3\2\2\2\u02ef"+
"\u02ed\3\2\2\2\u02f0\u02f1\5\u0090I\2\u02f1m\3\2\2\2\u02f2\u02f3\7\64"+
"\2\2\u02f3\u02f4\5\u0092J\2\u02f4o\3\2\2\2\u02f5\u02f6\7P\2\2\u02f6\u02f7"+
"\7\25\2\2\u02f7\u02fc\5r:\2\u02f8\u02f9\7|\2\2\u02f9\u02fb\5r:\2\u02fa"+
"\u02f8\3\2\2\2\u02fb\u02fe\3\2\2\2\u02fc\u02fa\3\2\2\2\u02fc\u02fd\3\2"+
"\2\2\u02fdq\3\2\2\2\u02fe\u02fc\3\2\2\2\u02ff\u0302\5\u0090I\2\u0300\u0301"+
"\7\27\2\2\u0301\u0303\7\13\2\2\u0302\u0300\3\2\2\2\u0302\u0303\3\2\2\2"+
"\u0303\u0309\3\2\2\2\u0304\u0307\t\6\2\2\u0305\u0306\7I\2\2\u0306\u0308"+
"\t\7\2\2\u0307\u0305\3\2\2\2\u0307\u0308\3\2\2\2\u0308\u030a\3\2\2\2\u0309"+
"\u0304\3\2\2\2\u0309\u030a\3\2\2\2\u030as\3\2\2\2\u030b\u030c\7o\2\2\u030c"+
"\u030d\5\u00b0Y\2\u030d\u030e\7\20\2\2\u030e\u030f\7~\2\2\u030f\u0310"+
"\5v<\2\u0310\u031a\7\177\2\2\u0311\u0312\7|\2\2\u0312\u0313\5\u00b0Y\2"+
"\u0313\u0314\7\20\2\2\u0314\u0315\7~\2\2\u0315\u0316\5v<\2\u0316\u0317"+
"\7\177\2\2\u0317\u0319\3\2\2\2\u0318\u0311\3\2\2\2\u0319\u031c\3\2\2\2"+
"\u031a\u0318\3\2\2\2\u031a\u031b\3\2\2\2\u031bu\3\2\2\2\u031c\u031a\3"+
"\2\2\2\u031d\u031f\5\u00b0Y\2\u031e\u031d\3\2\2\2\u031e\u031f\3\2\2\2"+
"\u031f\u0321\3\2\2\2\u0320\u0322\5x=\2\u0321\u0320\3\2\2\2\u0321\u0322"+
"\3\2\2\2\u0322\u0324\3\2\2\2\u0323\u0325\5p9\2\u0324\u0323\3\2\2\2\u0324"+
"\u0325\3\2\2\2\u0325\u0327\3\2\2\2\u0326\u0328\5z>\2\u0327\u0326\3\2\2"+
"\2\u0327\u0328\3\2\2\2\u0328w\3\2\2\2\u0329\u032a\7U\2\2\u032a\u032b\7"+
"\25\2\2\u032b\u0330\5l\67\2\u032c\u032d\7|\2\2\u032d\u032f\5l\67\2\u032e"+
"\u032c\3\2\2\2\u032f\u0332\3\2\2\2\u0330\u032e\3\2\2\2\u0330\u0331\3\2"+
"\2\2\u0331y\3\2\2\2\u0332\u0330\3\2\2\2\u0333\u0334\t\b\2\2\u0334\u0336"+
"\5|?\2\u0335\u0337\5\u0080A\2\u0336\u0335\3\2\2\2\u0336\u0337\3\2\2\2"+
"\u0337\u0341\3\2\2\2\u0338\u0339\t\b\2\2\u0339\u033a\7\23\2\2\u033a\u033b"+
"\5|?\2\u033b\u033c\7\16\2\2\u033c\u033e\5~@\2\u033d\u033f\5\u0080A\2\u033e"+
"\u033d\3\2\2\2\u033e\u033f\3\2\2\2\u033f\u0341\3\2\2\2\u0340\u0333\3\2"+
"\2\2\u0340\u0338\3\2\2\2\u0341{\3\2\2\2\u0342\u0343\7h\2\2\u0343\u034d"+
"\7V\2\2\u0344\u0345\5\u0086D\2\u0345\u0346\7V\2\2\u0346\u034d\3\2\2\2"+
"\u0347\u0348\7\33\2\2\u0348\u034d\7[\2\2\u0349\u034a\5\u0086D\2\u034a"+
"\u034b\7/\2\2\u034b\u034d\3\2\2\2\u034c\u0342\3\2\2\2\u034c\u0344\3\2"+
"\2\2\u034c\u0347\3\2\2\2\u034c\u0349\3\2\2\2\u034d}\3\2\2\2\u034e\u034f"+
"\7h\2\2\u034f\u035b\7V\2\2\u0350\u0351\5\u0086D\2\u0351\u0352\7V\2\2\u0352"+
"\u035b\3\2\2\2\u0353\u0354\7\33\2\2\u0354\u035b\7[\2\2\u0355\u0356\5\u0086"+
"D\2\u0356\u0357\7/\2\2\u0357\u035b\3\2\2\2\u0358\u0359\7h\2\2\u0359\u035b"+
"\7/\2\2\u035a\u034e\3\2\2\2\u035a\u0350\3\2\2\2\u035a\u0353\3\2\2\2\u035a"+
"\u0355\3\2\2\2\u035a\u0358\3\2\2\2\u035b\177\3\2\2\2\u035c\u035d\7)\2"+
"\2\u035d\u035e\7\33\2\2\u035e\u0367\7[\2\2\u035f\u0360\7)\2\2\u0360\u0367"+
"\7\62\2\2\u0361\u0362\7)\2\2\u0362\u0367\7a\2\2\u0363\u0364\7)\2\2\u0364"+
"\u0365\7F\2\2\u0365\u0367\7Q\2\2\u0366\u035c\3\2\2\2\u0366\u035f\3\2\2"+
"\2\u0366\u0361\3\2\2\2\u0366\u0363\3\2\2\2\u0367\u0081\3\2\2\2\u0368\u0369"+
"\7C\2\2\u0369\u036a\5\u0086D\2\u036a\u0083\3\2\2\2\u036b\u036c\7L\2\2"+
"\u036c\u0373\5\u0086D\2\u036d\u036e\7=\2\2\u036e\u036f\7b\2\2\u036f\u0370"+
"\7T\2\2\u0370\u0371\7\30\2\2\u0371\u0373\5\u00a8U\2\u0372\u036b\3\2\2"+
"\2\u0372\u036d\3\2\2\2\u0373\u0085\3\2\2\2\u0374\u0377\5\u00a8U\2\u0375"+
"\u0377\7\4\2\2\u0376\u0374\3\2\2\2\u0376\u0375\3\2\2\2\u0377\u0087\3\2"+
"\2\2\u0378\u0379\t\t\2\2\u0379\u0387\5\u008aF\2\u037a\u037b\t\t\2\2\u037b"+
"\u037c\7~\2\2\u037c\u0381\5\u008aF\2\u037d\u037e\7|\2\2\u037e\u0380\5"+
"\u008aF\2\u037f\u037d\3\2\2\2\u0380\u0383\3\2\2\2\u0381\u037f\3\2\2\2"+
"\u0381\u0382\3\2\2\2\u0382\u0384\3\2\2\2\u0383\u0381\3\2\2\2\u0384\u0385"+
"\7\177\2\2\u0385\u0387\3\2\2\2\u0386\u0378\3\2\2\2\u0386\u037a\3\2\2\2"+
"\u0387\u0089\3\2\2\2\u0388\u038b\5\u00a8U\2\u0389\u038b\5\u009eP\2\u038a"+
"\u0388\3\2\2\2\u038a\u0389\3\2\2\2\u038b\u008b\3\2\2\2\u038c\u0391\5\u00b0"+
"Y\2\u038d\u038e\t\n\2\2\u038e\u0390\5\u00b2Z\2\u038f\u038d\3\2\2\2\u0390"+
"\u0393\3\2\2\2\u0391\u038f\3\2\2\2\u0391\u0392\3\2\2\2\u0392\u008d\3\2"+
"\2\2\u0393\u0391\3\2\2\2\u0394\u0395\7n\2\2\u0395\u0396\5\u0092J\2\u0396"+
"\u008f\3\2\2\2\u0397\u0398\bI\1\2\u0398\u0399\7~\2\2\u0399\u039a\5\u0090"+
"I\2\u039a\u039b\7\177\2\2\u039b\u03c0\3\2\2\2\u039c\u039d\7\26\2\2\u039d"+
"\u039f\5\u0090I\2\u039e\u03a0\5\u009aN\2\u039f\u039e\3\2\2\2\u03a0\u03a1"+
"\3\2\2\2\u03a1\u039f\3\2\2\2\u03a1\u03a2\3\2\2\2\u03a2\u03a5\3\2\2\2\u03a3"+
"\u03a4\7#\2\2\u03a4\u03a6\5\u0090I\2\u03a5\u03a3\3\2\2\2\u03a5\u03a6\3"+
"\2\2\2\u03a6\u03a7\3\2\2\2\u03a7\u03a8\7%\2\2\u03a8\u03c0\3\2\2\2\u03a9"+
"\u03ab\7\26\2\2\u03aa\u03ac\5\u009cO\2\u03ab\u03aa\3\2\2\2\u03ac\u03ad"+
"\3\2\2\2\u03ad\u03ab\3\2\2\2\u03ad\u03ae\3\2\2\2\u03ae\u03b1\3\2\2\2\u03af"+
"\u03b0\7#\2\2\u03b0\u03b2\5\u0090I\2\u03b1\u03af\3\2\2\2\u03b1\u03b2\3"+
"\2\2\2\u03b2\u03b3\3\2\2\2\u03b3\u03b4\7%\2\2\u03b4\u03c0\3\2\2\2\u03b5"+
"\u03c0\5\u009eP\2\u03b6\u03c0\5\u00a8U\2\u03b7\u03c0\5\u0098M\2\u03b8"+
"\u03c0\t\13\2\2\u03b9\u03c0\5^\60\2\u03ba\u03c0\5\u00aaV\2\u03bb\u03bc"+
"\7\u0083\2\2\u03bc\u03c0\5\u0090I\7\u03bd\u03be\7\u0082\2\2\u03be\u03c0"+
"\5\u0090I\6\u03bf\u0397\3\2\2\2\u03bf\u039c\3\2\2\2\u03bf\u03a9\3\2\2"+
"\2\u03bf\u03b5\3\2\2\2\u03bf\u03b6\3\2\2\2\u03bf\u03b7\3\2\2\2\u03bf\u03b8"+
"\3\2\2\2\u03bf\u03b9\3\2\2\2\u03bf\u03ba\3\2\2\2\u03bf\u03bb\3\2\2\2\u03bf"+
"\u03bd\3\2\2\2\u03c0\u03cc\3\2\2\2\u03c1\u03c2\f\5\2\2\u03c2\u03c3\t\f"+
"\2\2\u03c3\u03cb\5\u0090I\6\u03c4\u03c5\f\4\2\2\u03c5\u03c6\t\r\2\2\u03c6"+
"\u03cb\5\u0090I\5\u03c7\u03c8\f\3\2\2\u03c8\u03c9\7\u0088\2\2\u03c9\u03cb"+
"\5\u0090I\4\u03ca\u03c1\3\2\2\2\u03ca\u03c4\3\2\2\2\u03ca\u03c7\3\2\2"+
"\2\u03cb\u03ce\3\2\2\2\u03cc\u03ca\3\2\2\2\u03cc\u03cd\3\2\2\2\u03cd\u0091"+
"\3\2\2\2\u03ce\u03cc\3\2\2\2\u03cf\u03d0\bJ\1\2\u03d0\u03d1\7~\2\2\u03d1"+
"\u03d2\5\u0092J\2\u03d2\u03d3\7\177\2\2\u03d3\u0472\3\2\2\2\u03d4\u03d5"+
"\7G\2\2\u03d5\u0472\5\u0092J\30\u03d6\u03d8\7G\2\2\u03d7\u03d6\3\2\2\2"+
"\u03d7\u03d8\3\2\2\2\u03d8\u03d9\3\2\2\2\u03d9\u03df\7*\2\2\u03da\u03e0"+
"\5\u00b0Y\2\u03db\u03dc\7~\2\2\u03dc\u03dd\5\u00b0Y\2\u03dd\u03de\7\177"+
"\2\2\u03de\u03e0\3\2\2\2\u03df\u03da\3\2\2\2\u03df\u03db\3\2\2\2\u03e0"+
"\u0472\3\2\2\2\u03e1\u03e2\5\u0090I\2\u03e2\u03e4\7;\2\2\u03e3\u03e5\7"+
"G\2\2\u03e4\u03e3\3\2\2\2\u03e4\u03e5\3\2\2\2\u03e5\u03e6\3\2\2\2\u03e6"+
"\u03e7\7H\2\2\u03e7\u0472\3\2\2\2\u03e8\u03e9\5\u0090I\2\u03e9\u03eb\7"+
";\2\2\u03ea\u03ec\7G\2\2\u03eb\u03ea\3\2\2\2\u03eb\u03ec\3\2\2\2\u03ec"+
"\u03ed\3\2\2\2\u03ed\u03ee\7$\2\2\u03ee\u0472\3\2\2\2\u03ef\u03f0\5\u0090"+
"I\2\u03f0\u03f2\7v\2\2\u03f1\u03f3\t\16\2\2\u03f2\u03f1\3\2\2\2\u03f2"+
"\u03f3\3\2\2\2\u03f3\u03f9\3\2\2\2\u03f4\u03fa\5\u00b0Y\2\u03f5\u03f6"+
"\7~\2\2\u03f6\u03f7\5\u00b0Y\2\u03f7\u03f8\7\177\2\2\u03f8\u03fa\3\2\2"+
"\2\u03f9\u03f4\3\2\2\2\u03f9\u03f5\3\2\2\2\u03fa\u0472\3\2\2\2\u03fb\u03fc"+
"\5\u0090I\2\u03fc\u03fe\7w\2\2\u03fd\u03ff\t\16\2\2\u03fe\u03fd\3\2\2"+
"\2\u03fe\u03ff\3\2\2\2\u03ff\u0405\3\2\2\2\u0400\u0406\5\u00b0Y\2\u0401"+
"\u0402\7~\2\2\u0402\u0403\5\u00b0Y\2\u0403\u0404\7\177\2\2\u0404\u0406"+
"\3\2\2\2\u0405\u0400\3\2\2\2\u0405\u0401\3\2\2\2\u0406\u0472\3\2\2\2\u0407"+
"\u0408\5\u0090I\2\u0408\u040a\7x\2\2\u0409\u040b\t\16\2\2\u040a\u0409"+
"\3\2\2\2\u040a\u040b\3\2\2\2\u040b\u0411\3\2\2\2\u040c\u0412\5\u00b0Y"+
"\2\u040d\u040e\7~\2\2\u040e\u040f\5\u00b0Y\2\u040f\u0410\7\177\2\2\u0410"+
"\u0412\3\2\2\2\u0411\u040c\3\2\2\2\u0411\u040d\3\2\2\2\u0412\u0472\3\2"+
"\2\2\u0413\u0414\5\u0090I\2\u0414\u0416\7y\2\2\u0415\u0417\t\16\2\2\u0416"+
"\u0415\3\2\2\2\u0416\u0417\3\2\2\2\u0417\u041d\3\2\2\2\u0418\u041e\5\u00b0"+
"Y\2\u0419\u041a\7~\2\2\u041a\u041b\5\u00b0Y\2\u041b\u041c\7\177\2\2\u041c"+
"\u041e\3\2\2\2\u041d\u0418\3\2\2\2\u041d\u0419\3\2\2\2\u041e\u0472\3\2"+
"\2\2\u041f\u0420\5\u0090I\2\u0420\u0422\7z\2\2\u0421\u0423\t\16\2\2\u0422"+
"\u0421\3\2\2\2\u0422\u0423\3\2\2\2\u0423\u0429\3\2\2\2\u0424\u042a\5\u00b0"+
"Y\2\u0425\u0426\7~\2\2\u0426\u0427\5\u00b0Y\2\u0427\u0428\7\177\2\2\u0428"+
"\u042a\3\2\2\2\u0429\u0424\3\2\2\2\u0429\u0425\3\2\2\2\u042a\u0472\3\2"+
"\2\2\u042b\u042c\5\u0090I\2\u042c\u042e\7{\2\2\u042d\u042f\t\16\2\2\u042e"+
"\u042d\3\2\2\2\u042e\u042f\3\2\2\2\u042f\u0435\3\2\2\2\u0430\u0436\5\u00b0"+
"Y\2\u0431\u0432\7~\2\2\u0432\u0433\5\u00b0Y\2\u0433\u0434\7\177\2\2\u0434"+
"\u0436\3\2\2\2\u0435\u0430\3\2\2\2\u0435\u0431\3\2\2\2\u0436\u0472\3\2"+
"\2\2\u0437\u0438\5\u0090I\2\u0438\u0439\7v\2\2\u0439\u043a\5\u0090I\2"+
"\u043a\u0472\3\2\2\2\u043b\u043c\5\u0090I\2\u043c\u043d\7w\2\2\u043d\u043e"+
"\5\u0090I\2\u043e\u0472\3\2\2\2\u043f\u0440\5\u0090I\2\u0440\u0441\7x"+
"\2\2\u0441\u0442\5\u0090I\2\u0442\u0472\3\2\2\2\u0443\u0444\5\u0090I\2"+
"\u0444\u0445\7y\2\2\u0445\u0446\5\u0090I\2\u0446\u0472\3\2\2\2\u0447\u0448"+
"\5\u0090I\2\u0448\u0449\7z\2\2\u0449\u044a\5\u0090I\2\u044a\u0472\3\2"+
"\2\2\u044b\u044c\5\u0090I\2\u044c\u044d\7{\2\2\u044d\u044e\5\u0090I\2"+
"\u044e\u0472\3\2\2\2\u044f\u0451\5\u0090I\2\u0450\u0452\7G\2\2\u0451\u0450"+
"\3\2\2\2\u0451\u0452\3\2\2\2\u0452\u0453\3\2\2\2\u0453\u0454\7\65\2\2"+
"\u0454\u0455\5\u0096L\2\u0455\u0472\3\2\2\2\u0456\u0458\5\u0090I\2\u0457"+
"\u0459\7G\2\2\u0458\u0457\3\2\2\2\u0458\u0459\3\2\2\2\u0459\u045a\3\2"+
"\2\2\u045a\u045b\7\23\2\2\u045b\u045c\5\u0090I\2\u045c\u045d\7\16\2\2"+
"\u045d\u045e\5\u0090I\2\u045e\u0472\3\2\2\2\u045f\u0461\5\u0090I\2\u0460"+
"\u0462\7G\2\2\u0461\u0460\3\2\2\2\u0461\u0462\3\2\2\2\u0462\u0463\3\2"+
"\2\2\u0463\u0464\7B\2\2\u0464\u0467\5\u0090I\2\u0465\u0466\7\'\2\2\u0466"+
"\u0468\5\u0090I\2\u0467\u0465\3\2\2\2\u0467\u0468\3\2\2\2\u0468\u0472"+
"\3\2\2\2\u0469\u046b\5\u0090I\2\u046a\u046c\7G\2\2\u046b\u046a\3\2\2\2"+
"\u046b\u046c\3\2\2\2\u046c\u046d\3\2\2\2\u046d\u046e\7D\2\2\u046e\u046f"+
"\7K\2\2\u046f\u0470\5^\60\2\u0470\u0472\3\2\2\2\u0471\u03cf\3\2\2\2\u0471"+
"\u03d4\3\2\2\2\u0471\u03d7\3\2\2\2\u0471\u03e1\3\2\2\2\u0471\u03e8\3\2"+
"\2\2\u0471\u03ef\3\2\2\2\u0471\u03fb\3\2\2\2\u0471\u0407\3\2\2\2\u0471"+
"\u0413\3\2\2\2\u0471\u041f\3\2\2\2\u0471\u042b\3\2\2\2\u0471\u0437\3\2"+
"\2\2\u0471\u043b\3\2\2\2\u0471\u043f\3\2\2\2\u0471\u0443\3\2\2\2\u0471"+
"\u0447\3\2\2\2\u0471\u044b\3\2\2\2\u0471\u044f\3\2\2\2\u0471\u0456\3\2"+
"\2\2\u0471\u045f\3\2\2\2\u0471\u0469\3\2\2\2\u0472\u047b\3\2\2\2\u0473"+
"\u0474\f\27\2\2\u0474\u0475\7\16\2\2\u0475\u047a\5\u0092J\30\u0476\u0477"+
"\f\26\2\2\u0477\u0478\7O\2\2\u0478\u047a\5\u0092J\27\u0479\u0473\3\2\2"+
"\2\u0479\u0476\3\2\2\2\u047a\u047d\3\2\2\2\u047b\u0479\3\2\2\2\u047b\u047c"+
"\3\2\2\2\u047c\u0093\3\2\2\2\u047d\u047b\3\2\2\2\u047e\u0481\5\u0092J"+
"\2\u047f\u0481\5\u0090I\2\u0480\u047e\3\2\2\2\u0480\u047f\3\2\2\2\u0481"+
"\u0095\3\2\2\2\u0482\u0483\7~\2\2\u0483\u0488\5\u0090I\2\u0484\u0485\7"+
"|\2\2\u0485\u0487\5\u0090I\2\u0486\u0484\3\2\2\2\u0487\u048a\3\2\2\2\u0488"+
"\u0486\3\2\2\2\u0488\u0489\3\2\2\2\u0489\u048b\3\2\2\2\u048a\u0488\3\2"+
"\2\2\u048b\u048c\7\177\2\2\u048c\u048f\3\2\2\2\u048d\u048f\5\u0090I\2"+
"\u048e\u0482\3\2\2\2\u048e\u048d\3\2\2\2\u048f\u0097\3\2\2\2\u0490\u0491"+
"\7g\2\2\u0491\u0494\7~\2\2\u0492\u0495\5^\60\2\u0493\u0495\5\u00a8U\2"+
"\u0494\u0492\3\2\2\2\u0494\u0493\3\2\2\2\u0495\u0496\3\2\2\2\u0496\u0497"+
"\7\177\2\2\u0497\u0099\3\2\2\2\u0498\u0499\7m\2\2\u0499\u049a\5\u0090"+
"I\2\u049a\u049b\7`\2\2\u049b\u049c\5\u0090I\2\u049c\u009b\3\2\2\2\u049d"+
"\u049e\7m\2\2\u049e\u049f\5\u0092J\2\u049f\u04a0\7`\2\2\u04a0\u04a1\5"+
"\u0090I\2\u04a1\u009d\3\2\2\2\u04a2\u04b1\7\13\2\2\u04a3\u04b1\7\n\2\2"+
"\u04a4\u04b1\7\4\2\2\u04a5\u04b1\7\6\2\2\u04a6\u04b1\7\5\2\2\u04a7\u04b1"+
"\7\7\2\2\u04a8\u04b1\7\b\2\2\u04a9\u04b1\7\t\2\2\u04aa\u04b1\7H\2\2\u04ab"+
"\u04b1\7f\2\2\u04ac\u04b1\7+\2\2\u04ad\u04b1\5\u00a0Q\2\u04ae\u04b1\5"+
"\u00a2R\2\u04af\u04b1\5\u00a4S\2\u04b0\u04a2\3\2\2\2\u04b0\u04a3\3\2\2"+
"\2\u04b0\u04a4\3\2\2\2\u04b0\u04a5\3\2\2\2\u04b0\u04a6\3\2\2\2\u04b0\u04a7"+
"\3\2\2\2\u04b0\u04a8\3\2\2\2\u04b0\u04a9\3\2\2\2\u04b0\u04aa\3\2\2\2\u04b0"+
"\u04ab\3\2\2\2\u04b0\u04ac\3\2\2\2\u04b0\u04ad\3\2\2\2\u04b0\u04ae\3\2"+
"\2\2\u04b0\u04af\3\2\2\2\u04b1\u009f\3\2\2\2\u04b2\u04b3\7r\2\2\u04b3"+
"\u04b4\5\u00a6T\2\u04b4\u04b5\7u\2\2\u04b5\u00a1\3\2\2\2\u04b6\u04b7\7"+
"s\2\2\u04b7\u04b8\5\u00a6T\2\u04b8\u04b9\7u\2\2\u04b9\u00a3\3\2\2\2\u04ba"+
"\u04bb\7t\2\2\u04bb\u04bc\5\u00a6T\2\u04bc\u04bd\7u\2\2\u04bd\u00a5\3"+
"\2\2\2\u04be\u04bf\t\17\2\2\u04bf\u00a7\3\2\2\2\u04c0\u04c1\7\u0087\2"+
"\2\u04c1\u04c5\5\u00b0Y\2\u04c2\u04c3\7\u0089\2\2\u04c3\u04c5\7\4\2\2"+
"\u04c4\u04c0\3\2\2\2\u04c4\u04c2\3\2\2\2\u04c5\u00a9\3\2\2\2\u04c6\u04c7"+
"\7e\2\2\u04c7\u04c9\7~\2\2\u04c8\u04ca\5\u00acW\2\u04c9\u04c8\3\2\2\2"+
"\u04c9\u04ca\3\2\2\2\u04ca\u04cc\3\2\2\2\u04cb\u04cd\5\u00aeX\2\u04cc"+
"\u04cb\3\2\2\2\u04cc\u04cd\3\2\2\2\u04cd\u04cf\3\2\2\2\u04ce\u04d0\7\60"+
"\2\2\u04cf\u04ce\3\2\2\2\u04cf\u04d0\3\2\2\2\u04d0\u04d1\3\2\2\2\u04d1"+
"\u04d2\5\u0090I\2\u04d2\u04d3\7\177\2\2\u04d3\u051e\3\2\2\2\u04d4\u04d7"+
"\t\13\2\2\u04d5\u04d6\7~\2\2\u04d6\u04d8\7\177\2\2\u04d7\u04d5\3\2\2\2"+
"\u04d7\u04d8\3\2\2\2\u04d8\u051e\3\2\2\2\u04d9\u04da\7\31\2\2\u04da\u04e0"+
"\7~\2\2\u04db\u04dd\7\"\2\2\u04dc\u04db\3\2\2\2\u04dc\u04dd\3\2\2\2\u04dd"+
"\u04de\3\2\2\2\u04de\u04e1\5\u0090I\2\u04df\u04e1\7\u0084\2\2\u04e0\u04dc"+
"\3\2\2\2\u04e0\u04df\3\2\2\2\u04e1\u04e2\3\2\2\2\u04e2\u04e8\7\177\2\2"+
"\u04e3\u04e4\7-\2\2\u04e4\u04e5\7~\2\2\u04e5\u04e6\5\u008eH\2\u04e6\u04e7"+
"\7\177\2\2\u04e7\u04e9\3\2\2\2\u04e8\u04e3\3\2\2\2\u04e8\u04e9\3\2\2\2"+
"\u04e9\u04f2\3\2\2\2\u04ea\u04f0\7S\2\2\u04eb\u04f1\5\u00b0Y\2\u04ec\u04ed"+
"\7~\2\2\u04ed\u04ee\5v<\2\u04ee\u04ef\7\177\2\2\u04ef\u04f1\3\2\2\2\u04f0"+
"\u04eb\3\2\2\2\u04f0\u04ec\3\2\2\2\u04f1\u04f3\3\2\2\2\u04f2\u04ea\3\2"+
"\2\2\u04f2\u04f3\3\2\2\2\u04f3\u051e\3\2\2\2\u04f4\u04f5\5\u00b0Y\2\u04f5"+
"\u04f7\7~\2\2\u04f6\u04f8\7\"\2\2\u04f7\u04f6\3\2\2\2\u04f7\u04f8\3\2"+
"\2\2\u04f8\u0501\3\2\2\2\u04f9\u04fe\5\u0090I\2\u04fa\u04fb\7|\2\2\u04fb"+
"\u04fd\5\u0090I\2\u04fc\u04fa\3\2\2\2\u04fd\u0500\3\2\2\2\u04fe\u04fc"+
"\3\2\2\2\u04fe\u04ff\3\2\2\2\u04ff\u0502\3\2\2\2\u0500\u04fe\3\2\2\2\u0501"+
"\u04f9\3\2\2\2\u0501\u0502\3\2\2\2\u0502\u0503\3\2\2\2\u0503\u050a\7\177"+
"\2\2\u0504\u0505\7q\2\2\u0505\u0506\7\62\2\2\u0506\u0507\7~\2\2\u0507"+
"\u0508\5p9\2\u0508\u0509\7\177\2\2\u0509\u050b\3\2\2\2\u050a\u0504\3\2"+
"\2\2\u050a\u050b\3\2\2\2\u050b\u0511\3\2\2\2\u050c\u050d\7-\2\2\u050d"+
"\u050e\7~\2\2\u050e\u050f\5\u008eH\2\u050f\u0510\7\177\2\2\u0510\u0512"+
"\3\2\2\2\u0511\u050c\3\2\2\2\u0511\u0512\3\2\2\2\u0512\u051b\3\2\2\2\u0513"+
"\u0519\7S\2\2\u0514\u051a\5\u00b0Y\2\u0515\u0516\7~\2\2\u0516\u0517\5"+
"v<\2\u0517\u0518\7\177\2\2\u0518\u051a\3\2\2\2\u0519\u0514\3\2\2\2\u0519"+
"\u0515\3\2\2\2\u051a\u051c\3\2\2\2\u051b\u0513\3\2\2\2\u051b\u051c\3\2"+
"\2\2\u051c\u051e\3\2\2\2\u051d\u04c6\3\2\2\2\u051d\u04d4\3\2\2\2\u051d"+
"\u04d9\3\2\2\2\u051d\u04f4\3\2\2\2\u051e\u00ab\3\2\2\2\u051f\u0520\t\20"+
"\2\2\u0520\u00ad\3\2\2\2\u0521\u0525\7\n\2\2\u0522\u0525\7\13\2\2\u0523"+
"\u0525\5\u00a8U\2\u0524\u0521\3\2\2\2\u0524\u0522\3\2\2\2\u0524\u0523"+
"\3\2\2\2\u0525\u00af\3\2\2\2\u0526\u0527\t\21\2\2\u0527\u00b1\3\2\2\2"+
"\u0528\u052c\5\u00b0Y\2\u0529\u052c\7f\2\2\u052a\u052c\7+\2\2\u052b\u0528"+
"\3\2\2\2\u052b\u0529\3\2\2\2\u052b\u052a\3\2\2\2\u052c\u00b3\3\2\2\2\u00aa"+
"\u00b6\u00b9\u00ca\u00d5\u00db\u00e7\u00f4\u00fc\u0100\u0108\u010c\u0111"+
"\u0114\u0117\u011a\u011e\u0121\u0124\u0129\u012c\u0130\u0137\u013a\u013d"+
"\u0140\u0144\u014b\u014e\u015b\u015f\u0162\u016b\u0170\u017d\u0185\u0190"+
"\u0194\u0198\u019b\u019e\u01a1\u01a4\u01a8\u01ab\u01ae\u01b1\u01b4\u01bc"+
"\u01c5\u01cc\u01ce\u01d5\u01d7\u01dc\u01ed\u01f9\u0206\u0211\u0213\u021b"+
"\u0225\u0231\u0236\u023a\u0240\u0244\u024e\u0251\u0254\u0257\u025a\u025c"+
"\u0263\u026a\u026f\u0276\u027b\u0283\u0288\u0297\u02a6\u02a9\u02b2\u02b5"+
"\u02bd\u02d2\u02d9\u02e2\u02e4\u02ed\u02fc\u0302\u0307\u0309\u031a\u031e"+
"\u0321\u0324\u0327\u0330\u0336\u033e\u0340\u034c\u035a\u0366\u0372\u0376"+
"\u0381\u0386\u038a\u0391\u03a1\u03a5\u03ad\u03b1\u03bf\u03ca\u03cc\u03d7"+
"\u03df\u03e4\u03eb\u03f2\u03f9\u03fe\u0405\u040a\u0411\u0416\u041d\u0422"+
"\u0429\u042e\u0435\u0451\u0458\u0461\u0467\u046b\u0471\u0479\u047b\u0480"+
"\u0488\u048e\u0494\u04b0\u04c4\u04c9\u04cc\u04cf\u04d7\u04dc\u04e0\u04e8"+
"\u04f0\u04f2\u04f7\u04fe\u0501\u050a\u0511\u0519\u051b\u051d\u0524\u052b";
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);
}
}
}