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_plainLiteral = 79, RULE_plainNumericLiteral = 80,
RULE_timestampLiteral = 81, RULE_dateLiteral = 82, RULE_timeLiteral = 83,
RULE_dateTimeLiteralText = 84, RULE_parameter = 85, RULE_function = 86,
RULE_trimSpecification = 87, RULE_trimCharacter = 88, RULE_identifier = 89,
RULE_identifierNonStart = 90;
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", "plainLiteral", "plainNumericLiteral",
"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(187);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WITH) {
{
setState(182);
match(WITH);
setState(184);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
case 1:
{
setState(183);
match(RECURSIVE);
}
break;
}
setState(186);
withQuery();
}
}
setState(189);
simpleStatement();
setState(190);
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(192);
selectExpression();
setState(193);
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(204);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(195);
path();
setState(196);
match(EOF);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(198);
outerPath();
setState(199);
match(EOF);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(201);
macroPath();
setState(202);
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(206);
expression(0);
setState(207);
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(215);
_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 PLUS:
case MINUS:
case COLON:
case QUESTION_MARK:
enterOuterAlt(_localctx, 1);
{
setState(209);
parameterOrLiteral();
setState(210);
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(212);
entityTypeOrEnumLiteral();
setState(213);
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(221);
_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 PLUS:
case MINUS:
case COLON:
case QUESTION_MARK:
enterOuterAlt(_localctx, 1);
{
setState(217);
parameterOrLiteral();
setState(218);
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(220);
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(223);
predicate(0);
setState(224);
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(226);
entityName();
setState(227);
match(LP);
setState(228);
identifier();
setState(233);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(229);
match(COMMA);
setState(230);
identifier();
}
}
setState(235);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(236);
match(RP);
setState(237);
match(AS);
setState(238);
match(LP);
setState(239);
simpleStatement();
setState(240);
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(246);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FROM:
case SELECT:
case LP:
enterOuterAlt(_localctx, 1);
{
setState(242);
selectStatement();
}
break;
case UPDATE:
enterOuterAlt(_localctx, 2);
{
setState(243);
updateStatement();
}
break;
case DELETE:
enterOuterAlt(_localctx, 3);
{
setState(244);
deleteStatement();
}
break;
case INSERT:
enterOuterAlt(_localctx, 4);
{
setState(245);
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(258);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FROM:
case SELECT:
enterOuterAlt(_localctx, 1);
{
setState(248);
querySpecification();
}
break;
case LP:
enterOuterAlt(_localctx, 2);
{
setState(249);
match(LP);
setState(250);
selectStatement();
setState(251);
match(RP);
setState(252);
_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(254);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(253);
_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(256);
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(270);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SELECT:
enterOuterAlt(_localctx, 1);
{
setState(260);
subQuerySpecification();
}
break;
case LP:
enterOuterAlt(_localctx, 2);
{
setState(261);
match(LP);
setState(262);
subQuery();
setState(263);
match(RP);
setState(264);
_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(266);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(265);
_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(268);
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(272);
subQuerySelectClause();
setState(273);
subQueryFromClause();
setState(275);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AFTER || _la==BEFORE) {
{
setState(274);
keysetClause();
}
}
setState(278);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(277);
whereClause();
}
}
setState(281);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GROUP) {
{
setState(280);
groupByClause();
}
}
setState(284);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==HAVING) {
{
setState(283);
havingClause();
}
}
setState(291);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXCEPT || _la==INTERSECT || _la==UNION) {
{
setState(286);
_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(288);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(287);
_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(290);
subQuery();
}
}
setState(294);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
case 1:
{
setState(293);
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(296);
orderByClause();
setState(302);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LIMIT:
{
{
setState(297);
limitClause();
setState(299);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==JUMP || _la==OFFSET) {
{
setState(298);
offsetClause();
}
}
}
}
break;
case JUMP:
case OFFSET:
{
setState(301);
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(304);
match(DELETE);
setState(306);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
case 1:
{
setState(305);
match(FROM);
}
break;
}
setState(308);
entityName();
setState(313);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LP) {
{
setState(309);
match(LP);
setState(310);
simpleSubpath();
setState(311);
match(RP);
}
}
setState(316);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==IDENTIFIER) {
{
setState(315);
identificationVariable();
}
}
setState(319);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(318);
whereClause();
}
}
setState(322);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RETURNING) {
{
setState(321);
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(324);
match(UPDATE);
setState(326);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
case 1:
{
setState(325);
match(FROM);
}
break;
}
setState(328);
entityName();
setState(333);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LP) {
{
setState(329);
match(LP);
setState(330);
simpleSubpath();
setState(331);
match(RP);
}
}
setState(336);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==IDENTIFIER) {
{
setState(335);
identificationVariable();
}
}
setState(338);
match(SET);
setState(339);
dmlAttributeName();
setState(340);
match(EQUAL);
setState(341);
expression(0);
setState(349);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(342);
match(COMMA);
setState(343);
dmlAttributeName();
setState(344);
match(EQUAL);
setState(345);
expression(0);
}
}
setState(351);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(353);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(352);
whereClause();
}
}
setState(356);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RETURNING) {
{
setState(355);
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(358);
match(INSERT);
setState(359);
match(INTO);
setState(360);
entityName();
setState(365);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
case 1:
{
setState(361);
match(LP);
setState(362);
simpleSubpath();
setState(363);
match(RP);
}
break;
}
setState(367);
targetFieldsSpecification();
setState(368);
querySpecification();
setState(370);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==RETURNING) {
{
setState(369);
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(383);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(372);
simpleSubpath();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(373);
match(KEY);
setState(374);
match(LP);
setState(375);
path();
setState(376);
match(RP);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(378);
match(INDEX);
setState(379);
match(LP);
setState(380);
path();
setState(381);
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(385);
match(LP);
setState(386);
dmlAttributeName();
setState(391);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(387);
match(COMMA);
setState(388);
dmlAttributeName();
}
}
setState(393);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(394);
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(396);
match(RETURNING);
setState(397);
simpleSubpath();
setState(402);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(398);
match(COMMA);
setState(399);
simpleSubpath();
}
}
setState(404);
_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(406);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SELECT) {
{
setState(405);
selectClause();
}
}
setState(408);
fromClause();
setState(410);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AFTER || _la==BEFORE) {
{
setState(409);
keysetClause();
}
}
setState(413);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WHERE) {
{
setState(412);
whereClause();
}
}
setState(416);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==GROUP) {
{
setState(415);
groupByClause();
}
}
setState(419);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==HAVING) {
{
setState(418);
havingClause();
}
}
setState(422);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==WINDOW) {
{
setState(421);
windowClause();
}
}
setState(429);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXCEPT || _la==INTERSECT || _la==UNION) {
{
setState(424);
_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(426);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ALL || _la==DISTINCT) {
{
setState(425);
_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(428);
querySpecification();
}
}
setState(432);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) {
case 1:
{
setState(431);
orderByClause();
}
break;
}
setState(435);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
case 1:
{
setState(434);
limitClause();
}
break;
}
setState(438);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,46,_ctx) ) {
case 1:
{
setState(437);
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(440);
match(FROM);
setState(441);
fromItem();
setState(446);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(442);
match(COMMA);
setState(443);
fromItem();
}
}
setState(448);
_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(449);
match(FROM);
setState(450);
subQueryFromItem();
setState(455);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(451);
match(COMMA);
setState(452);
subQueryFromItem();
}
}
setState(457);
_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(458);
fromItemElement();
setState(464);
_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(462);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CROSS:
{
setState(459);
crossJoin();
}
break;
case COMMA:
{
setState(460);
inCollectionJoin();
}
break;
case FULL:
case INNER:
case JOIN:
case LEFT:
case OUTER:
case RIGHT:
{
setState(461);
qualifiedJoin();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
setState(466);
_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(467);
fromItemElement();
setState(473);
_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(471);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CROSS:
{
setState(468);
crossJoin();
}
break;
case COMMA:
{
setState(469);
inCollectionJoin();
}
break;
case FULL:
case INNER:
case JOIN:
case LEFT:
case OUTER:
case RIGHT:
{
setState(470);
subQueryQualifiedJoin();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
setState(475);
_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(533);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,58,_ctx) ) {
case 1:
_localctx = new FromEntityContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(476);
entityName();
setState(478);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==IDENTIFIER) {
{
setState(477);
identificationVariable();
}
}
}
break;
case 2:
_localctx = new FromValuesContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(480);
entityName();
setState(481);
match(LP);
setState(482);
match(INTEGER_LITERAL);
setState(483);
match(VALUES);
setState(484);
match(RP);
setState(485);
identificationVariable();
}
break;
case 3:
_localctx = new FromValuesListContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(487);
entityName();
setState(488);
match(LP);
setState(489);
match(VALUES);
setState(490);
fromItemValuesItem();
setState(495);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(491);
match(COMMA);
setState(492);
fromItemValuesItem();
}
}
setState(497);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(498);
match(RP);
setState(499);
identificationVariable();
}
break;
case 4:
_localctx = new FromSimpleValuesLikeEntityAttributeContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(501);
identifier();
setState(502);
match(LP);
setState(503);
match(INTEGER_LITERAL);
setState(504);
match(VALUES);
setState(507);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LIKE) {
{
setState(505);
match(LIKE);
setState(506);
entityName();
}
}
setState(509);
match(RP);
setState(510);
identificationVariable();
}
break;
case 5:
_localctx = new FromSimpleValuesListContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(512);
identifier();
setState(513);
match(LP);
setState(514);
match(VALUES);
setState(515);
fromItemValuesItem();
setState(520);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(516);
match(COMMA);
setState(517);
fromItemValuesItem();
}
}
setState(522);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(523);
match(RP);
setState(524);
identificationVariable();
}
break;
case 6:
_localctx = new FromOldOrNewContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(526);
_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(527);
match(LP);
setState(528);
entityName();
setState(529);
match(RP);
setState(531);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==IDENTIFIER) {
{
setState(530);
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 plainLiteral() {
return getRuleContexts(PlainLiteralContext.class);
}
public PlainLiteralContext plainLiteral(int i) {
return getRuleContext(PlainLiteralContext.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(535);
match(LP);
setState(536);
plainLiteral();
setState(541);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(537);
match(COMMA);
setState(538);
plainLiteral();
}
}
setState(543);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(544);
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(546);
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(551);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AS:
enterOuterAlt(_localctx, 1);
{
{
setState(548);
match(AS);
setState(549);
identifier();
}
}
break;
case IDENTIFIER:
enterOuterAlt(_localctx, 2);
{
setState(550);
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(553);
match(CROSS);
setState(554);
match(JOIN);
setState(555);
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(557);
match(COMMA);
setState(558);
match(IN);
setState(559);
match(LP);
setState(560);
path();
setState(561);
match(RP);
setState(563);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==IDENTIFIER) {
{
setState(562);
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(565);
joinTypeQualifier();
setState(566);
match(JOIN);
setState(568);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) {
case 1:
{
setState(567);
match(FETCH);
}
break;
}
setState(570);
joinItemElement();
setState(572);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ON) {
{
setState(571);
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(574);
joinTypeQualifier();
setState(575);
match(JOIN);
setState(576);
joinItemElement();
setState(578);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ON) {
{
setState(577);
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(582);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(580);
fromItemElement();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(581);
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(584);
match(TREAT);
setState(585);
match(LP);
setState(586);
path();
setState(587);
match(AS);
setState(588);
entityName();
setState(589);
match(RP);
setState(592);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==DOT) {
{
setState(590);
match(DOT);
setState(591);
generalSubpath();
}
}
setState(595);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==IDENTIFIER) {
{
setState(594);
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(606);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,71,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(598);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INNER) {
{
setState(597);
match(INNER);
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(601);
_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(600);
_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(604);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==OUTER) {
{
setState(603);
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(608);
match(ON);
setState(609);
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(611);
match(SELECT);
setState(613);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) {
case 1:
{
setState(612);
match(DISTINCT);
}
break;
}
setState(615);
selectItem();
setState(620);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(616);
match(COMMA);
setState(617);
selectItem();
}
}
setState(622);
_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(623);
match(SELECT);
setState(625);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,74,_ctx) ) {
case 1:
{
setState(624);
match(DISTINCT);
}
break;
}
setState(627);
subQuerySelectItem();
setState(632);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(628);
match(COMMA);
setState(629);
subQuerySelectItem();
}
}
setState(634);
_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(635);
selectExpression();
setState(637);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS || _la==IDENTIFIER) {
{
setState(636);
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(639);
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(645);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(641);
constructorExpression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(642);
objectSelectExpression();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(643);
mapEntrySelectExpression();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(644);
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(650);
_errHandler.sync(this);
switch (_input.LA(1)) {
case AS:
enterOuterAlt(_localctx, 1);
{
{
setState(647);
match(AS);
setState(648);
identifier();
}
}
break;
case IDENTIFIER:
enterOuterAlt(_localctx, 2);
{
setState(649);
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(652);
match(ENTRY);
setState(653);
match(LP);
setState(654);
path();
setState(655);
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(657);
match(NEW);
setState(658);
simpleSubpath();
setState(659);
match(LP);
setState(660);
constructorItem();
setState(665);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(661);
match(COMMA);
setState(662);
constructorItem();
}
}
setState(667);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(668);
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(670);
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(672);
match(OBJECT);
setState(673);
match(LP);
setState(674);
identifier();
setState(675);
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(683);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,81,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(677);
qualifiedPath();
setState(680);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) {
case 1:
{
setState(678);
match(DOT);
setState(679);
generalSubpath();
}
break;
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(682);
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(685);
identifier();
setState(686);
match(LP);
setState(695);
_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(687);
expression(0);
setState(692);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(688);
match(COMMA);
setState(689);
expression(0);
}
}
setState(694);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(697);
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(699);
match(OUTER);
setState(700);
match(LP);
setState(703);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,84,_ctx) ) {
case 1:
{
setState(701);
simpleSubpath();
}
break;
case 2:
{
setState(702);
macroPath();
}
break;
}
setState(705);
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(724);
_errHandler.sync(this);
switch (_input.LA(1)) {
case TREAT:
_localctx = new TreatPathContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(707);
match(TREAT);
setState(708);
match(LP);
setState(709);
path();
setState(710);
match(AS);
setState(711);
entityName();
setState(712);
match(RP);
}
break;
case VALUE:
_localctx = new ValuePathContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(714);
match(VALUE);
setState(715);
match(LP);
setState(716);
path();
setState(717);
match(RP);
}
break;
case KEY:
_localctx = new MapKeyPathContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(719);
match(KEY);
setState(720);
match(LP);
setState(721);
path();
setState(722);
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(726);
identifier();
setState(731);
_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(727);
match(DOT);
setState(728);
identifierNonStart();
}
}
}
setState(733);
_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(734);
simpleSubpath();
setState(742);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) {
case 1:
{
setState(735);
match(LB);
setState(736);
predicateOrExpression();
setState(737);
match(RB);
setState(740);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) {
case 1:
{
setState(738);
match(DOT);
setState(739);
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(744);
match(GROUP);
setState(745);
match(BY);
setState(746);
groupingValue();
setState(751);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(747);
match(COMMA);
setState(748);
groupingValue();
}
}
setState(753);
_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(754);
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(756);
match(HAVING);
setState(757);
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(759);
match(ORDER);
setState(760);
match(BY);
setState(761);
orderByItem();
setState(766);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(762);
match(COMMA);
setState(763);
orderByItem();
}
}
setState(768);
_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(769);
expression(0);
setState(772);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==COLLATE) {
{
setState(770);
match(COLLATE);
setState(771);
match(STRING_LITERAL);
}
}
setState(779);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASC || _la==DESC) {
{
setState(774);
_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(777);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NULLS) {
{
setState(775);
match(NULLS);
setState(776);
_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(781);
match(WINDOW);
setState(782);
identifier();
setState(783);
match(AS);
setState(784);
match(LP);
setState(785);
windowDefinition();
setState(786);
match(RP);
setState(796);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(787);
match(COMMA);
setState(788);
identifier();
setState(789);
match(AS);
setState(790);
match(LP);
setState(791);
windowDefinition();
setState(792);
match(RP);
}
}
setState(798);
_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(800);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,95,_ctx) ) {
case 1:
{
setState(799);
identifier();
}
break;
}
setState(803);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PARTITION) {
{
setState(802);
partitionByClause();
}
}
setState(806);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ORDER) {
{
setState(805);
orderByClause();
}
}
setState(809);
_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(808);
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(811);
match(PARTITION);
setState(812);
match(BY);
setState(813);
groupingValue();
setState(818);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(814);
match(COMMA);
setState(815);
groupingValue();
}
}
setState(820);
_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(834);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,102,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(821);
((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(822);
frameStart();
setState(824);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXCLUDE) {
{
setState(823);
frameExclusionClause();
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(826);
((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(827);
match(BETWEEN);
setState(828);
frameStart();
setState(829);
match(AND);
setState(830);
frameEnd();
setState(832);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EXCLUDE) {
{
setState(831);
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(846);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,103,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(836);
match(UNBOUNDED);
setState(837);
match(PRECEDING);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(838);
parameterOrNumberLiteral();
setState(839);
match(PRECEDING);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(841);
match(CURRENT);
setState(842);
match(ROW);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(843);
parameterOrNumberLiteral();
setState(844);
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(860);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,104,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(848);
match(UNBOUNDED);
setState(849);
match(PRECEDING);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(850);
parameterOrNumberLiteral();
setState(851);
match(PRECEDING);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(853);
match(CURRENT);
setState(854);
match(ROW);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(855);
parameterOrNumberLiteral();
setState(856);
match(FOLLOWING);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(858);
match(UNBOUNDED);
setState(859);
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(872);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,105,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(862);
match(EXCLUDE);
setState(863);
match(CURRENT);
setState(864);
match(ROW);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(865);
match(EXCLUDE);
setState(866);
match(GROUP);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(867);
match(EXCLUDE);
setState(868);
match(TIES);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(869);
match(EXCLUDE);
setState(870);
match(NO);
setState(871);
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(874);
match(LIMIT);
setState(875);
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(884);
_errHandler.sync(this);
switch (_input.LA(1)) {
case OFFSET:
enterOuterAlt(_localctx, 1);
{
setState(877);
match(OFFSET);
setState(878);
parameterOrNumberLiteral();
}
break;
case JUMP:
enterOuterAlt(_localctx, 2);
{
setState(879);
match(JUMP);
setState(880);
match(TO);
setState(881);
match(PAGE);
setState(882);
match(CONTAINING);
setState(883);
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(888);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COLON:
case QUESTION_MARK:
enterOuterAlt(_localctx, 1);
{
setState(886);
parameter();
}
break;
case INTEGER_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(887);
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(904);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,109,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(890);
_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(891);
parameterOrLiteral();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(892);
_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(893);
match(LP);
setState(894);
parameterOrLiteral();
setState(899);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(895);
match(COMMA);
setState(896);
parameterOrLiteral();
}
}
setState(901);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(902);
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 PlainLiteralContext plainLiteral() {
return getRuleContext(PlainLiteralContext.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(908);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COLON:
case QUESTION_MARK:
enterOuterAlt(_localctx, 1);
{
setState(906);
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:
case PLUS:
case MINUS:
enterOuterAlt(_localctx, 2);
{
setState(907);
plainLiteral();
}
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(910);
identifier();
setState(915);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==DOT || _la==DOLLAR) {
{
{
setState(911);
_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(912);
identifierNonStart();
}
}
setState(917);
_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(918);
match(WHERE);
setState(919);
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(961);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,116,_ctx) ) {
case 1:
{
_localctx = new GroupedExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(922);
match(LP);
setState(923);
expression(0);
setState(924);
match(RP);
}
break;
case 2:
{
_localctx = new SimpleCaseExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(926);
match(CASE);
setState(927);
((SimpleCaseExpressionContext)_localctx).operand = expression(0);
setState(929);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(928);
simpleCaseWhen();
}
}
setState(931);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==WHEN );
setState(935);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(933);
match(ELSE);
setState(934);
((SimpleCaseExpressionContext)_localctx).otherwise = expression(0);
}
}
setState(937);
match(END);
}
break;
case 3:
{
_localctx = new GeneralCaseExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(939);
match(CASE);
setState(941);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(940);
searchedCaseWhen();
}
}
setState(943);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==WHEN );
setState(947);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ELSE) {
{
setState(945);
match(ELSE);
setState(946);
expression(0);
}
}
setState(949);
match(END);
}
break;
case 4:
{
_localctx = new LiteralExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(951);
literal();
}
break;
case 5:
{
_localctx = new ParameterExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(952);
parameter();
}
break;
case 6:
{
_localctx = new EntityTypeExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(953);
entityType();
}
break;
case 7:
{
_localctx = new TemporalFunctionExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(954);
((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(955);
path();
}
break;
case 9:
{
_localctx = new FunctionExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(956);
function();
}
break;
case 10:
{
_localctx = new UnaryMinusExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(957);
match(MINUS);
setState(958);
expression(5);
}
break;
case 11:
{
_localctx = new UnaryPlusExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(959);
match(PLUS);
setState(960);
expression(4);
}
break;
}
_ctx.stop = _input.LT(-1);
setState(974);
_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(972);
_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(963);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(964);
_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(965);
((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(966);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(967);
_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(968);
((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(969);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(970);
match(DOUBLE_PIPE);
setState(971);
((ConcatenationExpressionContext)_localctx).rhs = expression(2);
}
break;
}
}
}
setState(976);
_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(1139);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) {
case 1:
{
_localctx = new GroupedPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(978);
match(LP);
setState(979);
predicate(0);
setState(980);
match(RP);
}
break;
case 2:
{
_localctx = new NegatedPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(982);
match(NOT);
setState(983);
predicate(22);
}
break;
case 3:
{
_localctx = new ExistsSimplePredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(985);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(984);
match(NOT);
}
}
setState(987);
match(EXISTS);
setState(993);
_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(988);
identifier();
}
break;
case LP:
{
setState(989);
match(LP);
setState(990);
identifier();
setState(991);
match(RP);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 4:
{
_localctx = new IsNullPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(995);
expression(0);
setState(996);
match(IS);
setState(998);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(997);
match(NOT);
}
}
setState(1000);
match(NULL);
}
break;
case 5:
{
_localctx = new IsEmptyPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1002);
expression(0);
setState(1003);
match(IS);
setState(1005);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1004);
match(NOT);
}
}
setState(1007);
match(EMPTY);
}
break;
case 6:
{
_localctx = new QuantifiedSimpleEqualityPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1009);
expression(0);
setState(1010);
match(EQUAL);
setState(1012);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,123,_ctx) ) {
case 1:
{
setState(1011);
((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(1019);
_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(1014);
identifier();
}
break;
case LP:
{
{
setState(1015);
match(LP);
setState(1016);
identifier();
setState(1017);
match(RP);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 7:
{
_localctx = new QuantifiedSimpleInequalityPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1021);
expression(0);
setState(1022);
match(NOT_EQUAL);
setState(1024);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) {
case 1:
{
setState(1023);
((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(1031);
_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(1026);
identifier();
}
break;
case LP:
{
{
setState(1027);
match(LP);
setState(1028);
identifier();
setState(1029);
match(RP);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 8:
{
_localctx = new QuantifiedSimpleGreaterThanPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1033);
expression(0);
setState(1034);
match(GREATER);
setState(1036);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) {
case 1:
{
setState(1035);
((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(1043);
_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(1038);
identifier();
}
break;
case LP:
{
{
setState(1039);
match(LP);
setState(1040);
identifier();
setState(1041);
match(RP);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 9:
{
_localctx = new QuantifiedSimpleGreaterThanOrEqualPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1045);
expression(0);
setState(1046);
match(GREATER_EQUAL);
setState(1048);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) {
case 1:
{
setState(1047);
((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(1055);
_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(1050);
identifier();
}
break;
case LP:
{
{
setState(1051);
match(LP);
setState(1052);
identifier();
setState(1053);
match(RP);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 10:
{
_localctx = new QuantifiedSimpleLessThanPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1057);
expression(0);
setState(1058);
match(LESS);
setState(1060);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) {
case 1:
{
setState(1059);
((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(1067);
_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(1062);
identifier();
}
break;
case LP:
{
{
setState(1063);
match(LP);
setState(1064);
identifier();
setState(1065);
match(RP);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 11:
{
_localctx = new QuantifiedSimpleLessThanOrEqualPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1069);
expression(0);
setState(1070);
match(LESS_EQUAL);
setState(1072);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,133,_ctx) ) {
case 1:
{
setState(1071);
((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(1079);
_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(1074);
identifier();
}
break;
case LP:
{
{
setState(1075);
match(LP);
setState(1076);
identifier();
setState(1077);
match(RP);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 12:
{
_localctx = new EqualityPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1081);
((EqualityPredicateContext)_localctx).lhs = expression(0);
setState(1082);
match(EQUAL);
setState(1083);
((EqualityPredicateContext)_localctx).rhs = expression(0);
}
break;
case 13:
{
_localctx = new InequalityPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1085);
((InequalityPredicateContext)_localctx).lhs = expression(0);
setState(1086);
match(NOT_EQUAL);
setState(1087);
((InequalityPredicateContext)_localctx).rhs = expression(0);
}
break;
case 14:
{
_localctx = new GreaterThanPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1089);
((GreaterThanPredicateContext)_localctx).lhs = expression(0);
setState(1090);
match(GREATER);
setState(1091);
((GreaterThanPredicateContext)_localctx).rhs = expression(0);
}
break;
case 15:
{
_localctx = new GreaterThanOrEqualPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1093);
((GreaterThanOrEqualPredicateContext)_localctx).lhs = expression(0);
setState(1094);
match(GREATER_EQUAL);
setState(1095);
((GreaterThanOrEqualPredicateContext)_localctx).rhs = expression(0);
}
break;
case 16:
{
_localctx = new LessThanPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1097);
((LessThanPredicateContext)_localctx).lhs = expression(0);
setState(1098);
match(LESS);
setState(1099);
((LessThanPredicateContext)_localctx).rhs = expression(0);
}
break;
case 17:
{
_localctx = new LessThanOrEqualPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1101);
((LessThanOrEqualPredicateContext)_localctx).lhs = expression(0);
setState(1102);
match(LESS_EQUAL);
setState(1103);
((LessThanOrEqualPredicateContext)_localctx).rhs = expression(0);
}
break;
case 18:
{
_localctx = new InPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1105);
expression(0);
setState(1107);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1106);
match(NOT);
}
}
setState(1109);
match(IN);
setState(1110);
inList();
}
break;
case 19:
{
_localctx = new BetweenPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1112);
((BetweenPredicateContext)_localctx).lhs = expression(0);
setState(1114);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1113);
match(NOT);
}
}
setState(1116);
match(BETWEEN);
setState(1117);
((BetweenPredicateContext)_localctx).start = expression(0);
setState(1118);
match(AND);
setState(1119);
((BetweenPredicateContext)_localctx).end = expression(0);
}
break;
case 20:
{
_localctx = new LikePredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1121);
((LikePredicateContext)_localctx).lhs = expression(0);
setState(1123);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1122);
match(NOT);
}
}
setState(1125);
match(LIKE);
setState(1126);
((LikePredicateContext)_localctx).like = expression(0);
setState(1129);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) {
case 1:
{
setState(1127);
match(ESCAPE);
setState(1128);
((LikePredicateContext)_localctx).escape = expression(0);
}
break;
}
}
break;
case 21:
{
_localctx = new MemberOfPredicateContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(1131);
expression(0);
setState(1133);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(1132);
match(NOT);
}
}
setState(1135);
match(MEMBER);
setState(1136);
match(OF);
setState(1137);
path();
}
break;
}
_ctx.stop = _input.LT(-1);
setState(1149);
_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(1147);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,141,_ctx) ) {
case 1:
{
_localctx = new AndPredicateContext(new PredicateContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_predicate);
setState(1141);
if (!(precpred(_ctx, 21))) throw new FailedPredicateException(this, "precpred(_ctx, 21)");
setState(1142);
match(AND);
setState(1143);
predicate(22);
}
break;
case 2:
{
_localctx = new OrPredicateContext(new PredicateContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_predicate);
setState(1144);
if (!(precpred(_ctx, 20))) throw new FailedPredicateException(this, "precpred(_ctx, 20)");
setState(1145);
match(OR);
setState(1146);
predicate(21);
}
break;
}
}
}
setState(1151);
_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(1154);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1152);
predicate(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1153);
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(1168);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,145,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1156);
match(LP);
setState(1157);
expression(0);
setState(1162);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1158);
match(COMMA);
setState(1159);
expression(0);
}
}
setState(1164);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1165);
match(RP);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1167);
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(1170);
match(TYPE);
setState(1171);
match(LP);
setState(1174);
_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(1172);
path();
}
break;
case COLON:
case QUESTION_MARK:
{
setState(1173);
parameter();
}
break;
default:
throw new NoViableAltException(this);
}
setState(1176);
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(1178);
match(WHEN);
setState(1179);
((SimpleCaseWhenContext)_localctx).when = expression(0);
setState(1180);
match(THEN);
setState(1181);
((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(1183);
match(WHEN);
setState(1184);
predicate(0);
setState(1185);
match(THEN);
setState(1186);
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(1202);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING_LITERAL:
enterOuterAlt(_localctx, 1);
{
setState(1188);
match(STRING_LITERAL);
}
break;
case CHARACTER_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(1189);
match(CHARACTER_LITERAL);
}
break;
case INTEGER_LITERAL:
enterOuterAlt(_localctx, 3);
{
setState(1190);
match(INTEGER_LITERAL);
}
break;
case LONG_LITERAL:
enterOuterAlt(_localctx, 4);
{
setState(1191);
match(LONG_LITERAL);
}
break;
case BIG_INTEGER_LITERAL:
enterOuterAlt(_localctx, 5);
{
setState(1192);
match(BIG_INTEGER_LITERAL);
}
break;
case FLOAT_LITERAL:
enterOuterAlt(_localctx, 6);
{
setState(1193);
match(FLOAT_LITERAL);
}
break;
case DOUBLE_LITERAL:
enterOuterAlt(_localctx, 7);
{
setState(1194);
match(DOUBLE_LITERAL);
}
break;
case BIG_DECIMAL_LITERAL:
enterOuterAlt(_localctx, 8);
{
setState(1195);
match(BIG_DECIMAL_LITERAL);
}
break;
case NULL:
enterOuterAlt(_localctx, 9);
{
setState(1196);
match(NULL);
}
break;
case TRUE:
enterOuterAlt(_localctx, 10);
{
setState(1197);
match(TRUE);
}
break;
case FALSE:
enterOuterAlt(_localctx, 11);
{
setState(1198);
match(FALSE);
}
break;
case TIMESTAMP_ESCAPE_START:
enterOuterAlt(_localctx, 12);
{
setState(1199);
timestampLiteral();
}
break;
case DATE_ESCAPE_START:
enterOuterAlt(_localctx, 13);
{
setState(1200);
dateLiteral();
}
break;
case TIME_ESCAPE_START:
enterOuterAlt(_localctx, 14);
{
setState(1201);
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 PlainLiteralContext extends ParserRuleContext {
public TerminalNode STRING_LITERAL() { return getToken(JPQLNextParser.STRING_LITERAL, 0); }
public TerminalNode CHARACTER_LITERAL() { return getToken(JPQLNextParser.CHARACTER_LITERAL, 0); }
public PlainNumericLiteralContext plainNumericLiteral() {
return getRuleContext(PlainNumericLiteralContext.class,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 PlainLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_plainLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterPlainLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitPlainLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitPlainLiteral(this);
else return visitor.visitChildren(this);
}
}
public final PlainLiteralContext plainLiteral() throws RecognitionException {
PlainLiteralContext _localctx = new PlainLiteralContext(_ctx, getState());
enterRule(_localctx, 158, RULE_plainLiteral);
try {
setState(1213);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING_LITERAL:
enterOuterAlt(_localctx, 1);
{
setState(1204);
match(STRING_LITERAL);
}
break;
case CHARACTER_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(1205);
match(CHARACTER_LITERAL);
}
break;
case INTEGER_LITERAL:
case BIG_INTEGER_LITERAL:
case LONG_LITERAL:
case FLOAT_LITERAL:
case DOUBLE_LITERAL:
case BIG_DECIMAL_LITERAL:
case PLUS:
case MINUS:
enterOuterAlt(_localctx, 3);
{
setState(1206);
plainNumericLiteral();
}
break;
case NULL:
enterOuterAlt(_localctx, 4);
{
setState(1207);
match(NULL);
}
break;
case TRUE:
enterOuterAlt(_localctx, 5);
{
setState(1208);
match(TRUE);
}
break;
case FALSE:
enterOuterAlt(_localctx, 6);
{
setState(1209);
match(FALSE);
}
break;
case TIMESTAMP_ESCAPE_START:
enterOuterAlt(_localctx, 7);
{
setState(1210);
timestampLiteral();
}
break;
case DATE_ESCAPE_START:
enterOuterAlt(_localctx, 8);
{
setState(1211);
dateLiteral();
}
break;
case TIME_ESCAPE_START:
enterOuterAlt(_localctx, 9);
{
setState(1212);
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 PlainNumericLiteralContext extends ParserRuleContext {
public TerminalNode INTEGER_LITERAL() { return getToken(JPQLNextParser.INTEGER_LITERAL, 0); }
public TerminalNode PLUS() { return getToken(JPQLNextParser.PLUS, 0); }
public TerminalNode MINUS() { return getToken(JPQLNextParser.MINUS, 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 PlainNumericLiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_plainNumericLiteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).enterPlainNumericLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof JPQLNextParserListener ) ((JPQLNextParserListener)listener).exitPlainNumericLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof JPQLNextParserVisitor ) return ((JPQLNextParserVisitor)visitor).visitPlainNumericLiteral(this);
else return visitor.visitChildren(this);
}
}
public final PlainNumericLiteralContext plainNumericLiteral() throws RecognitionException {
PlainNumericLiteralContext _localctx = new PlainNumericLiteralContext(_ctx, getState());
enterRule(_localctx, 160, RULE_plainNumericLiteral);
int _la;
try {
setState(1239);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,155,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1216);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PLUS || _la==MINUS) {
{
setState(1215);
_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(1218);
match(INTEGER_LITERAL);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1220);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PLUS || _la==MINUS) {
{
setState(1219);
_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(1222);
match(LONG_LITERAL);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1224);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PLUS || _la==MINUS) {
{
setState(1223);
_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(1226);
match(BIG_INTEGER_LITERAL);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1228);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PLUS || _la==MINUS) {
{
setState(1227);
_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(1230);
match(FLOAT_LITERAL);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1232);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PLUS || _la==MINUS) {
{
setState(1231);
_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(1234);
match(DOUBLE_LITERAL);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(1236);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PLUS || _la==MINUS) {
{
setState(1235);
_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(1238);
match(BIG_DECIMAL_LITERAL);
}
break;
}
}
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, 162, RULE_timestampLiteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(1241);
match(TIMESTAMP_ESCAPE_START);
setState(1242);
dateTimeLiteralText();
setState(1243);
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, 164, RULE_dateLiteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(1245);
match(DATE_ESCAPE_START);
setState(1246);
dateTimeLiteralText();
setState(1247);
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, 166, RULE_timeLiteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(1249);
match(TIME_ESCAPE_START);
setState(1250);
dateTimeLiteralText();
setState(1251);
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, 168, RULE_dateTimeLiteralText);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1253);
_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, 170, RULE_parameter);
try {
setState(1259);
_errHandler.sync(this);
switch (_input.LA(1)) {
case COLON:
_localctx = new NamedParameterContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1255);
match(COLON);
setState(1256);
identifier();
}
break;
case QUESTION_MARK:
_localctx = new PositionalParameterContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1257);
match(QUESTION_MARK);
setState(1258);
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, 172, RULE_function);
int _la;
try {
setState(1348);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,173,_ctx) ) {
case 1:
_localctx = new TrimFunctionContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1261);
match(TRIM);
setState(1262);
match(LP);
setState(1264);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) {
case 1:
{
setState(1263);
trimSpecification();
}
break;
}
setState(1267);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,158,_ctx) ) {
case 1:
{
setState(1266);
trimCharacter();
}
break;
}
setState(1270);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) {
case 1:
{
setState(1269);
match(FROM);
}
break;
}
setState(1272);
expression(0);
setState(1273);
match(RP);
}
break;
case 2:
_localctx = new TemporalFunctionContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1275);
((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(1278);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,160,_ctx) ) {
case 1:
{
setState(1276);
match(LP);
setState(1277);
match(RP);
}
break;
}
}
break;
case 3:
_localctx = new CountFunctionContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(1280);
match(COUNT);
setState(1281);
match(LP);
setState(1287);
_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(1283);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,161,_ctx) ) {
case 1:
{
setState(1282);
match(DISTINCT);
}
break;
}
setState(1285);
expression(0);
}
}
break;
case ASTERISK:
{
setState(1286);
match(ASTERISK);
}
break;
default:
throw new NoViableAltException(this);
}
setState(1289);
match(RP);
setState(1295);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,163,_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,165,_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);
((CountFunctionContext)_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;
case 4:
_localctx = new GenericFunctionInvocationContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(1307);
((GenericFunctionInvocationContext)_localctx).name = identifier();
setState(1308);
match(LP);
setState(1310);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,166,_ctx) ) {
case 1:
{
setState(1309);
match(DISTINCT);
}
break;
}
setState(1320);
_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(1312);
expression(0);
setState(1317);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1313);
match(COMMA);
setState(1314);
expression(0);
}
}
setState(1319);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(1322);
match(RP);
setState(1329);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) {
case 1:
{
setState(1323);
match(WITHIN);
setState(1324);
match(GROUP);
setState(1325);
match(LP);
setState(1326);
orderByClause();
setState(1327);
match(RP);
}
break;
}
setState(1336);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,170,_ctx) ) {
case 1:
{
setState(1331);
match(FILTER);
setState(1332);
match(LP);
setState(1333);
whereClause();
setState(1334);
match(RP);
}
break;
}
setState(1346);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,172,_ctx) ) {
case 1:
{
setState(1338);
match(OVER);
setState(1344);
_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(1339);
((GenericFunctionInvocationContext)_localctx).windowName = identifier();
}
break;
case LP:
{
{
setState(1340);
match(LP);
setState(1341);
windowDefinition();
setState(1342);
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, 174, RULE_trimSpecification);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1350);
_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, 176, RULE_trimCharacter);
try {
setState(1355);
_errHandler.sync(this);
switch (_input.LA(1)) {
case CHARACTER_LITERAL:
enterOuterAlt(_localctx, 1);
{
setState(1352);
match(CHARACTER_LITERAL);
}
break;
case STRING_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(1353);
match(STRING_LITERAL);
}
break;
case COLON:
case QUESTION_MARK:
enterOuterAlt(_localctx, 3);
{
setState(1354);
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, 178, RULE_identifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1357);
_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, 180, RULE_identifierNonStart);
try {
setState(1362);
_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(1359);
identifier();
}
break;
case TRUE:
enterOuterAlt(_localctx, 2);
{
setState(1360);
match(TRUE);
}
break;
case FALSE:
enterOuterAlt(_localctx, 3);
{
setState(1361);
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\u0557\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\4[\t[\4\\\t\\\3\2\3\2\5\2\u00bb\n"+
"\2\3\2\5\2\u00be\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\u00cf\n\4\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\6\5\6\u00da"+
"\n\6\3\7\3\7\3\7\3\7\5\7\u00e0\n\7\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\7\t"+
"\u00ea\n\t\f\t\16\t\u00ed\13\t\3\t\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n"+
"\5\n\u00f9\n\n\3\13\3\13\3\13\3\13\3\13\3\13\5\13\u0101\n\13\3\13\3\13"+
"\5\13\u0105\n\13\3\f\3\f\3\f\3\f\3\f\3\f\5\f\u010d\n\f\3\f\3\f\5\f\u0111"+
"\n\f\3\r\3\r\3\r\5\r\u0116\n\r\3\r\5\r\u0119\n\r\3\r\5\r\u011c\n\r\3\r"+
"\5\r\u011f\n\r\3\r\3\r\5\r\u0123\n\r\3\r\5\r\u0126\n\r\3\r\5\r\u0129\n"+
"\r\3\16\3\16\3\16\5\16\u012e\n\16\3\16\5\16\u0131\n\16\3\17\3\17\5\17"+
"\u0135\n\17\3\17\3\17\3\17\3\17\3\17\5\17\u013c\n\17\3\17\5\17\u013f\n"+
"\17\3\17\5\17\u0142\n\17\3\17\5\17\u0145\n\17\3\20\3\20\5\20\u0149\n\20"+
"\3\20\3\20\3\20\3\20\3\20\5\20\u0150\n\20\3\20\5\20\u0153\n\20\3\20\3"+
"\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\7\20\u015e\n\20\f\20\16\20\u0161"+
"\13\20\3\20\5\20\u0164\n\20\3\20\5\20\u0167\n\20\3\21\3\21\3\21\3\21\3"+
"\21\3\21\3\21\5\21\u0170\n\21\3\21\3\21\3\21\5\21\u0175\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\u0182\n\22\3\23\3\23"+
"\3\23\3\23\7\23\u0188\n\23\f\23\16\23\u018b\13\23\3\23\3\23\3\24\3\24"+
"\3\24\3\24\7\24\u0193\n\24\f\24\16\24\u0196\13\24\3\25\5\25\u0199\n\25"+
"\3\25\3\25\5\25\u019d\n\25\3\25\5\25\u01a0\n\25\3\25\5\25\u01a3\n\25\3"+
"\25\5\25\u01a6\n\25\3\25\5\25\u01a9\n\25\3\25\3\25\5\25\u01ad\n\25\3\25"+
"\5\25\u01b0\n\25\3\25\5\25\u01b3\n\25\3\25\5\25\u01b6\n\25\3\25\5\25\u01b9"+
"\n\25\3\26\3\26\3\26\3\26\7\26\u01bf\n\26\f\26\16\26\u01c2\13\26\3\27"+
"\3\27\3\27\3\27\7\27\u01c8\n\27\f\27\16\27\u01cb\13\27\3\30\3\30\3\30"+
"\3\30\7\30\u01d1\n\30\f\30\16\30\u01d4\13\30\3\31\3\31\3\31\3\31\7\31"+
"\u01da\n\31\f\31\16\31\u01dd\13\31\3\32\3\32\5\32\u01e1\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\u01f0\n\32"+
"\f\32\16\32\u01f3\13\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\5"+
"\32\u01fe\n\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\7\32\u0209"+
"\n\32\f\32\16\32\u020c\13\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\5"+
"\32\u0216\n\32\5\32\u0218\n\32\3\33\3\33\3\33\3\33\7\33\u021e\n\33\f\33"+
"\16\33\u0221\13\33\3\33\3\33\3\34\3\34\3\35\3\35\3\35\5\35\u022a\n\35"+
"\3\36\3\36\3\36\3\36\3\37\3\37\3\37\3\37\3\37\3\37\5\37\u0236\n\37\3 "+
"\3 \3 \5 \u023b\n \3 \3 \5 \u023f\n \3!\3!\3!\3!\5!\u0245\n!\3\"\3\"\5"+
"\"\u0249\n\"\3#\3#\3#\3#\3#\3#\3#\3#\5#\u0253\n#\3#\5#\u0256\n#\3$\5$"+
"\u0259\n$\3$\5$\u025c\n$\3$\5$\u025f\n$\5$\u0261\n$\3%\3%\3%\3&\3&\5&"+
"\u0268\n&\3&\3&\3&\7&\u026d\n&\f&\16&\u0270\13&\3\'\3\'\5\'\u0274\n\'"+
"\3\'\3\'\3\'\7\'\u0279\n\'\f\'\16\'\u027c\13\'\3(\3(\5(\u0280\n(\3)\3"+
")\3*\3*\3*\3*\5*\u0288\n*\3+\3+\3+\5+\u028d\n+\3,\3,\3,\3,\3,\3-\3-\3"+
"-\3-\3-\3-\7-\u029a\n-\f-\16-\u029d\13-\3-\3-\3.\3.\3/\3/\3/\3/\3/\3\60"+
"\3\60\3\60\5\60\u02ab\n\60\3\60\5\60\u02ae\n\60\3\61\3\61\3\61\3\61\3"+
"\61\7\61\u02b5\n\61\f\61\16\61\u02b8\13\61\5\61\u02ba\n\61\3\61\3\61\3"+
"\62\3\62\3\62\3\62\5\62\u02c2\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\u02d7"+
"\n\63\3\64\3\64\3\64\7\64\u02dc\n\64\f\64\16\64\u02df\13\64\3\65\3\65"+
"\3\65\3\65\3\65\3\65\5\65\u02e7\n\65\5\65\u02e9\n\65\3\66\3\66\3\66\3"+
"\66\3\66\7\66\u02f0\n\66\f\66\16\66\u02f3\13\66\3\67\3\67\38\38\38\39"+
"\39\39\39\39\79\u02ff\n9\f9\169\u0302\139\3:\3:\3:\5:\u0307\n:\3:\3:\3"+
":\5:\u030c\n:\5:\u030e\n:\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\7;\u031d"+
"\n;\f;\16;\u0320\13;\3<\5<\u0323\n<\3<\5<\u0326\n<\3<\5<\u0329\n<\3<\5"+
"<\u032c\n<\3=\3=\3=\3=\3=\7=\u0333\n=\f=\16=\u0336\13=\3>\3>\3>\5>\u033b"+
"\n>\3>\3>\3>\3>\3>\3>\5>\u0343\n>\5>\u0345\n>\3?\3?\3?\3?\3?\3?\3?\3?"+
"\3?\3?\5?\u0351\n?\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\3@\5@\u035f\n@\3A"+
"\3A\3A\3A\3A\3A\3A\3A\3A\3A\5A\u036b\nA\3B\3B\3B\3C\3C\3C\3C\3C\3C\3C"+
"\5C\u0377\nC\3D\3D\5D\u037b\nD\3E\3E\3E\3E\3E\3E\3E\7E\u0384\nE\fE\16"+
"E\u0387\13E\3E\3E\5E\u038b\nE\3F\3F\5F\u038f\nF\3G\3G\3G\7G\u0394\nG\f"+
"G\16G\u0397\13G\3H\3H\3H\3I\3I\3I\3I\3I\3I\3I\3I\6I\u03a4\nI\rI\16I\u03a5"+
"\3I\3I\5I\u03aa\nI\3I\3I\3I\3I\6I\u03b0\nI\rI\16I\u03b1\3I\3I\5I\u03b6"+
"\nI\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\3I\5I\u03c4\nI\3I\3I\3I\3I\3I\3I"+
"\3I\3I\3I\7I\u03cf\nI\fI\16I\u03d2\13I\3J\3J\3J\3J\3J\3J\3J\3J\5J\u03dc"+
"\nJ\3J\3J\3J\3J\3J\3J\5J\u03e4\nJ\3J\3J\3J\5J\u03e9\nJ\3J\3J\3J\3J\3J"+
"\5J\u03f0\nJ\3J\3J\3J\3J\3J\5J\u03f7\nJ\3J\3J\3J\3J\3J\5J\u03fe\nJ\3J"+
"\3J\3J\5J\u0403\nJ\3J\3J\3J\3J\3J\5J\u040a\nJ\3J\3J\3J\5J\u040f\nJ\3J"+
"\3J\3J\3J\3J\5J\u0416\nJ\3J\3J\3J\5J\u041b\nJ\3J\3J\3J\3J\3J\5J\u0422"+
"\nJ\3J\3J\3J\5J\u0427\nJ\3J\3J\3J\3J\3J\5J\u042e\nJ\3J\3J\3J\5J\u0433"+
"\nJ\3J\3J\3J\3J\3J\5J\u043a\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\u0456\nJ\3J\3J\3J\3J\3J\5J"+
"\u045d\nJ\3J\3J\3J\3J\3J\3J\3J\5J\u0466\nJ\3J\3J\3J\3J\5J\u046c\nJ\3J"+
"\3J\5J\u0470\nJ\3J\3J\3J\3J\5J\u0476\nJ\3J\3J\3J\3J\3J\3J\7J\u047e\nJ"+
"\fJ\16J\u0481\13J\3K\3K\5K\u0485\nK\3L\3L\3L\3L\7L\u048b\nL\fL\16L\u048e"+
"\13L\3L\3L\3L\5L\u0493\nL\3M\3M\3M\3M\5M\u0499\nM\3M\3M\3N\3N\3N\3N\3"+
"N\3O\3O\3O\3O\3O\3P\3P\3P\3P\3P\3P\3P\3P\3P\3P\3P\3P\3P\3P\5P\u04b5\n"+
"P\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\5Q\u04c0\nQ\3R\5R\u04c3\nR\3R\3R\5R\u04c7"+
"\nR\3R\3R\5R\u04cb\nR\3R\3R\5R\u04cf\nR\3R\3R\5R\u04d3\nR\3R\3R\5R\u04d7"+
"\nR\3R\5R\u04da\nR\3S\3S\3S\3S\3T\3T\3T\3T\3U\3U\3U\3U\3V\3V\3W\3W\3W"+
"\3W\5W\u04ee\nW\3X\3X\3X\5X\u04f3\nX\3X\5X\u04f6\nX\3X\5X\u04f9\nX\3X"+
"\3X\3X\3X\3X\3X\5X\u0501\nX\3X\3X\3X\5X\u0506\nX\3X\3X\5X\u050a\nX\3X"+
"\3X\3X\3X\3X\3X\5X\u0512\nX\3X\3X\3X\3X\3X\3X\5X\u051a\nX\5X\u051c\nX"+
"\3X\3X\3X\5X\u0521\nX\3X\3X\3X\7X\u0526\nX\fX\16X\u0529\13X\5X\u052b\n"+
"X\3X\3X\3X\3X\3X\3X\3X\5X\u0534\nX\3X\3X\3X\3X\3X\5X\u053b\nX\3X\3X\3"+
"X\3X\3X\3X\5X\u0543\nX\5X\u0545\nX\5X\u0547\nX\3Y\3Y\3Z\3Z\3Z\5Z\u054e"+
"\nZ\3[\3[\3\\\3\\\3\\\5\\\u0555\n\\\3\\\2\4\u0090\u0092]\2\4\6\b\n\f\16"+
"\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bd"+
"fhjlnprtvxz|~\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\u00b4\u00b6\2\22\5\2((99ii\4\2\r\r\"\"\4\2EE"+
"MM\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\u05f7\2\u00bd"+
"\3\2\2\2\4\u00c2\3\2\2\2\6\u00ce\3\2\2\2\b\u00d0\3\2\2\2\n\u00d9\3\2\2"+
"\2\f\u00df\3\2\2\2\16\u00e1\3\2\2\2\20\u00e4\3\2\2\2\22\u00f8\3\2\2\2"+
"\24\u0104\3\2\2\2\26\u0110\3\2\2\2\30\u0112\3\2\2\2\32\u012a\3\2\2\2\34"+
"\u0132\3\2\2\2\36\u0146\3\2\2\2 \u0168\3\2\2\2\"\u0181\3\2\2\2$\u0183"+
"\3\2\2\2&\u018e\3\2\2\2(\u0198\3\2\2\2*\u01ba\3\2\2\2,\u01c3\3\2\2\2."+
"\u01cc\3\2\2\2\60\u01d5\3\2\2\2\62\u0217\3\2\2\2\64\u0219\3\2\2\2\66\u0224"+
"\3\2\2\28\u0229\3\2\2\2:\u022b\3\2\2\2<\u022f\3\2\2\2>\u0237\3\2\2\2@"+
"\u0240\3\2\2\2B\u0248\3\2\2\2D\u024a\3\2\2\2F\u0260\3\2\2\2H\u0262\3\2"+
"\2\2J\u0265\3\2\2\2L\u0271\3\2\2\2N\u027d\3\2\2\2P\u0281\3\2\2\2R\u0287"+
"\3\2\2\2T\u028c\3\2\2\2V\u028e\3\2\2\2X\u0293\3\2\2\2Z\u02a0\3\2\2\2\\"+
"\u02a2\3\2\2\2^\u02ad\3\2\2\2`\u02af\3\2\2\2b\u02bd\3\2\2\2d\u02d6\3\2"+
"\2\2f\u02d8\3\2\2\2h\u02e0\3\2\2\2j\u02ea\3\2\2\2l\u02f4\3\2\2\2n\u02f6"+
"\3\2\2\2p\u02f9\3\2\2\2r\u0303\3\2\2\2t\u030f\3\2\2\2v\u0322\3\2\2\2x"+
"\u032d\3\2\2\2z\u0344\3\2\2\2|\u0350\3\2\2\2~\u035e\3\2\2\2\u0080\u036a"+
"\3\2\2\2\u0082\u036c\3\2\2\2\u0084\u0376\3\2\2\2\u0086\u037a\3\2\2\2\u0088"+
"\u038a\3\2\2\2\u008a\u038e\3\2\2\2\u008c\u0390\3\2\2\2\u008e\u0398\3\2"+
"\2\2\u0090\u03c3\3\2\2\2\u0092\u0475\3\2\2\2\u0094\u0484\3\2\2\2\u0096"+
"\u0492\3\2\2\2\u0098\u0494\3\2\2\2\u009a\u049c\3\2\2\2\u009c\u04a1\3\2"+
"\2\2\u009e\u04b4\3\2\2\2\u00a0\u04bf\3\2\2\2\u00a2\u04d9\3\2\2\2\u00a4"+
"\u04db\3\2\2\2\u00a6\u04df\3\2\2\2\u00a8\u04e3\3\2\2\2\u00aa\u04e7\3\2"+
"\2\2\u00ac\u04ed\3\2\2\2\u00ae\u0546\3\2\2\2\u00b0\u0548\3\2\2\2\u00b2"+
"\u054d\3\2\2\2\u00b4\u054f\3\2\2\2\u00b6\u0554\3\2\2\2\u00b8\u00ba\7p"+
"\2\2\u00b9\u00bb\7X\2\2\u00ba\u00b9\3\2\2\2\u00ba\u00bb\3\2\2\2\u00bb"+
"\u00bc\3\2\2\2\u00bc\u00be\5\20\t\2\u00bd\u00b8\3\2\2\2\u00bd\u00be\3"+
"\2\2\2\u00be\u00bf\3\2\2\2\u00bf\u00c0\5\22\n\2\u00c0\u00c1\7\2\2\3\u00c1"+
"\3\3\2\2\2\u00c2\u00c3\5R*\2\u00c3\u00c4\7\2\2\3\u00c4\5\3\2\2\2\u00c5"+
"\u00c6\5^\60\2\u00c6\u00c7\7\2\2\3\u00c7\u00cf\3\2\2\2\u00c8\u00c9\5b"+
"\62\2\u00c9\u00ca\7\2\2\3\u00ca\u00cf\3\2\2\2\u00cb\u00cc\5`\61\2\u00cc"+
"\u00cd\7\2\2\3\u00cd\u00cf\3\2\2\2\u00ce\u00c5\3\2\2\2\u00ce\u00c8\3\2"+
"\2\2\u00ce\u00cb\3\2\2\2\u00cf\7\3\2\2\2\u00d0\u00d1\5\u0090I\2\u00d1"+
"\u00d2\7\2\2\3\u00d2\t\3\2\2\2\u00d3\u00d4\5\u008aF\2\u00d4\u00d5\7\2"+
"\2\3\u00d5\u00da\3\2\2\2\u00d6\u00d7\5\u008cG\2\u00d7\u00d8\7\2\2\3\u00d8"+
"\u00da\3\2\2\2\u00d9\u00d3\3\2\2\2\u00d9\u00d6\3\2\2\2\u00da\13\3\2\2"+
"\2\u00db\u00dc\5\u008aF\2\u00dc\u00dd\7\2\2\3\u00dd\u00e0\3\2\2\2\u00de"+
"\u00e0\5\6\4\2\u00df\u00db\3\2\2\2\u00df\u00de\3\2\2\2\u00e0\r\3\2\2\2"+
"\u00e1\u00e2\5\u0092J\2\u00e2\u00e3\7\2\2\3\u00e3\17\3\2\2\2\u00e4\u00e5"+
"\5\66\34\2\u00e5\u00e6\7~\2\2\u00e6\u00eb\5\u00b4[\2\u00e7\u00e8\7|\2"+
"\2\u00e8\u00ea\5\u00b4[\2\u00e9\u00e7\3\2\2\2\u00ea\u00ed\3\2\2\2\u00eb"+
"\u00e9\3\2\2\2\u00eb\u00ec\3\2\2\2\u00ec\u00ee\3\2\2\2\u00ed\u00eb\3\2"+
"\2\2\u00ee\u00ef\7\177\2\2\u00ef\u00f0\7\20\2\2\u00f0\u00f1\7~\2\2\u00f1"+
"\u00f2\5\22\n\2\u00f2\u00f3\7\177\2\2\u00f3\21\3\2\2\2\u00f4\u00f9\5\24"+
"\13\2\u00f5\u00f9\5\36\20\2\u00f6\u00f9\5\34\17\2\u00f7\u00f9\5 \21\2"+
"\u00f8\u00f4\3\2\2\2\u00f8\u00f5\3\2\2\2\u00f8\u00f6\3\2\2\2\u00f8\u00f7"+
"\3\2\2\2\u00f9\23\3\2\2\2\u00fa\u0105\5(\25\2\u00fb\u00fc\7~\2\2\u00fc"+
"\u00fd\5\24\13\2\u00fd\u00fe\7\177\2\2\u00fe\u0100\t\2\2\2\u00ff\u0101"+
"\t\3\2\2\u0100\u00ff\3\2\2\2\u0100\u0101\3\2\2\2\u0101\u0102\3\2\2\2\u0102"+
"\u0103\5\24\13\2\u0103\u0105\3\2\2\2\u0104\u00fa\3\2\2\2\u0104\u00fb\3"+
"\2\2\2\u0105\25\3\2\2\2\u0106\u0111\5\30\r\2\u0107\u0108\7~\2\2\u0108"+
"\u0109\5\26\f\2\u0109\u010a\7\177\2\2\u010a\u010c\t\2\2\2\u010b\u010d"+
"\t\3\2\2\u010c\u010b\3\2\2\2\u010c\u010d\3\2\2\2\u010d\u010e\3\2\2\2\u010e"+
"\u010f\5\26\f\2\u010f\u0111\3\2\2\2\u0110\u0106\3\2\2\2\u0110\u0107\3"+
"\2\2\2\u0111\27\3\2\2\2\u0112\u0113\5L\'\2\u0113\u0115\5,\27\2\u0114\u0116"+
"\5\u0088E\2\u0115\u0114\3\2\2\2\u0115\u0116\3\2\2\2\u0116\u0118\3\2\2"+
"\2\u0117\u0119\5\u008eH\2\u0118\u0117\3\2\2\2\u0118\u0119\3\2\2\2\u0119"+
"\u011b\3\2\2\2\u011a\u011c\5j\66\2\u011b\u011a\3\2\2\2\u011b\u011c\3\2"+
"\2\2\u011c\u011e\3\2\2\2\u011d\u011f\5n8\2\u011e\u011d\3\2\2\2\u011e\u011f"+
"\3\2\2\2\u011f\u0125\3\2\2\2\u0120\u0122\t\2\2\2\u0121\u0123\t\3\2\2\u0122"+
"\u0121\3\2\2\2\u0122\u0123\3\2\2\2\u0123\u0124\3\2\2\2\u0124\u0126\5\26"+
"\f\2\u0125\u0120\3\2\2\2\u0125\u0126\3\2\2\2\u0126\u0128\3\2\2\2\u0127"+
"\u0129\5\32\16\2\u0128\u0127\3\2\2\2\u0128\u0129\3\2\2\2\u0129\31\3\2"+
"\2\2\u012a\u0130\5p9\2\u012b\u012d\5\u0082B\2\u012c\u012e\5\u0084C\2\u012d"+
"\u012c\3\2\2\2\u012d\u012e\3\2\2\2\u012e\u0131\3\2\2\2\u012f\u0131\5\u0084"+
"C\2\u0130\u012b\3\2\2\2\u0130\u012f\3\2\2\2\u0131\33\3\2\2\2\u0132\u0134"+
"\7 \2\2\u0133\u0135\7\60\2\2\u0134\u0133\3\2\2\2\u0134\u0135\3\2\2\2\u0135"+
"\u0136\3\2\2\2\u0136\u013b\5\66\34\2\u0137\u0138\7~\2\2\u0138\u0139\5"+
"f\64\2\u0139\u013a\7\177\2\2\u013a\u013c\3\2\2\2\u013b\u0137\3\2\2\2\u013b"+
"\u013c\3\2\2\2\u013c\u013e\3\2\2\2\u013d\u013f\58\35\2\u013e\u013d\3\2"+
"\2\2\u013e\u013f\3\2\2\2\u013f\u0141\3\2\2\2\u0140\u0142\5\u008eH\2\u0141"+
"\u0140\3\2\2\2\u0141\u0142\3\2\2\2\u0142\u0144\3\2\2\2\u0143\u0145\5&"+
"\24\2\u0144\u0143\3\2\2\2\u0144\u0145\3\2\2\2\u0145\35\3\2\2\2\u0146\u0148"+
"\7j\2\2\u0147\u0149\7\60\2\2\u0148\u0147\3\2\2\2\u0148\u0149\3\2\2\2\u0149"+
"\u014a\3\2\2\2\u014a\u014f\5\66\34\2\u014b\u014c\7~\2\2\u014c\u014d\5"+
"f\64\2\u014d\u014e\7\177\2\2\u014e\u0150\3\2\2\2\u014f\u014b\3\2\2\2\u014f"+
"\u0150\3\2\2\2\u0150\u0152\3\2\2\2\u0151\u0153\58\35\2\u0152\u0151\3\2"+
"\2\2\u0152\u0153\3\2\2\2\u0153\u0154\3\2\2\2\u0154\u0155\7^\2\2\u0155"+
"\u0156\5\"\22\2\u0156\u0157\7v\2\2\u0157\u015f\5\u0090I\2\u0158\u0159"+
"\7|\2\2\u0159\u015a\5\"\22\2\u015a\u015b\7v\2\2\u015b\u015c\5\u0090I\2"+
"\u015c\u015e\3\2\2\2\u015d\u0158\3\2\2\2\u015e\u0161\3\2\2\2\u015f\u015d"+
"\3\2\2\2\u015f\u0160\3\2\2\2\u0160\u0163\3\2\2\2\u0161\u015f\3\2\2\2\u0162"+
"\u0164\5\u008eH\2\u0163\u0162\3\2\2\2\u0163\u0164\3\2\2\2\u0164\u0166"+
"\3\2\2\2\u0165\u0167\5&\24\2\u0166\u0165\3\2\2\2\u0166\u0167\3\2\2\2\u0167"+
"\37\3\2\2\2\u0168\u0169\78\2\2\u0169\u016a\7:\2\2\u016a\u016f\5\66\34"+
"\2\u016b\u016c\7~\2\2\u016c\u016d\5f\64\2\u016d\u016e\7\177\2\2\u016e"+
"\u0170\3\2\2\2\u016f\u016b\3\2\2\2\u016f\u0170\3\2\2\2\u0170\u0171\3\2"+
"\2\2\u0171\u0172\5$\23\2\u0172\u0174\5(\25\2\u0173\u0175\5&\24\2\u0174"+
"\u0173\3\2\2\2\u0174\u0175\3\2\2\2\u0175!\3\2\2\2\u0176\u0182\5f\64\2"+
"\u0177\u0178\7>\2\2\u0178\u0179\7~\2\2\u0179\u017a\5^\60\2\u017a\u017b"+
"\7\177\2\2\u017b\u0182\3\2\2\2\u017c\u017d\7\66\2\2\u017d\u017e\7~\2\2"+
"\u017e\u017f\5^\60\2\u017f\u0180\7\177\2\2\u0180\u0182\3\2\2\2\u0181\u0176"+
"\3\2\2\2\u0181\u0177\3\2\2\2\u0181\u017c\3\2\2\2\u0182#\3\2\2\2\u0183"+
"\u0184\7~\2\2\u0184\u0189\5\"\22\2\u0185\u0186\7|\2\2\u0186\u0188\5\""+
"\22\2\u0187\u0185\3\2\2\2\u0188\u018b\3\2\2\2\u0189\u0187\3\2\2\2\u0189"+
"\u018a\3\2\2\2\u018a\u018c\3\2\2\2\u018b\u0189\3\2\2\2\u018c\u018d\7\177"+
"\2\2\u018d%\3\2\2\2\u018e\u018f\7Y\2\2\u018f\u0194\5f\64\2\u0190\u0191"+
"\7|\2\2\u0191\u0193\5f\64\2\u0192\u0190\3\2\2\2\u0193\u0196\3\2\2\2\u0194"+
"\u0192\3\2\2\2\u0194\u0195\3\2\2\2\u0195\'\3\2\2\2\u0196\u0194\3\2\2\2"+
"\u0197\u0199\5J&\2\u0198\u0197\3\2\2\2\u0198\u0199\3\2\2\2\u0199\u019a"+
"\3\2\2\2\u019a\u019c\5*\26\2\u019b\u019d\5\u0088E\2\u019c\u019b\3\2\2"+
"\2\u019c\u019d\3\2\2\2\u019d\u019f\3\2\2\2\u019e\u01a0\5\u008eH\2\u019f"+
"\u019e\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0\u01a2\3\2\2\2\u01a1\u01a3\5j"+
"\66\2\u01a2\u01a1\3\2\2\2\u01a2\u01a3\3\2\2\2\u01a3\u01a5\3\2\2\2\u01a4"+
"\u01a6\5n8\2\u01a5\u01a4\3\2\2\2\u01a5\u01a6\3\2\2\2\u01a6\u01a8\3\2\2"+
"\2\u01a7\u01a9\5t;\2\u01a8\u01a7\3\2\2\2\u01a8\u01a9\3\2\2\2\u01a9\u01af"+
"\3\2\2\2\u01aa\u01ac\t\2\2\2\u01ab\u01ad\t\3\2\2\u01ac\u01ab\3\2\2\2\u01ac"+
"\u01ad\3\2\2\2\u01ad\u01ae\3\2\2\2\u01ae\u01b0\5(\25\2\u01af\u01aa\3\2"+
"\2\2\u01af\u01b0\3\2\2\2\u01b0\u01b2\3\2\2\2\u01b1\u01b3\5p9\2\u01b2\u01b1"+
"\3\2\2\2\u01b2\u01b3\3\2\2\2\u01b3\u01b5\3\2\2\2\u01b4\u01b6\5\u0082B"+
"\2\u01b5\u01b4\3\2\2\2\u01b5\u01b6\3\2\2\2\u01b6\u01b8\3\2\2\2\u01b7\u01b9"+
"\5\u0084C\2\u01b8\u01b7\3\2\2\2\u01b8\u01b9\3\2\2\2\u01b9)\3\2\2\2\u01ba"+
"\u01bb\7\60\2\2\u01bb\u01c0\5.\30\2\u01bc\u01bd\7|\2\2\u01bd\u01bf\5."+
"\30\2\u01be\u01bc\3\2\2\2\u01bf\u01c2\3\2\2\2\u01c0\u01be\3\2\2\2\u01c0"+
"\u01c1\3\2\2\2\u01c1+\3\2\2\2\u01c2\u01c0\3\2\2\2\u01c3\u01c4\7\60\2\2"+
"\u01c4\u01c9\5\60\31\2\u01c5\u01c6\7|\2\2\u01c6\u01c8\5\60\31\2\u01c7"+
"\u01c5\3\2\2\2\u01c8\u01cb\3\2\2\2\u01c9\u01c7\3\2\2\2\u01c9\u01ca\3\2"+
"\2\2\u01ca-\3\2\2\2\u01cb\u01c9\3\2\2\2\u01cc\u01d2\5\62\32\2\u01cd\u01d1"+
"\5:\36\2\u01ce\u01d1\5<\37\2\u01cf\u01d1\5> \2\u01d0\u01cd\3\2\2\2\u01d0"+
"\u01ce\3\2\2\2\u01d0\u01cf\3\2\2\2\u01d1\u01d4\3\2\2\2\u01d2\u01d0\3\2"+
"\2\2\u01d2\u01d3\3\2\2\2\u01d3/\3\2\2\2\u01d4\u01d2\3\2\2\2\u01d5\u01db"+
"\5\62\32\2\u01d6\u01da\5:\36\2\u01d7\u01da\5<\37\2\u01d8\u01da\5@!\2\u01d9"+
"\u01d6\3\2\2\2\u01d9\u01d7\3\2\2\2\u01d9\u01d8\3\2\2\2\u01da\u01dd\3\2"+
"\2\2\u01db\u01d9\3\2\2\2\u01db\u01dc\3\2\2\2\u01dc\61\3\2\2\2\u01dd\u01db"+
"\3\2\2\2\u01de\u01e0\5\66\34\2\u01df\u01e1\58\35\2\u01e0\u01df\3\2\2\2"+
"\u01e0\u01e1\3\2\2\2\u01e1\u0218\3\2\2\2\u01e2\u01e3\5\66\34\2\u01e3\u01e4"+
"\7~\2\2\u01e4\u01e5\7\4\2\2\u01e5\u01e6\7l\2\2\u01e6\u01e7\7\177\2\2\u01e7"+
"\u01e8\58\35\2\u01e8\u0218\3\2\2\2\u01e9\u01ea\5\66\34\2\u01ea\u01eb\7"+
"~\2\2\u01eb\u01ec\7l\2\2\u01ec\u01f1\5\64\33\2\u01ed\u01ee\7|\2\2\u01ee"+
"\u01f0\5\64\33\2\u01ef\u01ed\3\2\2\2\u01f0\u01f3\3\2\2\2\u01f1\u01ef\3"+
"\2\2\2\u01f1\u01f2\3\2\2\2\u01f2\u01f4\3\2\2\2\u01f3\u01f1\3\2\2\2\u01f4"+
"\u01f5\7\177\2\2\u01f5\u01f6\58\35\2\u01f6\u0218\3\2\2\2\u01f7\u01f8\5"+
"\u00b4[\2\u01f8\u01f9\7~\2\2\u01f9\u01fa\7\4\2\2\u01fa\u01fd\7l\2\2\u01fb"+
"\u01fc\7B\2\2\u01fc\u01fe\5\66\34\2\u01fd\u01fb\3\2\2\2\u01fd\u01fe\3"+
"\2\2\2\u01fe\u01ff\3\2\2\2\u01ff\u0200\7\177\2\2\u0200\u0201\58\35\2\u0201"+
"\u0218\3\2\2\2\u0202\u0203\5\u00b4[\2\u0203\u0204\7~\2\2\u0204\u0205\7"+
"l\2\2\u0205\u020a\5\64\33\2\u0206\u0207\7|\2\2\u0207\u0209\5\64\33\2\u0208"+
"\u0206\3\2\2\2\u0209\u020c\3\2\2\2\u020a\u0208\3\2\2\2\u020a\u020b\3\2"+
"\2\2\u020b\u020d\3\2\2\2\u020c\u020a\3\2\2\2\u020d\u020e\7\177\2\2\u020e"+
"\u020f\58\35\2\u020f\u0218\3\2\2\2\u0210\u0211\t\4\2\2\u0211\u0212\7~"+
"\2\2\u0212\u0213\5\66\34\2\u0213\u0215\7\177\2\2\u0214\u0216\58\35\2\u0215"+
"\u0214\3\2\2\2\u0215\u0216\3\2\2\2\u0216\u0218\3\2\2\2\u0217\u01de\3\2"+
"\2\2\u0217\u01e2\3\2\2\2\u0217\u01e9\3\2\2\2\u0217\u01f7\3\2\2\2\u0217"+
"\u0202\3\2\2\2\u0217\u0210\3\2\2\2\u0218\63\3\2\2\2\u0219\u021a\7~\2\2"+
"\u021a\u021f\5\u00a0Q\2\u021b\u021c\7|\2\2\u021c\u021e\5\u00a0Q\2\u021d"+
"\u021b\3\2\2\2\u021e\u0221\3\2\2\2\u021f\u021d\3\2\2\2\u021f\u0220\3\2"+
"\2\2\u0220\u0222\3\2\2\2\u0221\u021f\3\2\2\2\u0222\u0223\7\177\2\2\u0223"+
"\65\3\2\2\2\u0224\u0225\5f\64\2\u0225\67\3\2\2\2\u0226\u0227\7\20\2\2"+
"\u0227\u022a\5\u00b4[\2\u0228\u022a\7\u008b\2\2\u0229\u0226\3\2\2\2\u0229"+
"\u0228\3\2\2\2\u022a9\3\2\2\2\u022b\u022c\7\32\2\2\u022c\u022d\7<\2\2"+
"\u022d\u022e\5\62\32\2\u022e;\3\2\2\2\u022f\u0230\7|\2\2\u0230\u0231\7"+
"\65\2\2\u0231\u0232\7~\2\2\u0232\u0233\5^\60\2\u0233\u0235\7\177\2\2\u0234"+
"\u0236\58\35\2\u0235\u0234\3\2\2\2\u0235\u0236\3\2\2\2\u0236=\3\2\2\2"+
"\u0237\u0238\5F$\2\u0238\u023a\7<\2\2\u0239\u023b\7,\2\2\u023a\u0239\3"+
"\2\2\2\u023a\u023b\3\2\2\2\u023b\u023c\3\2\2\2\u023c\u023e\5B\"\2\u023d"+
"\u023f\5H%\2\u023e\u023d\3\2\2\2\u023e\u023f\3\2\2\2\u023f?\3\2\2\2\u0240"+
"\u0241\5F$\2\u0241\u0242\7<\2\2\u0242\u0244\5B\"\2\u0243\u0245\5H%\2\u0244"+
"\u0243\3\2\2\2\u0244\u0245\3\2\2\2\u0245A\3\2\2\2\u0246\u0249\5\62\32"+
"\2\u0247\u0249\5D#\2\u0248\u0246\3\2\2\2\u0248\u0247\3\2\2\2\u0249C\3"+
"\2\2\2\u024a\u024b\7d\2\2\u024b\u024c\7~\2\2\u024c\u024d\5^\60\2\u024d"+
"\u024e\7\20\2\2\u024e\u024f\5\66\34\2\u024f\u0252\7\177\2\2\u0250\u0251"+
"\7}\2\2\u0251\u0253\5h\65\2\u0252\u0250\3\2\2\2\u0252\u0253\3\2\2\2\u0253"+
"\u0255\3\2\2\2\u0254\u0256\58\35\2\u0255\u0254\3\2\2\2\u0255\u0256\3\2"+
"\2\2\u0256E\3\2\2\2\u0257\u0259\7\67\2\2\u0258\u0257\3\2\2\2\u0258\u0259"+
"\3\2\2\2\u0259\u0261\3\2\2\2\u025a\u025c\t\5\2\2\u025b\u025a\3\2\2\2\u025b"+
"\u025c\3\2\2\2\u025c\u025e\3\2\2\2\u025d\u025f\7R\2\2\u025e\u025d\3\2"+
"\2\2\u025e\u025f\3\2\2\2\u025f\u0261\3\2\2\2\u0260\u0258\3\2\2\2\u0260"+
"\u025b\3\2\2\2\u0261G\3\2\2\2\u0262\u0263\7N\2\2\u0263\u0264\5\u0092J"+
"\2\u0264I\3\2\2\2\u0265\u0267\7]\2\2\u0266\u0268\7\"\2\2\u0267\u0266\3"+
"\2\2\2\u0267\u0268\3\2\2\2\u0268\u0269\3\2\2\2\u0269\u026e\5N(\2\u026a"+
"\u026b\7|\2\2\u026b\u026d\5N(\2\u026c\u026a\3\2\2\2\u026d\u0270\3\2\2"+
"\2\u026e\u026c\3\2\2\2\u026e\u026f\3\2\2\2\u026fK\3\2\2\2\u0270\u026e"+
"\3\2\2\2\u0271\u0273\7]\2\2\u0272\u0274\7\"\2\2\u0273\u0272\3\2\2\2\u0273"+
"\u0274\3\2\2\2\u0274\u0275\3\2\2\2\u0275\u027a\5P)\2\u0276\u0277\7|\2"+
"\2\u0277\u0279\5P)\2\u0278\u0276\3\2\2\2\u0279\u027c\3\2\2\2\u027a\u0278"+
"\3\2\2\2\u027a\u027b\3\2\2\2\u027bM\3\2\2\2\u027c\u027a\3\2\2\2\u027d"+
"\u027f\5R*\2\u027e\u0280\5T+\2\u027f\u027e\3\2\2\2\u027f\u0280\3\2\2\2"+
"\u0280O\3\2\2\2\u0281\u0282\5\u0090I\2\u0282Q\3\2\2\2\u0283\u0288\5X-"+
"\2\u0284\u0288\5\\/\2\u0285\u0288\5V,\2\u0286\u0288\5\u0090I\2\u0287\u0283"+
"\3\2\2\2\u0287\u0284\3\2\2\2\u0287\u0285\3\2\2\2\u0287\u0286\3\2\2\2\u0288"+
"S\3\2\2\2\u0289\u028a\7\20\2\2\u028a\u028d\5\u00b4[\2\u028b\u028d\7\u008b"+
"\2\2\u028c\u0289\3\2\2\2\u028c\u028b\3\2\2\2\u028dU\3\2\2\2\u028e\u028f"+
"\7&\2\2\u028f\u0290\7~\2\2\u0290\u0291\5^\60\2\u0291\u0292\7\177\2\2\u0292"+
"W\3\2\2\2\u0293\u0294\7E\2\2\u0294\u0295\5f\64\2\u0295\u0296\7~\2\2\u0296"+
"\u029b\5Z.\2\u0297\u0298\7|\2\2\u0298\u029a\5Z.\2\u0299\u0297\3\2\2\2"+
"\u029a\u029d\3\2\2\2\u029b\u0299\3\2\2\2\u029b\u029c\3\2\2\2\u029c\u029e"+
"\3\2\2\2\u029d\u029b\3\2\2\2\u029e\u029f\7\177\2\2\u029fY\3\2\2\2\u02a0"+
"\u02a1\5\u0090I\2\u02a1[\3\2\2\2\u02a2\u02a3\7J\2\2\u02a3\u02a4\7~\2\2"+
"\u02a4\u02a5\5\u00b4[\2\u02a5\u02a6\7\177\2\2\u02a6]\3\2\2\2\u02a7\u02aa"+
"\5d\63\2\u02a8\u02a9\7}\2\2\u02a9\u02ab\5h\65\2\u02aa\u02a8\3\2\2\2\u02aa"+
"\u02ab\3\2\2\2\u02ab\u02ae\3\2\2\2\u02ac\u02ae\5h\65\2\u02ad\u02a7\3\2"+
"\2\2\u02ad\u02ac\3\2\2\2\u02ae_\3\2\2\2\u02af\u02b0\5\u00b4[\2\u02b0\u02b9"+
"\7~\2\2\u02b1\u02b6\5\u0090I\2\u02b2\u02b3\7|\2\2\u02b3\u02b5\5\u0090"+
"I\2\u02b4\u02b2\3\2\2\2\u02b5\u02b8\3\2\2\2\u02b6\u02b4\3\2\2\2\u02b6"+
"\u02b7\3\2\2\2\u02b7\u02ba\3\2\2\2\u02b8\u02b6\3\2\2\2\u02b9\u02b1\3\2"+
"\2\2\u02b9\u02ba\3\2\2\2\u02ba\u02bb\3\2\2\2\u02bb\u02bc\7\177\2\2\u02bc"+
"a\3\2\2\2\u02bd\u02be\7R\2\2\u02be\u02c1\7~\2\2\u02bf\u02c2\5f\64\2\u02c0"+
"\u02c2\5`\61\2\u02c1\u02bf\3\2\2\2\u02c1\u02c0\3\2\2\2\u02c2\u02c3\3\2"+
"\2\2\u02c3\u02c4\7\177\2\2\u02c4c\3\2\2\2\u02c5\u02c6\7d\2\2\u02c6\u02c7"+
"\7~\2\2\u02c7\u02c8\5^\60\2\u02c8\u02c9\7\20\2\2\u02c9\u02ca\5\66\34\2"+
"\u02ca\u02cb\7\177\2\2\u02cb\u02d7\3\2\2\2\u02cc\u02cd\7k\2\2\u02cd\u02ce"+
"\7~\2\2\u02ce\u02cf\5^\60\2\u02cf\u02d0\7\177\2\2\u02d0\u02d7\3\2\2\2"+
"\u02d1\u02d2\7>\2\2\u02d2\u02d3\7~\2\2\u02d3\u02d4\5^\60\2\u02d4\u02d5"+
"\7\177\2\2\u02d5\u02d7\3\2\2\2\u02d6\u02c5\3\2\2\2\u02d6\u02cc\3\2\2\2"+
"\u02d6\u02d1\3\2\2\2\u02d7e\3\2\2\2\u02d8\u02dd\5\u00b4[\2\u02d9\u02da"+
"\7}\2\2\u02da\u02dc\5\u00b6\\\2\u02db\u02d9\3\2\2\2\u02dc\u02df\3\2\2"+
"\2\u02dd\u02db\3\2\2\2\u02dd\u02de\3\2\2\2\u02deg\3\2\2\2\u02df\u02dd"+
"\3\2\2\2\u02e0\u02e8\5f\64\2\u02e1\u02e2\7\u0080\2\2\u02e2\u02e3\5\u0094"+
"K\2\u02e3\u02e6\7\u0081\2\2\u02e4\u02e5\7}\2\2\u02e5\u02e7\5h\65\2\u02e6"+
"\u02e4\3\2\2\2\u02e6\u02e7\3\2\2\2\u02e7\u02e9\3\2\2\2\u02e8\u02e1\3\2"+
"\2\2\u02e8\u02e9\3\2\2\2\u02e9i\3\2\2\2\u02ea\u02eb\7\62\2\2\u02eb\u02ec"+
"\7\25\2\2\u02ec\u02f1\5l\67\2\u02ed\u02ee\7|\2\2\u02ee\u02f0\5l\67\2\u02ef"+
"\u02ed\3\2\2\2\u02f0\u02f3\3\2\2\2\u02f1\u02ef\3\2\2\2\u02f1\u02f2\3\2"+
"\2\2\u02f2k\3\2\2\2\u02f3\u02f1\3\2\2\2\u02f4\u02f5\5\u0090I\2\u02f5m"+
"\3\2\2\2\u02f6\u02f7\7\64\2\2\u02f7\u02f8\5\u0092J\2\u02f8o\3\2\2\2\u02f9"+
"\u02fa\7P\2\2\u02fa\u02fb\7\25\2\2\u02fb\u0300\5r:\2\u02fc\u02fd\7|\2"+
"\2\u02fd\u02ff\5r:\2\u02fe\u02fc\3\2\2\2\u02ff\u0302\3\2\2\2\u0300\u02fe"+
"\3\2\2\2\u0300\u0301\3\2\2\2\u0301q\3\2\2\2\u0302\u0300\3\2\2\2\u0303"+
"\u0306\5\u0090I\2\u0304\u0305\7\27\2\2\u0305\u0307\7\13\2\2\u0306\u0304"+
"\3\2\2\2\u0306\u0307\3\2\2\2\u0307\u030d\3\2\2\2\u0308\u030b\t\6\2\2\u0309"+
"\u030a\7I\2\2\u030a\u030c\t\7\2\2\u030b\u0309\3\2\2\2\u030b\u030c\3\2"+
"\2\2\u030c\u030e\3\2\2\2\u030d\u0308\3\2\2\2\u030d\u030e\3\2\2\2\u030e"+
"s\3\2\2\2\u030f\u0310\7o\2\2\u0310\u0311\5\u00b4[\2\u0311\u0312\7\20\2"+
"\2\u0312\u0313\7~\2\2\u0313\u0314\5v<\2\u0314\u031e\7\177\2\2\u0315\u0316"+
"\7|\2\2\u0316\u0317\5\u00b4[\2\u0317\u0318\7\20\2\2\u0318\u0319\7~\2\2"+
"\u0319\u031a\5v<\2\u031a\u031b\7\177\2\2\u031b\u031d\3\2\2\2\u031c\u0315"+
"\3\2\2\2\u031d\u0320\3\2\2\2\u031e\u031c\3\2\2\2\u031e\u031f\3\2\2\2\u031f"+
"u\3\2\2\2\u0320\u031e\3\2\2\2\u0321\u0323\5\u00b4[\2\u0322\u0321\3\2\2"+
"\2\u0322\u0323\3\2\2\2\u0323\u0325\3\2\2\2\u0324\u0326\5x=\2\u0325\u0324"+
"\3\2\2\2\u0325\u0326\3\2\2\2\u0326\u0328\3\2\2\2\u0327\u0329\5p9\2\u0328"+
"\u0327\3\2\2\2\u0328\u0329\3\2\2\2\u0329\u032b\3\2\2\2\u032a\u032c\5z"+
">\2\u032b\u032a\3\2\2\2\u032b\u032c\3\2\2\2\u032cw\3\2\2\2\u032d\u032e"+
"\7U\2\2\u032e\u032f\7\25\2\2\u032f\u0334\5l\67\2\u0330\u0331\7|\2\2\u0331"+
"\u0333\5l\67\2\u0332\u0330\3\2\2\2\u0333\u0336\3\2\2\2\u0334\u0332\3\2"+
"\2\2\u0334\u0335\3\2\2\2\u0335y\3\2\2\2\u0336\u0334\3\2\2\2\u0337\u0338"+
"\t\b\2\2\u0338\u033a\5|?\2\u0339\u033b\5\u0080A\2\u033a\u0339\3\2\2\2"+
"\u033a\u033b\3\2\2\2\u033b\u0345\3\2\2\2\u033c\u033d\t\b\2\2\u033d\u033e"+
"\7\23\2\2\u033e\u033f\5|?\2\u033f\u0340\7\16\2\2\u0340\u0342\5~@\2\u0341"+
"\u0343\5\u0080A\2\u0342\u0341\3\2\2\2\u0342\u0343\3\2\2\2\u0343\u0345"+
"\3\2\2\2\u0344\u0337\3\2\2\2\u0344\u033c\3\2\2\2\u0345{\3\2\2\2\u0346"+
"\u0347\7h\2\2\u0347\u0351\7V\2\2\u0348\u0349\5\u0086D\2\u0349\u034a\7"+
"V\2\2\u034a\u0351\3\2\2\2\u034b\u034c\7\33\2\2\u034c\u0351\7[\2\2\u034d"+
"\u034e\5\u0086D\2\u034e\u034f\7/\2\2\u034f\u0351\3\2\2\2\u0350\u0346\3"+
"\2\2\2\u0350\u0348\3\2\2\2\u0350\u034b\3\2\2\2\u0350\u034d\3\2\2\2\u0351"+
"}\3\2\2\2\u0352\u0353\7h\2\2\u0353\u035f\7V\2\2\u0354\u0355\5\u0086D\2"+
"\u0355\u0356\7V\2\2\u0356\u035f\3\2\2\2\u0357\u0358\7\33\2\2\u0358\u035f"+
"\7[\2\2\u0359\u035a\5\u0086D\2\u035a\u035b\7/\2\2\u035b\u035f\3\2\2\2"+
"\u035c\u035d\7h\2\2\u035d\u035f\7/\2\2\u035e\u0352\3\2\2\2\u035e\u0354"+
"\3\2\2\2\u035e\u0357\3\2\2\2\u035e\u0359\3\2\2\2\u035e\u035c\3\2\2\2\u035f"+
"\177\3\2\2\2\u0360\u0361\7)\2\2\u0361\u0362\7\33\2\2\u0362\u036b\7[\2"+
"\2\u0363\u0364\7)\2\2\u0364\u036b\7\62\2\2\u0365\u0366\7)\2\2\u0366\u036b"+
"\7a\2\2\u0367\u0368\7)\2\2\u0368\u0369\7F\2\2\u0369\u036b\7Q\2\2\u036a"+
"\u0360\3\2\2\2\u036a\u0363\3\2\2\2\u036a\u0365\3\2\2\2\u036a\u0367\3\2"+
"\2\2\u036b\u0081\3\2\2\2\u036c\u036d\7C\2\2\u036d\u036e\5\u0086D\2\u036e"+
"\u0083\3\2\2\2\u036f\u0370\7L\2\2\u0370\u0377\5\u0086D\2\u0371\u0372\7"+
"=\2\2\u0372\u0373\7b\2\2\u0373\u0374\7T\2\2\u0374\u0375\7\30\2\2\u0375"+
"\u0377\5\u00acW\2\u0376\u036f\3\2\2\2\u0376\u0371\3\2\2\2\u0377\u0085"+
"\3\2\2\2\u0378\u037b\5\u00acW\2\u0379\u037b\7\4\2\2\u037a\u0378\3\2\2"+
"\2\u037a\u0379\3\2\2\2\u037b\u0087\3\2\2\2\u037c\u037d\t\t\2\2\u037d\u038b"+
"\5\u008aF\2\u037e\u037f\t\t\2\2\u037f\u0380\7~\2\2\u0380\u0385\5\u008a"+
"F\2\u0381\u0382\7|\2\2\u0382\u0384\5\u008aF\2\u0383\u0381\3\2\2\2\u0384"+
"\u0387\3\2\2\2\u0385\u0383\3\2\2\2\u0385\u0386\3\2\2\2\u0386\u0388\3\2"+
"\2\2\u0387\u0385\3\2\2\2\u0388\u0389\7\177\2\2\u0389\u038b\3\2\2\2\u038a"+
"\u037c\3\2\2\2\u038a\u037e\3\2\2\2\u038b\u0089\3\2\2\2\u038c\u038f\5\u00ac"+
"W\2\u038d\u038f\5\u00a0Q\2\u038e\u038c\3\2\2\2\u038e\u038d\3\2\2\2\u038f"+
"\u008b\3\2\2\2\u0390\u0395\5\u00b4[\2\u0391\u0392\t\n\2\2\u0392\u0394"+
"\5\u00b6\\\2\u0393\u0391\3\2\2\2\u0394\u0397\3\2\2\2\u0395\u0393\3\2\2"+
"\2\u0395\u0396\3\2\2\2\u0396\u008d\3\2\2\2\u0397\u0395\3\2\2\2\u0398\u0399"+
"\7n\2\2\u0399\u039a\5\u0092J\2\u039a\u008f\3\2\2\2\u039b\u039c\bI\1\2"+
"\u039c\u039d\7~\2\2\u039d\u039e\5\u0090I\2\u039e\u039f\7\177\2\2\u039f"+
"\u03c4\3\2\2\2\u03a0\u03a1\7\26\2\2\u03a1\u03a3\5\u0090I\2\u03a2\u03a4"+
"\5\u009aN\2\u03a3\u03a2\3\2\2\2\u03a4\u03a5\3\2\2\2\u03a5\u03a3\3\2\2"+
"\2\u03a5\u03a6\3\2\2\2\u03a6\u03a9\3\2\2\2\u03a7\u03a8\7#\2\2\u03a8\u03aa"+
"\5\u0090I\2\u03a9\u03a7\3\2\2\2\u03a9\u03aa\3\2\2\2\u03aa\u03ab\3\2\2"+
"\2\u03ab\u03ac\7%\2\2\u03ac\u03c4\3\2\2\2\u03ad\u03af\7\26\2\2\u03ae\u03b0"+
"\5\u009cO\2\u03af\u03ae\3\2\2\2\u03b0\u03b1\3\2\2\2\u03b1\u03af\3\2\2"+
"\2\u03b1\u03b2\3\2\2\2\u03b2\u03b5\3\2\2\2\u03b3\u03b4\7#\2\2\u03b4\u03b6"+
"\5\u0090I\2\u03b5\u03b3\3\2\2\2\u03b5\u03b6\3\2\2\2\u03b6\u03b7\3\2\2"+
"\2\u03b7\u03b8\7%\2\2\u03b8\u03c4\3\2\2\2\u03b9\u03c4\5\u009eP\2\u03ba"+
"\u03c4\5\u00acW\2\u03bb\u03c4\5\u0098M\2\u03bc\u03c4\t\13\2\2\u03bd\u03c4"+
"\5^\60\2\u03be\u03c4\5\u00aeX\2\u03bf\u03c0\7\u0083\2\2\u03c0\u03c4\5"+
"\u0090I\7\u03c1\u03c2\7\u0082\2\2\u03c2\u03c4\5\u0090I\6\u03c3\u039b\3"+
"\2\2\2\u03c3\u03a0\3\2\2\2\u03c3\u03ad\3\2\2\2\u03c3\u03b9\3\2\2\2\u03c3"+
"\u03ba\3\2\2\2\u03c3\u03bb\3\2\2\2\u03c3\u03bc\3\2\2\2\u03c3\u03bd\3\2"+
"\2\2\u03c3\u03be\3\2\2\2\u03c3\u03bf\3\2\2\2\u03c3\u03c1\3\2\2\2\u03c4"+
"\u03d0\3\2\2\2\u03c5\u03c6\f\5\2\2\u03c6\u03c7\t\f\2\2\u03c7\u03cf\5\u0090"+
"I\6\u03c8\u03c9\f\4\2\2\u03c9\u03ca\t\r\2\2\u03ca\u03cf\5\u0090I\5\u03cb"+
"\u03cc\f\3\2\2\u03cc\u03cd\7\u0088\2\2\u03cd\u03cf\5\u0090I\4\u03ce\u03c5"+
"\3\2\2\2\u03ce\u03c8\3\2\2\2\u03ce\u03cb\3\2\2\2\u03cf\u03d2\3\2\2\2\u03d0"+
"\u03ce\3\2\2\2\u03d0\u03d1\3\2\2\2\u03d1\u0091\3\2\2\2\u03d2\u03d0\3\2"+
"\2\2\u03d3\u03d4\bJ\1\2\u03d4\u03d5\7~\2\2\u03d5\u03d6\5\u0092J\2\u03d6"+
"\u03d7\7\177\2\2\u03d7\u0476\3\2\2\2\u03d8\u03d9\7G\2\2\u03d9\u0476\5"+
"\u0092J\30\u03da\u03dc\7G\2\2\u03db\u03da\3\2\2\2\u03db\u03dc\3\2\2\2"+
"\u03dc\u03dd\3\2\2\2\u03dd\u03e3\7*\2\2\u03de\u03e4\5\u00b4[\2\u03df\u03e0"+
"\7~\2\2\u03e0\u03e1\5\u00b4[\2\u03e1\u03e2\7\177\2\2\u03e2\u03e4\3\2\2"+
"\2\u03e3\u03de\3\2\2\2\u03e3\u03df\3\2\2\2\u03e4\u0476\3\2\2\2\u03e5\u03e6"+
"\5\u0090I\2\u03e6\u03e8\7;\2\2\u03e7\u03e9\7G\2\2\u03e8\u03e7\3\2\2\2"+
"\u03e8\u03e9\3\2\2\2\u03e9\u03ea\3\2\2\2\u03ea\u03eb\7H\2\2\u03eb\u0476"+
"\3\2\2\2\u03ec\u03ed\5\u0090I\2\u03ed\u03ef\7;\2\2\u03ee\u03f0\7G\2\2"+
"\u03ef\u03ee\3\2\2\2\u03ef\u03f0\3\2\2\2\u03f0\u03f1\3\2\2\2\u03f1\u03f2"+
"\7$\2\2\u03f2\u0476\3\2\2\2\u03f3\u03f4\5\u0090I\2\u03f4\u03f6\7v\2\2"+
"\u03f5\u03f7\t\16\2\2\u03f6\u03f5\3\2\2\2\u03f6\u03f7\3\2\2\2\u03f7\u03fd"+
"\3\2\2\2\u03f8\u03fe\5\u00b4[\2\u03f9\u03fa\7~\2\2\u03fa\u03fb\5\u00b4"+
"[\2\u03fb\u03fc\7\177\2\2\u03fc\u03fe\3\2\2\2\u03fd\u03f8\3\2\2\2\u03fd"+
"\u03f9\3\2\2\2\u03fe\u0476\3\2\2\2\u03ff\u0400\5\u0090I\2\u0400\u0402"+
"\7w\2\2\u0401\u0403\t\16\2\2\u0402\u0401\3\2\2\2\u0402\u0403\3\2\2\2\u0403"+
"\u0409\3\2\2\2\u0404\u040a\5\u00b4[\2\u0405\u0406\7~\2\2\u0406\u0407\5"+
"\u00b4[\2\u0407\u0408\7\177\2\2\u0408\u040a\3\2\2\2\u0409\u0404\3\2\2"+
"\2\u0409\u0405\3\2\2\2\u040a\u0476\3\2\2\2\u040b\u040c\5\u0090I\2\u040c"+
"\u040e\7x\2\2\u040d\u040f\t\16\2\2\u040e\u040d\3\2\2\2\u040e\u040f\3\2"+
"\2\2\u040f\u0415\3\2\2\2\u0410\u0416\5\u00b4[\2\u0411\u0412\7~\2\2\u0412"+
"\u0413\5\u00b4[\2\u0413\u0414\7\177\2\2\u0414\u0416\3\2\2\2\u0415\u0410"+
"\3\2\2\2\u0415\u0411\3\2\2\2\u0416\u0476\3\2\2\2\u0417\u0418\5\u0090I"+
"\2\u0418\u041a\7y\2\2\u0419\u041b\t\16\2\2\u041a\u0419\3\2\2\2\u041a\u041b"+
"\3\2\2\2\u041b\u0421\3\2\2\2\u041c\u0422\5\u00b4[\2\u041d\u041e\7~\2\2"+
"\u041e\u041f\5\u00b4[\2\u041f\u0420\7\177\2\2\u0420\u0422\3\2\2\2\u0421"+
"\u041c\3\2\2\2\u0421\u041d\3\2\2\2\u0422\u0476\3\2\2\2\u0423\u0424\5\u0090"+
"I\2\u0424\u0426\7z\2\2\u0425\u0427\t\16\2\2\u0426\u0425\3\2\2\2\u0426"+
"\u0427\3\2\2\2\u0427\u042d\3\2\2\2\u0428\u042e\5\u00b4[\2\u0429\u042a"+
"\7~\2\2\u042a\u042b\5\u00b4[\2\u042b\u042c\7\177\2\2\u042c\u042e\3\2\2"+
"\2\u042d\u0428\3\2\2\2\u042d\u0429\3\2\2\2\u042e\u0476\3\2\2\2\u042f\u0430"+
"\5\u0090I\2\u0430\u0432\7{\2\2\u0431\u0433\t\16\2\2\u0432\u0431\3\2\2"+
"\2\u0432\u0433\3\2\2\2\u0433\u0439\3\2\2\2\u0434\u043a\5\u00b4[\2\u0435"+
"\u0436\7~\2\2\u0436\u0437\5\u00b4[\2\u0437\u0438\7\177\2\2\u0438\u043a"+
"\3\2\2\2\u0439\u0434\3\2\2\2\u0439\u0435\3\2\2\2\u043a\u0476\3\2\2\2\u043b"+
"\u043c\5\u0090I\2\u043c\u043d\7v\2\2\u043d\u043e\5\u0090I\2\u043e\u0476"+
"\3\2\2\2\u043f\u0440\5\u0090I\2\u0440\u0441\7w\2\2\u0441\u0442\5\u0090"+
"I\2\u0442\u0476\3\2\2\2\u0443\u0444\5\u0090I\2\u0444\u0445\7x\2\2\u0445"+
"\u0446\5\u0090I\2\u0446\u0476\3\2\2\2\u0447\u0448\5\u0090I\2\u0448\u0449"+
"\7y\2\2\u0449\u044a\5\u0090I\2\u044a\u0476\3\2\2\2\u044b\u044c\5\u0090"+
"I\2\u044c\u044d\7z\2\2\u044d\u044e\5\u0090I\2\u044e\u0476\3\2\2\2\u044f"+
"\u0450\5\u0090I\2\u0450\u0451\7{\2\2\u0451\u0452\5\u0090I\2\u0452\u0476"+
"\3\2\2\2\u0453\u0455\5\u0090I\2\u0454\u0456\7G\2\2\u0455\u0454\3\2\2\2"+
"\u0455\u0456\3\2\2\2\u0456\u0457\3\2\2\2\u0457\u0458\7\65\2\2\u0458\u0459"+
"\5\u0096L\2\u0459\u0476\3\2\2\2\u045a\u045c\5\u0090I\2\u045b\u045d\7G"+
"\2\2\u045c\u045b\3\2\2\2\u045c\u045d\3\2\2\2\u045d\u045e\3\2\2\2\u045e"+
"\u045f\7\23\2\2\u045f\u0460\5\u0090I\2\u0460\u0461\7\16\2\2\u0461\u0462"+
"\5\u0090I\2\u0462\u0476\3\2\2\2\u0463\u0465\5\u0090I\2\u0464\u0466\7G"+
"\2\2\u0465\u0464\3\2\2\2\u0465\u0466\3\2\2\2\u0466\u0467\3\2\2\2\u0467"+
"\u0468\7B\2\2\u0468\u046b\5\u0090I\2\u0469\u046a\7\'\2\2\u046a\u046c\5"+
"\u0090I\2\u046b\u0469\3\2\2\2\u046b\u046c\3\2\2\2\u046c\u0476\3\2\2\2"+
"\u046d\u046f\5\u0090I\2\u046e\u0470\7G\2\2\u046f\u046e\3\2\2\2\u046f\u0470"+
"\3\2\2\2\u0470\u0471\3\2\2\2\u0471\u0472\7D\2\2\u0472\u0473\7K\2\2\u0473"+
"\u0474\5^\60\2\u0474\u0476\3\2\2\2\u0475\u03d3\3\2\2\2\u0475\u03d8\3\2"+
"\2\2\u0475\u03db\3\2\2\2\u0475\u03e5\3\2\2\2\u0475\u03ec\3\2\2\2\u0475"+
"\u03f3\3\2\2\2\u0475\u03ff\3\2\2\2\u0475\u040b\3\2\2\2\u0475\u0417\3\2"+
"\2\2\u0475\u0423\3\2\2\2\u0475\u042f\3\2\2\2\u0475\u043b\3\2\2\2\u0475"+
"\u043f\3\2\2\2\u0475\u0443\3\2\2\2\u0475\u0447\3\2\2\2\u0475\u044b\3\2"+
"\2\2\u0475\u044f\3\2\2\2\u0475\u0453\3\2\2\2\u0475\u045a\3\2\2\2\u0475"+
"\u0463\3\2\2\2\u0475\u046d\3\2\2\2\u0476\u047f\3\2\2\2\u0477\u0478\f\27"+
"\2\2\u0478\u0479\7\16\2\2\u0479\u047e\5\u0092J\30\u047a\u047b\f\26\2\2"+
"\u047b\u047c\7O\2\2\u047c\u047e\5\u0092J\27\u047d\u0477\3\2\2\2\u047d"+
"\u047a\3\2\2\2\u047e\u0481\3\2\2\2\u047f\u047d\3\2\2\2\u047f\u0480\3\2"+
"\2\2\u0480\u0093\3\2\2\2\u0481\u047f\3\2\2\2\u0482\u0485\5\u0092J\2\u0483"+
"\u0485\5\u0090I\2\u0484\u0482\3\2\2\2\u0484\u0483\3\2\2\2\u0485\u0095"+
"\3\2\2\2\u0486\u0487\7~\2\2\u0487\u048c\5\u0090I\2\u0488\u0489\7|\2\2"+
"\u0489\u048b\5\u0090I\2\u048a\u0488\3\2\2\2\u048b\u048e\3\2\2\2\u048c"+
"\u048a\3\2\2\2\u048c\u048d\3\2\2\2\u048d\u048f\3\2\2\2\u048e\u048c\3\2"+
"\2\2\u048f\u0490\7\177\2\2\u0490\u0493\3\2\2\2\u0491\u0493\5\u0090I\2"+
"\u0492\u0486\3\2\2\2\u0492\u0491\3\2\2\2\u0493\u0097\3\2\2\2\u0494\u0495"+
"\7g\2\2\u0495\u0498\7~\2\2\u0496\u0499\5^\60\2\u0497\u0499\5\u00acW\2"+
"\u0498\u0496\3\2\2\2\u0498\u0497\3\2\2\2\u0499\u049a\3\2\2\2\u049a\u049b"+
"\7\177\2\2\u049b\u0099\3\2\2\2\u049c\u049d\7m\2\2\u049d\u049e\5\u0090"+
"I\2\u049e\u049f\7`\2\2\u049f\u04a0\5\u0090I\2\u04a0\u009b\3\2\2\2\u04a1"+
"\u04a2\7m\2\2\u04a2\u04a3\5\u0092J\2\u04a3\u04a4\7`\2\2\u04a4\u04a5\5"+
"\u0090I\2\u04a5\u009d\3\2\2\2\u04a6\u04b5\7\13\2\2\u04a7\u04b5\7\n\2\2"+
"\u04a8\u04b5\7\4\2\2\u04a9\u04b5\7\6\2\2\u04aa\u04b5\7\5\2\2\u04ab\u04b5"+
"\7\7\2\2\u04ac\u04b5\7\b\2\2\u04ad\u04b5\7\t\2\2\u04ae\u04b5\7H\2\2\u04af"+
"\u04b5\7f\2\2\u04b0\u04b5\7+\2\2\u04b1\u04b5\5\u00a4S\2\u04b2\u04b5\5"+
"\u00a6T\2\u04b3\u04b5\5\u00a8U\2\u04b4\u04a6\3\2\2\2\u04b4\u04a7\3\2\2"+
"\2\u04b4\u04a8\3\2\2\2\u04b4\u04a9\3\2\2\2\u04b4\u04aa\3\2\2\2\u04b4\u04ab"+
"\3\2\2\2\u04b4\u04ac\3\2\2\2\u04b4\u04ad\3\2\2\2\u04b4\u04ae\3\2\2\2\u04b4"+
"\u04af\3\2\2\2\u04b4\u04b0\3\2\2\2\u04b4\u04b1\3\2\2\2\u04b4\u04b2\3\2"+
"\2\2\u04b4\u04b3\3\2\2\2\u04b5\u009f\3\2\2\2\u04b6\u04c0\7\13\2\2\u04b7"+
"\u04c0\7\n\2\2\u04b8\u04c0\5\u00a2R\2\u04b9\u04c0\7H\2\2\u04ba\u04c0\7"+
"f\2\2\u04bb\u04c0\7+\2\2\u04bc\u04c0\5\u00a4S\2\u04bd\u04c0\5\u00a6T\2"+
"\u04be\u04c0\5\u00a8U\2\u04bf\u04b6\3\2\2\2\u04bf\u04b7\3\2\2\2\u04bf"+
"\u04b8\3\2\2\2\u04bf\u04b9\3\2\2\2\u04bf\u04ba\3\2\2\2\u04bf\u04bb\3\2"+
"\2\2\u04bf\u04bc\3\2\2\2\u04bf\u04bd\3\2\2\2\u04bf\u04be\3\2\2\2\u04c0"+
"\u00a1\3\2\2\2\u04c1\u04c3\t\r\2\2\u04c2\u04c1\3\2\2\2\u04c2\u04c3\3\2"+
"\2\2\u04c3\u04c4\3\2\2\2\u04c4\u04da\7\4\2\2\u04c5\u04c7\t\r\2\2\u04c6"+
"\u04c5\3\2\2\2\u04c6\u04c7\3\2\2\2\u04c7\u04c8\3\2\2\2\u04c8\u04da\7\6"+
"\2\2\u04c9\u04cb\t\r\2\2\u04ca\u04c9\3\2\2\2\u04ca\u04cb\3\2\2\2\u04cb"+
"\u04cc\3\2\2\2\u04cc\u04da\7\5\2\2\u04cd\u04cf\t\r\2\2\u04ce\u04cd\3\2"+
"\2\2\u04ce\u04cf\3\2\2\2\u04cf\u04d0\3\2\2\2\u04d0\u04da\7\7\2\2\u04d1"+
"\u04d3\t\r\2\2\u04d2\u04d1\3\2\2\2\u04d2\u04d3\3\2\2\2\u04d3\u04d4\3\2"+
"\2\2\u04d4\u04da\7\b\2\2\u04d5\u04d7\t\r\2\2\u04d6\u04d5\3\2\2\2\u04d6"+
"\u04d7\3\2\2\2\u04d7\u04d8\3\2\2\2\u04d8\u04da\7\t\2\2\u04d9\u04c2\3\2"+
"\2\2\u04d9\u04c6\3\2\2\2\u04d9\u04ca\3\2\2\2\u04d9\u04ce\3\2\2\2\u04d9"+
"\u04d2\3\2\2\2\u04d9\u04d6\3\2\2\2\u04da\u00a3\3\2\2\2\u04db\u04dc\7r"+
"\2\2\u04dc\u04dd\5\u00aaV\2\u04dd\u04de\7u\2\2\u04de\u00a5\3\2\2\2\u04df"+
"\u04e0\7s\2\2\u04e0\u04e1\5\u00aaV\2\u04e1\u04e2\7u\2\2\u04e2\u00a7\3"+
"\2\2\2\u04e3\u04e4\7t\2\2\u04e4\u04e5\5\u00aaV\2\u04e5\u04e6\7u\2\2\u04e6"+
"\u00a9\3\2\2\2\u04e7\u04e8\t\17\2\2\u04e8\u00ab\3\2\2\2\u04e9\u04ea\7"+
"\u0087\2\2\u04ea\u04ee\5\u00b4[\2\u04eb\u04ec\7\u0089\2\2\u04ec\u04ee"+
"\7\4\2\2\u04ed\u04e9\3\2\2\2\u04ed\u04eb\3\2\2\2\u04ee\u00ad\3\2\2\2\u04ef"+
"\u04f0\7e\2\2\u04f0\u04f2\7~\2\2\u04f1\u04f3\5\u00b0Y\2\u04f2\u04f1\3"+
"\2\2\2\u04f2\u04f3\3\2\2\2\u04f3\u04f5\3\2\2\2\u04f4\u04f6\5\u00b2Z\2"+
"\u04f5\u04f4\3\2\2\2\u04f5\u04f6\3\2\2\2\u04f6\u04f8\3\2\2\2\u04f7\u04f9"+
"\7\60\2\2\u04f8\u04f7\3\2\2\2\u04f8\u04f9\3\2\2\2\u04f9\u04fa\3\2\2\2"+
"\u04fa\u04fb\5\u0090I\2\u04fb\u04fc\7\177\2\2\u04fc\u0547\3\2\2\2\u04fd"+
"\u0500\t\13\2\2\u04fe\u04ff\7~\2\2\u04ff\u0501\7\177\2\2\u0500\u04fe\3"+
"\2\2\2\u0500\u0501\3\2\2\2\u0501\u0547\3\2\2\2\u0502\u0503\7\31\2\2\u0503"+
"\u0509\7~\2\2\u0504\u0506\7\"\2\2\u0505\u0504\3\2\2\2\u0505\u0506\3\2"+
"\2\2\u0506\u0507\3\2\2\2\u0507\u050a\5\u0090I\2\u0508\u050a\7\u0084\2"+
"\2\u0509\u0505\3\2\2\2\u0509\u0508\3\2\2\2\u050a\u050b\3\2\2\2\u050b\u0511"+
"\7\177\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\u00b4"+
"[\2\u0515\u0516\7~\2\2\u0516\u0517\5v<\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\u0547\3\2\2\2\u051d\u051e\5\u00b4"+
"[\2\u051e\u0520\7~\2\2\u051f\u0521\7\"\2\2\u0520\u051f\3\2\2\2\u0520\u0521"+
"\3\2\2\2\u0521\u052a\3\2\2\2\u0522\u0527\5\u0090I\2\u0523\u0524\7|\2\2"+
"\u0524\u0526\5\u0090I\2\u0525\u0523\3\2\2\2\u0526\u0529\3\2\2\2\u0527"+
"\u0525\3\2\2\2\u0527\u0528\3\2\2\2\u0528\u052b\3\2\2\2\u0529\u0527\3\2"+
"\2\2\u052a\u0522\3\2\2\2\u052a\u052b\3\2\2\2\u052b\u052c\3\2\2\2\u052c"+
"\u0533\7\177\2\2\u052d\u052e\7q\2\2\u052e\u052f\7\62\2\2\u052f\u0530\7"+
"~\2\2\u0530\u0531\5p9\2\u0531\u0532\7\177\2\2\u0532\u0534\3\2\2\2\u0533"+
"\u052d\3\2\2\2\u0533\u0534\3\2\2\2\u0534\u053a\3\2\2\2\u0535\u0536\7-"+
"\2\2\u0536\u0537\7~\2\2\u0537\u0538\5\u008eH\2\u0538\u0539\7\177\2\2\u0539"+
"\u053b\3\2\2\2\u053a\u0535\3\2\2\2\u053a\u053b\3\2\2\2\u053b\u0544\3\2"+
"\2\2\u053c\u0542\7S\2\2\u053d\u0543\5\u00b4[\2\u053e\u053f\7~\2\2\u053f"+
"\u0540\5v<\2\u0540\u0541\7\177\2\2\u0541\u0543\3\2\2\2\u0542\u053d\3\2"+
"\2\2\u0542\u053e\3\2\2\2\u0543\u0545\3\2\2\2\u0544\u053c\3\2\2\2\u0544"+
"\u0545\3\2\2\2\u0545\u0547\3\2\2\2\u0546\u04ef\3\2\2\2\u0546\u04fd\3\2"+
"\2\2\u0546\u0502\3\2\2\2\u0546\u051d\3\2\2\2\u0547\u00af\3\2\2\2\u0548"+
"\u0549\t\20\2\2\u0549\u00b1\3\2\2\2\u054a\u054e\7\n\2\2\u054b\u054e\7"+
"\13\2\2\u054c\u054e\5\u00acW\2\u054d\u054a\3\2\2\2\u054d\u054b\3\2\2\2"+
"\u054d\u054c\3\2\2\2\u054e\u00b3\3\2\2\2\u054f\u0550\t\21\2\2\u0550\u00b5"+
"\3\2\2\2\u0551\u0555\5\u00b4[\2\u0552\u0555\7f\2\2\u0553\u0555\7+\2\2"+
"\u0554\u0551\3\2\2\2\u0554\u0552\3\2\2\2\u0554\u0553\3\2\2\2\u0555\u00b7"+
"\3\2\2\2\u00b2\u00ba\u00bd\u00ce\u00d9\u00df\u00eb\u00f8\u0100\u0104\u010c"+
"\u0110\u0115\u0118\u011b\u011e\u0122\u0125\u0128\u012d\u0130\u0134\u013b"+
"\u013e\u0141\u0144\u0148\u014f\u0152\u015f\u0163\u0166\u016f\u0174\u0181"+
"\u0189\u0194\u0198\u019c\u019f\u01a2\u01a5\u01a8\u01ac\u01af\u01b2\u01b5"+
"\u01b8\u01c0\u01c9\u01d0\u01d2\u01d9\u01db\u01e0\u01f1\u01fd\u020a\u0215"+
"\u0217\u021f\u0229\u0235\u023a\u023e\u0244\u0248\u0252\u0255\u0258\u025b"+
"\u025e\u0260\u0267\u026e\u0273\u027a\u027f\u0287\u028c\u029b\u02aa\u02ad"+
"\u02b6\u02b9\u02c1\u02d6\u02dd\u02e6\u02e8\u02f1\u0300\u0306\u030b\u030d"+
"\u031e\u0322\u0325\u0328\u032b\u0334\u033a\u0342\u0344\u0350\u035e\u036a"+
"\u0376\u037a\u0385\u038a\u038e\u0395\u03a5\u03a9\u03b1\u03b5\u03c3\u03ce"+
"\u03d0\u03db\u03e3\u03e8\u03ef\u03f6\u03fd\u0402\u0409\u040e\u0415\u041a"+
"\u0421\u0426\u042d\u0432\u0439\u0455\u045c\u0465\u046b\u046f\u0475\u047d"+
"\u047f\u0484\u048c\u0492\u0498\u04b4\u04bf\u04c2\u04c6\u04ca\u04ce\u04d2"+
"\u04d6\u04d9\u04ed\u04f2\u04f5\u04f8\u0500\u0505\u0509\u0511\u0519\u051b"+
"\u0520\u0527\u052a\u0533\u053a\u0542\u0544\u0546\u054d\u0554";
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);
}
}
}
