com.github.harbby.dsxparser.antlr4.SqlBaseParser Maven / Gradle / Ivy
The newest version!
// Generated from com/github/harbby/dsxparser/antlr4/SqlBase.g4 by ANTLR 4.13.1
package com.github.harbby.dsxparser.antlr4;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"})
public class SqlBaseParser extends Parser {
static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, IN=8, ADD=9, ALL=10,
ALTER=11, ANALYZE=12, AND=13, ANY=14, ARRAY=15, AS=16, ASC=17, AT=18,
BERNOULLI=19, BETWEEN=20, BY=21, CALL=22, CASCADE=23, CASE=24, CAST=25,
CATALOGS=26, COLUMN=27, COLUMNS=28, COMMENT=29, COMMIT=30, COMMITTED=31,
CONSTRAINT=32, CREATE=33, CROSS=34, CUBE=35, CURRENT=36, CURRENT_PATH=37,
CURRENT_USER=38, DATA=39, DATE=40, DAY=41, DEALLOCATE=42, DELETE=43, DESC=44,
DESCRIBE=45, DISTINCT=46, DISTRIBUTED=47, DROP=48, ELSE=49, END=50, ESCAPE=51,
EXCEPT=52, EXCLUDING=53, EXECUTE=54, EXISTS=55, EXPLAIN=56, FALSE=57,
FILTER=58, FIRST=59, FOLLOWING=60, FOR=61, FORMAT=62, FROM=63, WINDOW=64,
SECONDS=65, LATE=66, DELAY=67, EVERY=68, TRIGGER=69, BATCH=70, FUNCTION=71,
EXTEND=72, WATERMARK=73, FULL=74, FUNCTIONS=75, GRANT=76, GRANTS=77, GRAPHVIZ=78,
HOUR=79, IF=80, INCLUDING=81, INNER=82, INPUT=83, INSERT=84, INTERSECT=85,
INTERVAL=86, INTO=87, IS=88, ISOLATION=89, JOIN=90, LAST=91, LATERAL=92,
LEVEL=93, LIKE=94, LIMIT=95, LOCALTIME=96, LOCALTIMESTAMP=97, LOGICAL=98,
MAP=99, MINUTE=100, MONTH=101, NATURAL=102, NFC=103, NFD=104, NFKC=105,
NFKD=106, NO=107, NORMALIZE=108, NOT=109, NULL=110, NULLIF=111, NULLS=112,
ON=113, ONLY=114, OPTION=115, OR=116, ORDER=117, ORDINALITY=118, OUTER=119,
OUTPUT=120, OVER=121, PARTITION=122, PARTITIONS=123, PATH=124, POSITION=125,
PRECEDING=126, PREPARE=127, PRIVILEGES=128, PROPERTIES=129, PUBLIC=130,
RANGE=131, READ=132, RECURSIVE=133, RENAME=134, REPEATABLE=135, REPLACE=136,
RESET=137, RESTRICT=138, REVOKE=139, ROLLBACK=140, ROLLUP=141, ROW=142,
ROWS=143, SCHEMA=144, SCHEMAS=145, SECOND=146, SELECT=147, SERIALIZABLE=148,
SESSION=149, SET=150, SETS=151, SHOW=152, SOME=153, START=154, STATS=155,
SUBSTRING=156, SYSTEM=157, TABLE=158, TABLES=159, TABLESAMPLE=160, TEXT=161,
THEN=162, TIME=163, TIMESTAMP=164, TO=165, TRANSACTION=166, TRUE=167,
TRY_CAST=168, TYPE=169, UESCAPE=170, UNBOUNDED=171, UNCOMMITTED=172, UNION=173,
UNNEST=174, USE=175, USING=176, VALIDATE=177, VALUES=178, VERBOSE=179,
VIEW=180, WHEN=181, WHERE=182, WITH=183, WORK=184, WRITE=185, YEAR=186,
ZONE=187, EQ=188, NEQ=189, LT=190, LTE=191, GT=192, GTE=193, PLUS=194,
MINUS=195, ASTERISK=196, SLASH=197, PERCENT=198, CONCAT=199, STRING=200,
UNICODE_STRING=201, BINARY_LITERAL=202, INTEGER_VALUE=203, DECIMAL_VALUE=204,
DOUBLE_VALUE=205, IDENTIFIER=206, DIGIT_IDENTIFIER=207, QUOTED_IDENTIFIER=208,
BACKQUOTED_IDENTIFIER=209, TIME_WITH_TIME_ZONE=210, TIMESTAMP_WITH_TIME_ZONE=211,
DOUBLE_PRECISION=212, SIMPLE_COMMENT=213, BRACKETED_COMMENT=214, WS=215,
UNRECOGNIZED=216, DELIMITER=217;
public static final int
RULE_singleExpression = 0, RULE_sampleType = 1, RULE_expression = 2, RULE_whenClause = 3,
RULE_booleanExpression = 4, RULE_predicate = 5, RULE_valueExpression = 6,
RULE_setQuantifier = 7, RULE_primaryExpression = 8, RULE_string = 9, RULE_comparisonOperator = 10,
RULE_comparisonQuantifier = 11, RULE_booleanValue = 12, RULE_normalForm = 13,
RULE_type = 14, RULE_typeParameter = 15, RULE_baseType = 16, RULE_pathElement = 17,
RULE_pathSpecification = 18, RULE_privilege = 19, RULE_qualifiedName = 20,
RULE_identifier = 21, RULE_number = 22, RULE_nonReserved = 23;
private static String[] makeRuleNames() {
return new String[] {
"singleExpression", "sampleType", "expression", "whenClause", "booleanExpression",
"predicate", "valueExpression", "setQuantifier", "primaryExpression",
"string", "comparisonOperator", "comparisonQuantifier", "booleanValue",
"normalForm", "type", "typeParameter", "baseType", "pathElement", "pathSpecification",
"privilege", "qualifiedName", "identifier", "number", "nonReserved"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, "'('", "','", "')'", "'?'", "'['", "']'", "'.'", "'IN'", "'ADD'",
"'ALL'", "'ALTER'", "'ANALYZE'", "'AND'", "'ANY'", "'ARRAY'", "'AS'",
"'ASC'", "'AT'", "'BERNOULLI'", "'BETWEEN'", "'BY'", "'CALL'", "'CASCADE'",
"'CASE'", "'CAST'", "'CATALOGS'", "'COLUMN'", "'COLUMNS'", "'COMMENT'",
"'COMMIT'", "'COMMITTED'", "'CONSTRAINT'", "'CREATE'", "'CROSS'", "'CUBE'",
"'CURRENT'", "'CURRENT_PATH'", "'CURRENT_USER'", "'DATA'", "'DATE'",
"'DAY'", "'DEALLOCATE'", "'DELETE'", "'DESC'", "'DESCRIBE'", "'DISTINCT'",
"'DISTRIBUTED'", "'DROP'", "'ELSE'", "'END'", "'ESCAPE'", "'EXCEPT'",
"'EXCLUDING'", "'EXECUTE'", "'EXISTS'", "'EXPLAIN'", "'FALSE'", "'FILTER'",
"'FIRST'", "'FOLLOWING'", "'FOR'", "'FORMAT'", "'FROM'", "'WINDOW'",
"'SECONDS'", "'LATE'", "'DELAY'", "'EVERY'", "'TRIGGER'", "'BATCH'",
"'FUNCTION'", "'EXTEND'", "'WATERMARK'", "'FULL'", "'FUNCTIONS'", "'GRANT'",
"'GRANTS'", "'GRAPHVIZ'", "'HOUR'", "'IF'", "'INCLUDING'", "'INNER'",
"'INPUT'", "'INSERT'", "'INTERSECT'", "'INTERVAL'", "'INTO'", "'IS'",
"'ISOLATION'", "'JOIN'", "'LAST'", "'LATERAL'", "'LEVEL'", "'LIKE'",
"'LIMIT'", "'LOCALTIME'", "'LOCALTIMESTAMP'", "'LOGICAL'", "'MAP'", "'MINUTE'",
"'MONTH'", "'NATURAL'", "'NFC'", "'NFD'", "'NFKC'", "'NFKD'", "'NO'",
"'NORMALIZE'", "'NOT'", "'NULL'", "'NULLIF'", "'NULLS'", "'ON'", "'ONLY'",
"'OPTION'", "'OR'", "'ORDER'", "'ORDINALITY'", "'OUTER'", "'OUTPUT'",
"'OVER'", "'PARTITION'", "'PARTITIONS'", "'PATH'", "'POSITION'", "'PRECEDING'",
"'PREPARE'", "'PRIVILEGES'", "'PROPERTIES'", "'PUBLIC'", "'RANGE'", "'READ'",
"'RECURSIVE'", "'RENAME'", "'REPEATABLE'", "'REPLACE'", "'RESET'", "'RESTRICT'",
"'REVOKE'", "'ROLLBACK'", "'ROLLUP'", "'ROW'", "'ROWS'", "'SCHEMA'",
"'SCHEMAS'", "'SECOND'", "'SELECT'", "'SERIALIZABLE'", "'SESSION'", "'SET'",
"'SETS'", "'SHOW'", "'SOME'", "'START'", "'STATS'", "'SUBSTRING'", "'SYSTEM'",
"'TABLE'", "'TABLES'", "'TABLESAMPLE'", "'TEXT'", "'THEN'", "'TIME'",
"'TIMESTAMP'", "'TO'", "'TRANSACTION'", "'TRUE'", "'TRY_CAST'", "'TYPE'",
"'UESCAPE'", "'UNBOUNDED'", "'UNCOMMITTED'", "'UNION'", "'UNNEST'", "'USE'",
"'USING'", "'VALIDATE'", "'VALUES'", "'VERBOSE'", "'VIEW'", "'WHEN'",
"'WHERE'", "'WITH'", "'WORK'", "'WRITE'", "'YEAR'", "'ZONE'", "'='",
null, "'<'", "'<='", "'>'", "'>='", "'+'", "'-'", "'*'", "'/'", "'%'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, null, null, null, null, null, null, null, "IN", "ADD", "ALL", "ALTER",
"ANALYZE", "AND", "ANY", "ARRAY", "AS", "ASC", "AT", "BERNOULLI", "BETWEEN",
"BY", "CALL", "CASCADE", "CASE", "CAST", "CATALOGS", "COLUMN", "COLUMNS",
"COMMENT", "COMMIT", "COMMITTED", "CONSTRAINT", "CREATE", "CROSS", "CUBE",
"CURRENT", "CURRENT_PATH", "CURRENT_USER", "DATA", "DATE", "DAY", "DEALLOCATE",
"DELETE", "DESC", "DESCRIBE", "DISTINCT", "DISTRIBUTED", "DROP", "ELSE",
"END", "ESCAPE", "EXCEPT", "EXCLUDING", "EXECUTE", "EXISTS", "EXPLAIN",
"FALSE", "FILTER", "FIRST", "FOLLOWING", "FOR", "FORMAT", "FROM", "WINDOW",
"SECONDS", "LATE", "DELAY", "EVERY", "TRIGGER", "BATCH", "FUNCTION",
"EXTEND", "WATERMARK", "FULL", "FUNCTIONS", "GRANT", "GRANTS", "GRAPHVIZ",
"HOUR", "IF", "INCLUDING", "INNER", "INPUT", "INSERT", "INTERSECT", "INTERVAL",
"INTO", "IS", "ISOLATION", "JOIN", "LAST", "LATERAL", "LEVEL", "LIKE",
"LIMIT", "LOCALTIME", "LOCALTIMESTAMP", "LOGICAL", "MAP", "MINUTE", "MONTH",
"NATURAL", "NFC", "NFD", "NFKC", "NFKD", "NO", "NORMALIZE", "NOT", "NULL",
"NULLIF", "NULLS", "ON", "ONLY", "OPTION", "OR", "ORDER", "ORDINALITY",
"OUTER", "OUTPUT", "OVER", "PARTITION", "PARTITIONS", "PATH", "POSITION",
"PRECEDING", "PREPARE", "PRIVILEGES", "PROPERTIES", "PUBLIC", "RANGE",
"READ", "RECURSIVE", "RENAME", "REPEATABLE", "REPLACE", "RESET", "RESTRICT",
"REVOKE", "ROLLBACK", "ROLLUP", "ROW", "ROWS", "SCHEMA", "SCHEMAS", "SECOND",
"SELECT", "SERIALIZABLE", "SESSION", "SET", "SETS", "SHOW", "SOME", "START",
"STATS", "SUBSTRING", "SYSTEM", "TABLE", "TABLES", "TABLESAMPLE", "TEXT",
"THEN", "TIME", "TIMESTAMP", "TO", "TRANSACTION", "TRUE", "TRY_CAST",
"TYPE", "UESCAPE", "UNBOUNDED", "UNCOMMITTED", "UNION", "UNNEST", "USE",
"USING", "VALIDATE", "VALUES", "VERBOSE", "VIEW", "WHEN", "WHERE", "WITH",
"WORK", "WRITE", "YEAR", "ZONE", "EQ", "NEQ", "LT", "LTE", "GT", "GTE",
"PLUS", "MINUS", "ASTERISK", "SLASH", "PERCENT", "CONCAT", "STRING",
"UNICODE_STRING", "BINARY_LITERAL", "INTEGER_VALUE", "DECIMAL_VALUE",
"DOUBLE_VALUE", "IDENTIFIER", "DIGIT_IDENTIFIER", "QUOTED_IDENTIFIER",
"BACKQUOTED_IDENTIFIER", "TIME_WITH_TIME_ZONE", "TIMESTAMP_WITH_TIME_ZONE",
"DOUBLE_PRECISION", "SIMPLE_COMMENT", "BRACKETED_COMMENT", "WS", "UNRECOGNIZED",
"DELIMITER"
};
}
private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
/**
* @deprecated Use {@link #VOCABULARY} instead.
*/
@Deprecated
public static final String[] tokenNames;
static {
tokenNames = new String[_SYMBOLIC_NAMES.length];
for (int i = 0; i < tokenNames.length; i++) {
tokenNames[i] = VOCABULARY.getLiteralName(i);
if (tokenNames[i] == null) {
tokenNames[i] = VOCABULARY.getSymbolicName(i);
}
if (tokenNames[i] == null) {
tokenNames[i] = "";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "SqlBase.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public SqlBaseParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
@SuppressWarnings("CheckReturnValue")
public static class SingleExpressionContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode EOF() { return getToken(SqlBaseParser.EOF, 0); }
public SingleExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_singleExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterSingleExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitSingleExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitSingleExpression(this);
else return visitor.visitChildren(this);
}
}
public final SingleExpressionContext singleExpression() throws RecognitionException {
SingleExpressionContext _localctx = new SingleExpressionContext(_ctx, getState());
enterRule(_localctx, 0, RULE_singleExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(48);
expression();
setState(49);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SampleTypeContext extends ParserRuleContext {
public TerminalNode BERNOULLI() { return getToken(SqlBaseParser.BERNOULLI, 0); }
public TerminalNode SYSTEM() { return getToken(SqlBaseParser.SYSTEM, 0); }
public SampleTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sampleType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterSampleType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitSampleType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitSampleType(this);
else return visitor.visitChildren(this);
}
}
public final SampleTypeContext sampleType() throws RecognitionException {
SampleTypeContext _localctx = new SampleTypeContext(_ctx, getState());
enterRule(_localctx, 2, RULE_sampleType);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(51);
_la = _input.LA(1);
if ( !(_la==BERNOULLI || _la==SYSTEM) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ExpressionContext extends ParserRuleContext {
public BooleanExpressionContext booleanExpression() {
return getRuleContext(BooleanExpressionContext.class,0);
}
public ExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitExpression(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionContext expression() throws RecognitionException {
ExpressionContext _localctx = new ExpressionContext(_ctx, getState());
enterRule(_localctx, 4, RULE_expression);
try {
enterOuterAlt(_localctx, 1);
{
setState(53);
booleanExpression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class WhenClauseContext extends ParserRuleContext {
public BooleanExpressionContext condition;
public ExpressionContext result;
public TerminalNode WHEN() { return getToken(SqlBaseParser.WHEN, 0); }
public TerminalNode THEN() { return getToken(SqlBaseParser.THEN, 0); }
public BooleanExpressionContext booleanExpression() {
return getRuleContext(BooleanExpressionContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode ELSE() { return getToken(SqlBaseParser.ELSE, 0); }
public TerminalNode IF() { return getToken(SqlBaseParser.IF, 0); }
public WhenClauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_whenClause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterWhenClause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitWhenClause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitWhenClause(this);
else return visitor.visitChildren(this);
}
}
public final WhenClauseContext whenClause() throws RecognitionException {
WhenClauseContext _localctx = new WhenClauseContext(_ctx, getState());
enterRule(_localctx, 6, RULE_whenClause);
try {
setState(63);
_errHandler.sync(this);
switch (_input.LA(1)) {
case WHEN:
enterOuterAlt(_localctx, 1);
{
setState(55);
match(WHEN);
}
break;
case ELSE:
enterOuterAlt(_localctx, 2);
{
{
setState(56);
match(ELSE);
setState(57);
match(IF);
}
setState(59);
((WhenClauseContext)_localctx).condition = booleanExpression(0);
setState(60);
match(THEN);
setState(61);
((WhenClauseContext)_localctx).result = expression();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class BooleanExpressionContext extends ParserRuleContext {
public BooleanExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_booleanExpression; }
public BooleanExpressionContext() { }
public void copyFrom(BooleanExpressionContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class LogicalNotContext extends BooleanExpressionContext {
public TerminalNode NOT() { return getToken(SqlBaseParser.NOT, 0); }
public BooleanExpressionContext booleanExpression() {
return getRuleContext(BooleanExpressionContext.class,0);
}
public LogicalNotContext(BooleanExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterLogicalNot(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitLogicalNot(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitLogicalNot(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PredicatedContext extends BooleanExpressionContext {
public ValueExpressionContext valueExpression;
public ValueExpressionContext valueExpression() {
return getRuleContext(ValueExpressionContext.class,0);
}
public PredicateContext predicate() {
return getRuleContext(PredicateContext.class,0);
}
public PredicatedContext(BooleanExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterPredicated(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitPredicated(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitPredicated(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class LogicalBinaryContext extends BooleanExpressionContext {
public BooleanExpressionContext left;
public Token operator;
public BooleanExpressionContext right;
public List booleanExpression() {
return getRuleContexts(BooleanExpressionContext.class);
}
public BooleanExpressionContext booleanExpression(int i) {
return getRuleContext(BooleanExpressionContext.class,i);
}
public TerminalNode AND() { return getToken(SqlBaseParser.AND, 0); }
public TerminalNode OR() { return getToken(SqlBaseParser.OR, 0); }
public LogicalBinaryContext(BooleanExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterLogicalBinary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitLogicalBinary(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitLogicalBinary(this);
else return visitor.visitChildren(this);
}
}
public final BooleanExpressionContext booleanExpression() throws RecognitionException {
return booleanExpression(0);
}
private BooleanExpressionContext booleanExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
BooleanExpressionContext _localctx = new BooleanExpressionContext(_ctx, _parentState);
BooleanExpressionContext _prevctx = _localctx;
int _startState = 8;
enterRecursionRule(_localctx, 8, RULE_booleanExpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(72);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__0:
case T__3:
case IN:
case ADD:
case ALL:
case ANALYZE:
case ANY:
case ARRAY:
case ASC:
case AT:
case BERNOULLI:
case CALL:
case CASCADE:
case CATALOGS:
case COLUMN:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case CURRENT:
case CURRENT_PATH:
case CURRENT_USER:
case DATA:
case DATE:
case DAY:
case DELETE:
case DESC:
case DISTRIBUTED:
case EXCLUDING:
case EXPLAIN:
case FALSE:
case FILTER:
case FIRST:
case FOLLOWING:
case FORMAT:
case FUNCTIONS:
case GRANT:
case GRANTS:
case GRAPHVIZ:
case HOUR:
case IF:
case INCLUDING:
case INPUT:
case INSERT:
case INTERVAL:
case ISOLATION:
case LAST:
case LATERAL:
case LEVEL:
case LIMIT:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOGICAL:
case MAP:
case MINUTE:
case MONTH:
case NFC:
case NFD:
case NFKC:
case NFKD:
case NO:
case NORMALIZE:
case NULL:
case NULLIF:
case NULLS:
case ONLY:
case OPTION:
case ORDINALITY:
case OUTPUT:
case OVER:
case PARTITION:
case PARTITIONS:
case PATH:
case POSITION:
case PRECEDING:
case PRIVILEGES:
case PROPERTIES:
case PUBLIC:
case RANGE:
case READ:
case RENAME:
case REPEATABLE:
case REPLACE:
case RESET:
case RESTRICT:
case REVOKE:
case ROLLBACK:
case ROW:
case ROWS:
case SCHEMA:
case SCHEMAS:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SET:
case SETS:
case SHOW:
case SOME:
case START:
case STATS:
case SUBSTRING:
case SYSTEM:
case TABLE:
case TABLES:
case TABLESAMPLE:
case TEXT:
case TIME:
case TIMESTAMP:
case TO:
case TRANSACTION:
case TRUE:
case TRY_CAST:
case TYPE:
case UNBOUNDED:
case UNCOMMITTED:
case USE:
case VALIDATE:
case VERBOSE:
case VIEW:
case WORK:
case WRITE:
case YEAR:
case ZONE:
case PLUS:
case MINUS:
case STRING:
case UNICODE_STRING:
case BINARY_LITERAL:
case INTEGER_VALUE:
case DECIMAL_VALUE:
case DOUBLE_VALUE:
case IDENTIFIER:
case DIGIT_IDENTIFIER:
case QUOTED_IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
case DOUBLE_PRECISION:
{
_localctx = new PredicatedContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(66);
((PredicatedContext)_localctx).valueExpression = valueExpression(0);
setState(68);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) {
case 1:
{
setState(67);
predicate(((PredicatedContext)_localctx).valueExpression);
}
break;
}
}
break;
case NOT:
{
_localctx = new LogicalNotContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(70);
match(NOT);
setState(71);
booleanExpression(3);
}
break;
default:
throw new NoViableAltException(this);
}
_ctx.stop = _input.LT(-1);
setState(82);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,4,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(80);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
case 1:
{
_localctx = new LogicalBinaryContext(new BooleanExpressionContext(_parentctx, _parentState));
((LogicalBinaryContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_booleanExpression);
setState(74);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(75);
((LogicalBinaryContext)_localctx).operator = match(AND);
setState(76);
((LogicalBinaryContext)_localctx).right = booleanExpression(3);
}
break;
case 2:
{
_localctx = new LogicalBinaryContext(new BooleanExpressionContext(_parentctx, _parentState));
((LogicalBinaryContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_booleanExpression);
setState(77);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(78);
((LogicalBinaryContext)_localctx).operator = match(OR);
setState(79);
((LogicalBinaryContext)_localctx).right = booleanExpression(2);
}
break;
}
}
}
setState(84);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,4,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PredicateContext extends ParserRuleContext {
public ParserRuleContext value;
public PredicateContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); }
public PredicateContext(ParserRuleContext parent, int invokingState, ParserRuleContext value) {
super(parent, invokingState);
this.value = value;
}
@Override public int getRuleIndex() { return RULE_predicate; }
public PredicateContext() { }
public void copyFrom(PredicateContext ctx) {
super.copyFrom(ctx);
this.value = ctx.value;
}
}
@SuppressWarnings("CheckReturnValue")
public static class ComparisonContext extends PredicateContext {
public ValueExpressionContext right;
public ComparisonOperatorContext comparisonOperator() {
return getRuleContext(ComparisonOperatorContext.class,0);
}
public ValueExpressionContext valueExpression() {
return getRuleContext(ValueExpressionContext.class,0);
}
public ComparisonContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterComparison(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitComparison(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitComparison(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class InListContext extends PredicateContext {
public TerminalNode IN() { return getToken(SqlBaseParser.IN, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public TerminalNode NOT() { return getToken(SqlBaseParser.NOT, 0); }
public InListContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterInList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitInList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitInList(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class NullPredicateContext extends PredicateContext {
public TerminalNode IS() { return getToken(SqlBaseParser.IS, 0); }
public TerminalNode NULL() { return getToken(SqlBaseParser.NULL, 0); }
public TerminalNode NOT() { return getToken(SqlBaseParser.NOT, 0); }
public NullPredicateContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterNullPredicate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitNullPredicate(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitNullPredicate(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class BetweenContext extends PredicateContext {
public ValueExpressionContext lower;
public ValueExpressionContext upper;
public TerminalNode BETWEEN() { return getToken(SqlBaseParser.BETWEEN, 0); }
public TerminalNode AND() { return getToken(SqlBaseParser.AND, 0); }
public List valueExpression() {
return getRuleContexts(ValueExpressionContext.class);
}
public ValueExpressionContext valueExpression(int i) {
return getRuleContext(ValueExpressionContext.class,i);
}
public TerminalNode NOT() { return getToken(SqlBaseParser.NOT, 0); }
public BetweenContext(PredicateContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterBetween(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitBetween(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitBetween(this);
else return visitor.visitChildren(this);
}
}
public final PredicateContext predicate(ParserRuleContext value) throws RecognitionException {
PredicateContext _localctx = new PredicateContext(_ctx, getState(), value);
enterRule(_localctx, 10, RULE_predicate);
int _la;
try {
setState(116);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
case 1:
_localctx = new ComparisonContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(85);
comparisonOperator();
setState(86);
((ComparisonContext)_localctx).right = valueExpression(0);
}
break;
case 2:
_localctx = new BetweenContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(89);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(88);
match(NOT);
}
}
setState(91);
match(BETWEEN);
setState(92);
((BetweenContext)_localctx).lower = valueExpression(0);
setState(93);
match(AND);
setState(94);
((BetweenContext)_localctx).upper = valueExpression(0);
}
break;
case 3:
_localctx = new InListContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(97);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(96);
match(NOT);
}
}
setState(99);
match(IN);
setState(100);
match(T__0);
setState(101);
expression();
setState(106);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(102);
match(T__1);
setState(103);
expression();
}
}
setState(108);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(109);
match(T__2);
}
break;
case 4:
_localctx = new NullPredicateContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(111);
match(IS);
setState(113);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(112);
match(NOT);
}
}
setState(115);
match(NULL);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ValueExpressionContext extends ParserRuleContext {
public ValueExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_valueExpression; }
public ValueExpressionContext() { }
public void copyFrom(ValueExpressionContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ValueExpressionDefaultContext extends ValueExpressionContext {
public PrimaryExpressionContext primaryExpression() {
return getRuleContext(PrimaryExpressionContext.class,0);
}
public ValueExpressionDefaultContext(ValueExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterValueExpressionDefault(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitValueExpressionDefault(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitValueExpressionDefault(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ConcatenationContext extends ValueExpressionContext {
public ValueExpressionContext left;
public ValueExpressionContext right;
public TerminalNode CONCAT() { return getToken(SqlBaseParser.CONCAT, 0); }
public List valueExpression() {
return getRuleContexts(ValueExpressionContext.class);
}
public ValueExpressionContext valueExpression(int i) {
return getRuleContext(ValueExpressionContext.class,i);
}
public ConcatenationContext(ValueExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterConcatenation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitConcatenation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitConcatenation(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ArithmeticBinaryContext extends ValueExpressionContext {
public ValueExpressionContext left;
public Token operator;
public ValueExpressionContext right;
public List valueExpression() {
return getRuleContexts(ValueExpressionContext.class);
}
public ValueExpressionContext valueExpression(int i) {
return getRuleContext(ValueExpressionContext.class,i);
}
public TerminalNode ASTERISK() { return getToken(SqlBaseParser.ASTERISK, 0); }
public TerminalNode SLASH() { return getToken(SqlBaseParser.SLASH, 0); }
public TerminalNode PERCENT() { return getToken(SqlBaseParser.PERCENT, 0); }
public TerminalNode PLUS() { return getToken(SqlBaseParser.PLUS, 0); }
public TerminalNode MINUS() { return getToken(SqlBaseParser.MINUS, 0); }
public ArithmeticBinaryContext(ValueExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterArithmeticBinary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitArithmeticBinary(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitArithmeticBinary(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ArithmeticUnaryContext extends ValueExpressionContext {
public Token operator;
public ValueExpressionContext valueExpression() {
return getRuleContext(ValueExpressionContext.class,0);
}
public TerminalNode MINUS() { return getToken(SqlBaseParser.MINUS, 0); }
public TerminalNode PLUS() { return getToken(SqlBaseParser.PLUS, 0); }
public ArithmeticUnaryContext(ValueExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterArithmeticUnary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitArithmeticUnary(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitArithmeticUnary(this);
else return visitor.visitChildren(this);
}
}
public final ValueExpressionContext valueExpression() throws RecognitionException {
return valueExpression(0);
}
private ValueExpressionContext valueExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ValueExpressionContext _localctx = new ValueExpressionContext(_ctx, _parentState);
ValueExpressionContext _prevctx = _localctx;
int _startState = 12;
enterRecursionRule(_localctx, 12, RULE_valueExpression, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(122);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__0:
case T__3:
case IN:
case ADD:
case ALL:
case ANALYZE:
case ANY:
case ARRAY:
case ASC:
case AT:
case BERNOULLI:
case CALL:
case CASCADE:
case CATALOGS:
case COLUMN:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case CURRENT:
case CURRENT_PATH:
case CURRENT_USER:
case DATA:
case DATE:
case DAY:
case DELETE:
case DESC:
case DISTRIBUTED:
case EXCLUDING:
case EXPLAIN:
case FALSE:
case FILTER:
case FIRST:
case FOLLOWING:
case FORMAT:
case FUNCTIONS:
case GRANT:
case GRANTS:
case GRAPHVIZ:
case HOUR:
case IF:
case INCLUDING:
case INPUT:
case INSERT:
case INTERVAL:
case ISOLATION:
case LAST:
case LATERAL:
case LEVEL:
case LIMIT:
case LOCALTIME:
case LOCALTIMESTAMP:
case LOGICAL:
case MAP:
case MINUTE:
case MONTH:
case NFC:
case NFD:
case NFKC:
case NFKD:
case NO:
case NORMALIZE:
case NULL:
case NULLIF:
case NULLS:
case ONLY:
case OPTION:
case ORDINALITY:
case OUTPUT:
case OVER:
case PARTITION:
case PARTITIONS:
case PATH:
case POSITION:
case PRECEDING:
case PRIVILEGES:
case PROPERTIES:
case PUBLIC:
case RANGE:
case READ:
case RENAME:
case REPEATABLE:
case REPLACE:
case RESET:
case RESTRICT:
case REVOKE:
case ROLLBACK:
case ROW:
case ROWS:
case SCHEMA:
case SCHEMAS:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SET:
case SETS:
case SHOW:
case SOME:
case START:
case STATS:
case SUBSTRING:
case SYSTEM:
case TABLE:
case TABLES:
case TABLESAMPLE:
case TEXT:
case TIME:
case TIMESTAMP:
case TO:
case TRANSACTION:
case TRUE:
case TRY_CAST:
case TYPE:
case UNBOUNDED:
case UNCOMMITTED:
case USE:
case VALIDATE:
case VERBOSE:
case VIEW:
case WORK:
case WRITE:
case YEAR:
case ZONE:
case STRING:
case UNICODE_STRING:
case BINARY_LITERAL:
case INTEGER_VALUE:
case DECIMAL_VALUE:
case DOUBLE_VALUE:
case IDENTIFIER:
case DIGIT_IDENTIFIER:
case QUOTED_IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
case DOUBLE_PRECISION:
{
_localctx = new ValueExpressionDefaultContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(119);
primaryExpression(0);
}
break;
case PLUS:
case MINUS:
{
_localctx = new ArithmeticUnaryContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(120);
((ArithmeticUnaryContext)_localctx).operator = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==PLUS || _la==MINUS) ) {
((ArithmeticUnaryContext)_localctx).operator = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(121);
valueExpression(4);
}
break;
default:
throw new NoViableAltException(this);
}
_ctx.stop = _input.LT(-1);
setState(135);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(133);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
case 1:
{
_localctx = new ArithmeticBinaryContext(new ValueExpressionContext(_parentctx, _parentState));
((ArithmeticBinaryContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_valueExpression);
setState(124);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(125);
((ArithmeticBinaryContext)_localctx).operator = _input.LT(1);
_la = _input.LA(1);
if ( !(((((_la - 196)) & ~0x3f) == 0 && ((1L << (_la - 196)) & 7L) != 0)) ) {
((ArithmeticBinaryContext)_localctx).operator = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(126);
((ArithmeticBinaryContext)_localctx).right = valueExpression(4);
}
break;
case 2:
{
_localctx = new ArithmeticBinaryContext(new ValueExpressionContext(_parentctx, _parentState));
((ArithmeticBinaryContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_valueExpression);
setState(127);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(128);
((ArithmeticBinaryContext)_localctx).operator = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==PLUS || _la==MINUS) ) {
((ArithmeticBinaryContext)_localctx).operator = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(129);
((ArithmeticBinaryContext)_localctx).right = valueExpression(3);
}
break;
case 3:
{
_localctx = new ConcatenationContext(new ValueExpressionContext(_parentctx, _parentState));
((ConcatenationContext)_localctx).left = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_valueExpression);
setState(130);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(131);
match(CONCAT);
setState(132);
((ConcatenationContext)_localctx).right = valueExpression(2);
}
break;
}
}
}
setState(137);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SetQuantifierContext extends ParserRuleContext {
public TerminalNode DISTINCT() { return getToken(SqlBaseParser.DISTINCT, 0); }
public TerminalNode ALL() { return getToken(SqlBaseParser.ALL, 0); }
public SetQuantifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_setQuantifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterSetQuantifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitSetQuantifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitSetQuantifier(this);
else return visitor.visitChildren(this);
}
}
public final SetQuantifierContext setQuantifier() throws RecognitionException {
SetQuantifierContext _localctx = new SetQuantifierContext(_ctx, getState());
enterRule(_localctx, 14, RULE_setQuantifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(138);
_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();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PrimaryExpressionContext extends ParserRuleContext {
public PrimaryExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primaryExpression; }
public PrimaryExpressionContext() { }
public void copyFrom(PrimaryExpressionContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DereferenceContext extends PrimaryExpressionContext {
public PrimaryExpressionContext base;
public IdentifierContext fieldName;
public PrimaryExpressionContext primaryExpression() {
return getRuleContext(PrimaryExpressionContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public DereferenceContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterDereference(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitDereference(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitDereference(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ColumnReferenceContext extends PrimaryExpressionContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ColumnReferenceContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterColumnReference(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitColumnReference(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitColumnReference(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class NullLiteralContext extends PrimaryExpressionContext {
public TerminalNode NULL() { return getToken(SqlBaseParser.NULL, 0); }
public NullLiteralContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterNullLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitNullLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitNullLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SubscriptContext extends PrimaryExpressionContext {
public PrimaryExpressionContext value;
public ValueExpressionContext index;
public PrimaryExpressionContext primaryExpression() {
return getRuleContext(PrimaryExpressionContext.class,0);
}
public ValueExpressionContext valueExpression() {
return getRuleContext(ValueExpressionContext.class,0);
}
public SubscriptContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterSubscript(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitSubscript(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitSubscript(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class TypeConstructorContext extends PrimaryExpressionContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public StringContext string() {
return getRuleContext(StringContext.class,0);
}
public TerminalNode DOUBLE_PRECISION() { return getToken(SqlBaseParser.DOUBLE_PRECISION, 0); }
public TypeConstructorContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterTypeConstructor(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitTypeConstructor(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitTypeConstructor(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SpecialDateTimeFunctionContext extends PrimaryExpressionContext {
public Token name;
public Token precision;
public TerminalNode LOCALTIME() { return getToken(SqlBaseParser.LOCALTIME, 0); }
public TerminalNode INTEGER_VALUE() { return getToken(SqlBaseParser.INTEGER_VALUE, 0); }
public TerminalNode LOCALTIMESTAMP() { return getToken(SqlBaseParser.LOCALTIMESTAMP, 0); }
public SpecialDateTimeFunctionContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterSpecialDateTimeFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitSpecialDateTimeFunction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitSpecialDateTimeFunction(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CurrentPathContext extends PrimaryExpressionContext {
public Token name;
public TerminalNode CURRENT_PATH() { return getToken(SqlBaseParser.CURRENT_PATH, 0); }
public CurrentPathContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterCurrentPath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitCurrentPath(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitCurrentPath(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class Substring2Context extends PrimaryExpressionContext {
public PrimaryExpressionContext value;
public ValueExpressionContext pos;
public ValueExpressionContext len;
public PrimaryExpressionContext primaryExpression() {
return getRuleContext(PrimaryExpressionContext.class,0);
}
public List valueExpression() {
return getRuleContexts(ValueExpressionContext.class);
}
public ValueExpressionContext valueExpression(int i) {
return getRuleContext(ValueExpressionContext.class,i);
}
public Substring2Context(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterSubstring2(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitSubstring2(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitSubstring2(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class BinaryLiteralContext extends PrimaryExpressionContext {
public TerminalNode BINARY_LITERAL() { return getToken(SqlBaseParser.BINARY_LITERAL, 0); }
public BinaryLiteralContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterBinaryLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitBinaryLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitBinaryLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class CurrentUserContext extends PrimaryExpressionContext {
public Token name;
public TerminalNode CURRENT_USER() { return getToken(SqlBaseParser.CURRENT_USER, 0); }
public CurrentUserContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterCurrentUser(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitCurrentUser(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitCurrentUser(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ParenthesizedExpressionContext extends PrimaryExpressionContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ParenthesizedExpressionContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterParenthesizedExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitParenthesizedExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitParenthesizedExpression(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class StringLiteralContext extends PrimaryExpressionContext {
public StringContext string() {
return getRuleContext(StringContext.class,0);
}
public StringLiteralContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterStringLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitStringLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitStringLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ArrayConstructorContext extends PrimaryExpressionContext {
public TerminalNode ARRAY() { return getToken(SqlBaseParser.ARRAY, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public ArrayConstructorContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterArrayConstructor(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitArrayConstructor(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitArrayConstructor(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class ParameterContext extends PrimaryExpressionContext {
public ParameterContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitParameter(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitParameter(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class SimpleIfThenContext extends PrimaryExpressionContext {
public BooleanExpressionContext condition;
public ExpressionContext result;
public ExpressionContext elseExpression;
public TerminalNode IF() { return getToken(SqlBaseParser.IF, 0); }
public TerminalNode THEN() { return getToken(SqlBaseParser.THEN, 0); }
public TerminalNode ELSE() { return getToken(SqlBaseParser.ELSE, 0); }
public BooleanExpressionContext booleanExpression() {
return getRuleContext(BooleanExpressionContext.class,0);
}
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List whenClause() {
return getRuleContexts(WhenClauseContext.class);
}
public WhenClauseContext whenClause(int i) {
return getRuleContext(WhenClauseContext.class,i);
}
public SimpleIfThenContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterSimpleIfThen(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitSimpleIfThen(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitSimpleIfThen(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class FunctionCallContext extends PrimaryExpressionContext {
public QualifiedNameContext qualifiedName() {
return getRuleContext(QualifiedNameContext.class,0);
}
public TerminalNode ASTERISK() { return getToken(SqlBaseParser.ASTERISK, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public SetQuantifierContext setQuantifier() {
return getRuleContext(SetQuantifierContext.class,0);
}
public FunctionCallContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterFunctionCall(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitFunctionCall(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitFunctionCall(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class NormalizeContext extends PrimaryExpressionContext {
public TerminalNode NORMALIZE() { return getToken(SqlBaseParser.NORMALIZE, 0); }
public ValueExpressionContext valueExpression() {
return getRuleContext(ValueExpressionContext.class,0);
}
public NormalFormContext normalForm() {
return getRuleContext(NormalFormContext.class,0);
}
public NormalizeContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterNormalize(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitNormalize(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitNormalize(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class PositionContext extends PrimaryExpressionContext {
public TerminalNode POSITION() { return getToken(SqlBaseParser.POSITION, 0); }
public List valueExpression() {
return getRuleContexts(ValueExpressionContext.class);
}
public ValueExpressionContext valueExpression(int i) {
return getRuleContext(ValueExpressionContext.class,i);
}
public TerminalNode IN() { return getToken(SqlBaseParser.IN, 0); }
public PositionContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterPosition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitPosition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitPosition(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class NumericLiteralContext extends PrimaryExpressionContext {
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public NumericLiteralContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterNumericLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitNumericLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitNumericLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class BooleanLiteralContext extends PrimaryExpressionContext {
public BooleanValueContext booleanValue() {
return getRuleContext(BooleanValueContext.class,0);
}
public BooleanLiteralContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterBooleanLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitBooleanLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitBooleanLiteral(this);
else return visitor.visitChildren(this);
}
}
public final PrimaryExpressionContext primaryExpression() throws RecognitionException {
return primaryExpression(0);
}
private PrimaryExpressionContext primaryExpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
PrimaryExpressionContext _localctx = new PrimaryExpressionContext(_ctx, _parentState);
PrimaryExpressionContext _prevctx = _localctx;
int _startState = 16;
enterRecursionRule(_localctx, 16, RULE_primaryExpression, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(235);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) {
case 1:
{
_localctx = new NullLiteralContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(141);
match(NULL);
}
break;
case 2:
{
_localctx = new TypeConstructorContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(142);
identifier();
setState(143);
string();
}
break;
case 3:
{
_localctx = new TypeConstructorContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(145);
match(DOUBLE_PRECISION);
setState(146);
string();
}
break;
case 4:
{
_localctx = new NumericLiteralContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(147);
number();
}
break;
case 5:
{
_localctx = new BooleanLiteralContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(148);
booleanValue();
}
break;
case 6:
{
_localctx = new StringLiteralContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(149);
string();
}
break;
case 7:
{
_localctx = new BinaryLiteralContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(150);
match(BINARY_LITERAL);
}
break;
case 8:
{
_localctx = new ParameterContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(151);
match(T__3);
}
break;
case 9:
{
_localctx = new PositionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(152);
match(POSITION);
setState(153);
match(T__0);
setState(154);
valueExpression(0);
setState(155);
match(IN);
setState(156);
valueExpression(0);
setState(157);
match(T__2);
}
break;
case 10:
{
_localctx = new SimpleIfThenContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(159);
match(IF);
setState(160);
((SimpleIfThenContext)_localctx).condition = booleanExpression(0);
setState(161);
match(THEN);
setState(162);
((SimpleIfThenContext)_localctx).result = expression();
setState(166);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,13,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(163);
whenClause();
}
}
}
setState(168);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,13,_ctx);
}
setState(169);
match(ELSE);
setState(170);
((SimpleIfThenContext)_localctx).elseExpression = expression();
}
break;
case 11:
{
_localctx = new FunctionCallContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(172);
qualifiedName();
setState(173);
match(T__0);
setState(174);
match(ASTERISK);
setState(175);
match(T__2);
}
break;
case 12:
{
_localctx = new FunctionCallContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(177);
qualifiedName();
setState(178);
match(T__0);
setState(190);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 6854720460937942802L) != 0) || ((((_la - 75)) & ~0x3f) == 0 && ((1L << (_la - 75)) & -292758440047588481L) != 0) || ((((_la - 139)) & ~0x3f) == 0 && ((1L << (_la - 139)) & -2197225195419205893L) != 0) || ((((_la - 203)) & ~0x3f) == 0 && ((1L << (_la - 203)) & 639L) != 0)) {
{
setState(180);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
case 1:
{
setState(179);
setQuantifier();
}
break;
}
setState(182);
expression();
setState(187);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(183);
match(T__1);
setState(184);
expression();
}
}
setState(189);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(192);
match(T__2);
}
break;
case 13:
{
_localctx = new ArrayConstructorContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(194);
match(ARRAY);
setState(195);
match(T__4);
setState(204);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 6854650092193765138L) != 0) || ((((_la - 75)) & ~0x3f) == 0 && ((1L << (_la - 75)) & -292758440047588481L) != 0) || ((((_la - 139)) & ~0x3f) == 0 && ((1L << (_la - 139)) & -2197225195419205893L) != 0) || ((((_la - 203)) & ~0x3f) == 0 && ((1L << (_la - 203)) & 639L) != 0)) {
{
setState(196);
expression();
setState(201);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(197);
match(T__1);
setState(198);
expression();
}
}
setState(203);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(206);
match(T__5);
}
break;
case 14:
{
_localctx = new ColumnReferenceContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(207);
identifier();
}
break;
case 15:
{
_localctx = new SpecialDateTimeFunctionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(208);
((SpecialDateTimeFunctionContext)_localctx).name = match(LOCALTIME);
setState(212);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
case 1:
{
setState(209);
match(T__0);
setState(210);
((SpecialDateTimeFunctionContext)_localctx).precision = match(INTEGER_VALUE);
setState(211);
match(T__2);
}
break;
}
}
break;
case 16:
{
_localctx = new SpecialDateTimeFunctionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(214);
((SpecialDateTimeFunctionContext)_localctx).name = match(LOCALTIMESTAMP);
setState(218);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
case 1:
{
setState(215);
match(T__0);
setState(216);
((SpecialDateTimeFunctionContext)_localctx).precision = match(INTEGER_VALUE);
setState(217);
match(T__2);
}
break;
}
}
break;
case 17:
{
_localctx = new CurrentUserContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(220);
((CurrentUserContext)_localctx).name = match(CURRENT_USER);
}
break;
case 18:
{
_localctx = new CurrentPathContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(221);
((CurrentPathContext)_localctx).name = match(CURRENT_PATH);
}
break;
case 19:
{
_localctx = new NormalizeContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(222);
match(NORMALIZE);
setState(223);
match(T__0);
setState(224);
valueExpression(0);
setState(227);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__1) {
{
setState(225);
match(T__1);
setState(226);
normalForm();
}
}
setState(229);
match(T__2);
}
break;
case 20:
{
_localctx = new ParenthesizedExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(231);
match(T__0);
setState(232);
expression();
setState(233);
match(T__2);
}
break;
}
_ctx.stop = _input.LT(-1);
setState(254);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,24,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(252);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,23,_ctx) ) {
case 1:
{
_localctx = new SubscriptContext(new PrimaryExpressionContext(_parentctx, _parentState));
((SubscriptContext)_localctx).value = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_primaryExpression);
setState(237);
if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)");
setState(238);
match(T__4);
setState(239);
((SubscriptContext)_localctx).index = valueExpression(0);
setState(240);
match(T__5);
}
break;
case 2:
{
_localctx = new Substring2Context(new PrimaryExpressionContext(_parentctx, _parentState));
((Substring2Context)_localctx).value = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_primaryExpression);
setState(242);
if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)");
setState(243);
match(T__4);
setState(244);
((Substring2Context)_localctx).pos = valueExpression(0);
setState(245);
match(T__1);
setState(246);
((Substring2Context)_localctx).len = valueExpression(0);
setState(247);
match(T__5);
}
break;
case 3:
{
_localctx = new DereferenceContext(new PrimaryExpressionContext(_parentctx, _parentState));
((DereferenceContext)_localctx).base = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_primaryExpression);
setState(249);
if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
setState(250);
match(T__6);
setState(251);
((DereferenceContext)_localctx).fieldName = identifier();
}
break;
}
}
}
setState(256);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,24,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StringContext extends ParserRuleContext {
public StringContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_string; }
public StringContext() { }
public void copyFrom(StringContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class UnicodeStringLiteralContext extends StringContext {
public TerminalNode UNICODE_STRING() { return getToken(SqlBaseParser.UNICODE_STRING, 0); }
public TerminalNode UESCAPE() { return getToken(SqlBaseParser.UESCAPE, 0); }
public TerminalNode STRING() { return getToken(SqlBaseParser.STRING, 0); }
public UnicodeStringLiteralContext(StringContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterUnicodeStringLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitUnicodeStringLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitUnicodeStringLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class BasicStringLiteralContext extends StringContext {
public TerminalNode STRING() { return getToken(SqlBaseParser.STRING, 0); }
public BasicStringLiteralContext(StringContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterBasicStringLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitBasicStringLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitBasicStringLiteral(this);
else return visitor.visitChildren(this);
}
}
public final StringContext string() throws RecognitionException {
StringContext _localctx = new StringContext(_ctx, getState());
enterRule(_localctx, 18, RULE_string);
try {
setState(263);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING:
_localctx = new BasicStringLiteralContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(257);
match(STRING);
}
break;
case UNICODE_STRING:
_localctx = new UnicodeStringLiteralContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(258);
match(UNICODE_STRING);
setState(261);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
case 1:
{
setState(259);
match(UESCAPE);
setState(260);
match(STRING);
}
break;
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ComparisonOperatorContext extends ParserRuleContext {
public TerminalNode EQ() { return getToken(SqlBaseParser.EQ, 0); }
public TerminalNode NEQ() { return getToken(SqlBaseParser.NEQ, 0); }
public TerminalNode LT() { return getToken(SqlBaseParser.LT, 0); }
public TerminalNode LTE() { return getToken(SqlBaseParser.LTE, 0); }
public TerminalNode GT() { return getToken(SqlBaseParser.GT, 0); }
public TerminalNode GTE() { return getToken(SqlBaseParser.GTE, 0); }
public ComparisonOperatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_comparisonOperator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterComparisonOperator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitComparisonOperator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitComparisonOperator(this);
else return visitor.visitChildren(this);
}
}
public final ComparisonOperatorContext comparisonOperator() throws RecognitionException {
ComparisonOperatorContext _localctx = new ComparisonOperatorContext(_ctx, getState());
enterRule(_localctx, 20, RULE_comparisonOperator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(265);
_la = _input.LA(1);
if ( !(((((_la - 188)) & ~0x3f) == 0 && ((1L << (_la - 188)) & 63L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ComparisonQuantifierContext extends ParserRuleContext {
public TerminalNode ALL() { return getToken(SqlBaseParser.ALL, 0); }
public TerminalNode SOME() { return getToken(SqlBaseParser.SOME, 0); }
public TerminalNode ANY() { return getToken(SqlBaseParser.ANY, 0); }
public ComparisonQuantifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_comparisonQuantifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterComparisonQuantifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitComparisonQuantifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitComparisonQuantifier(this);
else return visitor.visitChildren(this);
}
}
public final ComparisonQuantifierContext comparisonQuantifier() throws RecognitionException {
ComparisonQuantifierContext _localctx = new ComparisonQuantifierContext(_ctx, getState());
enterRule(_localctx, 22, RULE_comparisonQuantifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(267);
_la = _input.LA(1);
if ( !(_la==ALL || _la==ANY || _la==SOME) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class BooleanValueContext extends ParserRuleContext {
public TerminalNode TRUE() { return getToken(SqlBaseParser.TRUE, 0); }
public TerminalNode FALSE() { return getToken(SqlBaseParser.FALSE, 0); }
public BooleanValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_booleanValue; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterBooleanValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitBooleanValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitBooleanValue(this);
else return visitor.visitChildren(this);
}
}
public final BooleanValueContext booleanValue() throws RecognitionException {
BooleanValueContext _localctx = new BooleanValueContext(_ctx, getState());
enterRule(_localctx, 24, RULE_booleanValue);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(269);
_la = _input.LA(1);
if ( !(_la==FALSE || _la==TRUE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class NormalFormContext extends ParserRuleContext {
public TerminalNode NFD() { return getToken(SqlBaseParser.NFD, 0); }
public TerminalNode NFC() { return getToken(SqlBaseParser.NFC, 0); }
public TerminalNode NFKD() { return getToken(SqlBaseParser.NFKD, 0); }
public TerminalNode NFKC() { return getToken(SqlBaseParser.NFKC, 0); }
public NormalFormContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_normalForm; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterNormalForm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitNormalForm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitNormalForm(this);
else return visitor.visitChildren(this);
}
}
public final NormalFormContext normalForm() throws RecognitionException {
NormalFormContext _localctx = new NormalFormContext(_ctx, getState());
enterRule(_localctx, 26, RULE_normalForm);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(271);
_la = _input.LA(1);
if ( !(((((_la - 103)) & ~0x3f) == 0 && ((1L << (_la - 103)) & 15L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TypeContext extends ParserRuleContext {
public TerminalNode ARRAY() { return getToken(SqlBaseParser.ARRAY, 0); }
public TerminalNode LT() { return getToken(SqlBaseParser.LT, 0); }
public List type() {
return getRuleContexts(TypeContext.class);
}
public TypeContext type(int i) {
return getRuleContext(TypeContext.class,i);
}
public TerminalNode GT() { return getToken(SqlBaseParser.GT, 0); }
public TerminalNode MAP() { return getToken(SqlBaseParser.MAP, 0); }
public TerminalNode ROW() { return getToken(SqlBaseParser.ROW, 0); }
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public BaseTypeContext baseType() {
return getRuleContext(BaseTypeContext.class,0);
}
public List typeParameter() {
return getRuleContexts(TypeParameterContext.class);
}
public TypeParameterContext typeParameter(int i) {
return getRuleContext(TypeParameterContext.class,i);
}
public TypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_type; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitType(this);
else return visitor.visitChildren(this);
}
}
public final TypeContext type() throws RecognitionException {
return type(0);
}
private TypeContext type(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
TypeContext _localctx = new TypeContext(_ctx, _parentState);
TypeContext _prevctx = _localctx;
int _startState = 28;
enterRecursionRule(_localctx, 28, RULE_type, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(315);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
case 1:
{
setState(274);
match(ARRAY);
setState(275);
match(LT);
setState(276);
type(0);
setState(277);
match(GT);
}
break;
case 2:
{
setState(279);
match(MAP);
setState(280);
match(LT);
setState(281);
type(0);
setState(282);
match(T__1);
setState(283);
type(0);
setState(284);
match(GT);
}
break;
case 3:
{
setState(286);
match(ROW);
setState(287);
match(T__0);
setState(288);
identifier();
setState(289);
type(0);
setState(296);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(290);
match(T__1);
setState(291);
identifier();
setState(292);
type(0);
}
}
setState(298);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(299);
match(T__2);
}
break;
case 4:
{
setState(301);
baseType();
setState(313);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,29,_ctx) ) {
case 1:
{
setState(302);
match(T__0);
setState(303);
typeParameter();
setState(308);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(304);
match(T__1);
setState(305);
typeParameter();
}
}
setState(310);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(311);
match(T__2);
}
break;
}
}
break;
}
_ctx.stop = _input.LT(-1);
setState(321);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,31,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new TypeContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_type);
setState(317);
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
setState(318);
match(ARRAY);
}
}
}
setState(323);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,31,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TypeParameterContext extends ParserRuleContext {
public TerminalNode INTEGER_VALUE() { return getToken(SqlBaseParser.INTEGER_VALUE, 0); }
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public TypeParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeParameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterTypeParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitTypeParameter(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitTypeParameter(this);
else return visitor.visitChildren(this);
}
}
public final TypeParameterContext typeParameter() throws RecognitionException {
TypeParameterContext _localctx = new TypeParameterContext(_ctx, getState());
enterRule(_localctx, 30, RULE_typeParameter);
try {
setState(326);
_errHandler.sync(this);
switch (_input.LA(1)) {
case INTEGER_VALUE:
enterOuterAlt(_localctx, 1);
{
setState(324);
match(INTEGER_VALUE);
}
break;
case IN:
case ADD:
case ALL:
case ANALYZE:
case ANY:
case ARRAY:
case ASC:
case AT:
case BERNOULLI:
case CALL:
case CASCADE:
case CATALOGS:
case COLUMN:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case CURRENT:
case DATA:
case DATE:
case DAY:
case DELETE:
case DESC:
case DISTRIBUTED:
case EXCLUDING:
case EXPLAIN:
case FILTER:
case FIRST:
case FOLLOWING:
case FORMAT:
case FUNCTIONS:
case GRANT:
case GRANTS:
case GRAPHVIZ:
case HOUR:
case IF:
case INCLUDING:
case INPUT:
case INSERT:
case INTERVAL:
case ISOLATION:
case LAST:
case LATERAL:
case LEVEL:
case LIMIT:
case LOGICAL:
case MAP:
case MINUTE:
case MONTH:
case NFC:
case NFD:
case NFKC:
case NFKD:
case NO:
case NULLIF:
case NULLS:
case ONLY:
case OPTION:
case ORDINALITY:
case OUTPUT:
case OVER:
case PARTITION:
case PARTITIONS:
case PATH:
case POSITION:
case PRECEDING:
case PRIVILEGES:
case PROPERTIES:
case PUBLIC:
case RANGE:
case READ:
case RENAME:
case REPEATABLE:
case REPLACE:
case RESET:
case RESTRICT:
case REVOKE:
case ROLLBACK:
case ROW:
case ROWS:
case SCHEMA:
case SCHEMAS:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SET:
case SETS:
case SHOW:
case SOME:
case START:
case STATS:
case SUBSTRING:
case SYSTEM:
case TABLE:
case TABLES:
case TABLESAMPLE:
case TEXT:
case TIME:
case TIMESTAMP:
case TO:
case TRANSACTION:
case TRY_CAST:
case TYPE:
case UNBOUNDED:
case UNCOMMITTED:
case USE:
case VALIDATE:
case VERBOSE:
case VIEW:
case WORK:
case WRITE:
case YEAR:
case ZONE:
case IDENTIFIER:
case DIGIT_IDENTIFIER:
case QUOTED_IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
case TIME_WITH_TIME_ZONE:
case TIMESTAMP_WITH_TIME_ZONE:
case DOUBLE_PRECISION:
enterOuterAlt(_localctx, 2);
{
setState(325);
type(0);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class BaseTypeContext extends ParserRuleContext {
public TerminalNode TIME_WITH_TIME_ZONE() { return getToken(SqlBaseParser.TIME_WITH_TIME_ZONE, 0); }
public TerminalNode TIMESTAMP_WITH_TIME_ZONE() { return getToken(SqlBaseParser.TIMESTAMP_WITH_TIME_ZONE, 0); }
public TerminalNode DOUBLE_PRECISION() { return getToken(SqlBaseParser.DOUBLE_PRECISION, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public BaseTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_baseType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterBaseType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitBaseType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitBaseType(this);
else return visitor.visitChildren(this);
}
}
public final BaseTypeContext baseType() throws RecognitionException {
BaseTypeContext _localctx = new BaseTypeContext(_ctx, getState());
enterRule(_localctx, 32, RULE_baseType);
try {
setState(332);
_errHandler.sync(this);
switch (_input.LA(1)) {
case TIME_WITH_TIME_ZONE:
enterOuterAlt(_localctx, 1);
{
setState(328);
match(TIME_WITH_TIME_ZONE);
}
break;
case TIMESTAMP_WITH_TIME_ZONE:
enterOuterAlt(_localctx, 2);
{
setState(329);
match(TIMESTAMP_WITH_TIME_ZONE);
}
break;
case DOUBLE_PRECISION:
enterOuterAlt(_localctx, 3);
{
setState(330);
match(DOUBLE_PRECISION);
}
break;
case IN:
case ADD:
case ALL:
case ANALYZE:
case ANY:
case ARRAY:
case ASC:
case AT:
case BERNOULLI:
case CALL:
case CASCADE:
case CATALOGS:
case COLUMN:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case CURRENT:
case DATA:
case DATE:
case DAY:
case DELETE:
case DESC:
case DISTRIBUTED:
case EXCLUDING:
case EXPLAIN:
case FILTER:
case FIRST:
case FOLLOWING:
case FORMAT:
case FUNCTIONS:
case GRANT:
case GRANTS:
case GRAPHVIZ:
case HOUR:
case IF:
case INCLUDING:
case INPUT:
case INSERT:
case INTERVAL:
case ISOLATION:
case LAST:
case LATERAL:
case LEVEL:
case LIMIT:
case LOGICAL:
case MAP:
case MINUTE:
case MONTH:
case NFC:
case NFD:
case NFKC:
case NFKD:
case NO:
case NULLIF:
case NULLS:
case ONLY:
case OPTION:
case ORDINALITY:
case OUTPUT:
case OVER:
case PARTITION:
case PARTITIONS:
case PATH:
case POSITION:
case PRECEDING:
case PRIVILEGES:
case PROPERTIES:
case PUBLIC:
case RANGE:
case READ:
case RENAME:
case REPEATABLE:
case REPLACE:
case RESET:
case RESTRICT:
case REVOKE:
case ROLLBACK:
case ROW:
case ROWS:
case SCHEMA:
case SCHEMAS:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SET:
case SETS:
case SHOW:
case SOME:
case START:
case STATS:
case SUBSTRING:
case SYSTEM:
case TABLE:
case TABLES:
case TABLESAMPLE:
case TEXT:
case TIME:
case TIMESTAMP:
case TO:
case TRANSACTION:
case TRY_CAST:
case TYPE:
case UNBOUNDED:
case UNCOMMITTED:
case USE:
case VALIDATE:
case VERBOSE:
case VIEW:
case WORK:
case WRITE:
case YEAR:
case ZONE:
case IDENTIFIER:
case DIGIT_IDENTIFIER:
case QUOTED_IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
enterOuterAlt(_localctx, 4);
{
setState(331);
identifier();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PathElementContext extends ParserRuleContext {
public PathElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pathElement; }
public PathElementContext() { }
public void copyFrom(PathElementContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class QualifiedArgumentContext extends PathElementContext {
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public QualifiedArgumentContext(PathElementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterQualifiedArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitQualifiedArgument(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitQualifiedArgument(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class UnqualifiedArgumentContext extends PathElementContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public UnqualifiedArgumentContext(PathElementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterUnqualifiedArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitUnqualifiedArgument(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitUnqualifiedArgument(this);
else return visitor.visitChildren(this);
}
}
public final PathElementContext pathElement() throws RecognitionException {
PathElementContext _localctx = new PathElementContext(_ctx, getState());
enterRule(_localctx, 34, RULE_pathElement);
try {
setState(339);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) {
case 1:
_localctx = new QualifiedArgumentContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(334);
identifier();
setState(335);
match(T__6);
setState(336);
identifier();
}
break;
case 2:
_localctx = new UnqualifiedArgumentContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(338);
identifier();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PathSpecificationContext extends ParserRuleContext {
public List pathElement() {
return getRuleContexts(PathElementContext.class);
}
public PathElementContext pathElement(int i) {
return getRuleContext(PathElementContext.class,i);
}
public PathSpecificationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pathSpecification; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterPathSpecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitPathSpecification(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitPathSpecification(this);
else return visitor.visitChildren(this);
}
}
public final PathSpecificationContext pathSpecification() throws RecognitionException {
PathSpecificationContext _localctx = new PathSpecificationContext(_ctx, getState());
enterRule(_localctx, 36, RULE_pathSpecification);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(341);
pathElement();
setState(346);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(342);
match(T__1);
setState(343);
pathElement();
}
}
setState(348);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PrivilegeContext extends ParserRuleContext {
public TerminalNode SELECT() { return getToken(SqlBaseParser.SELECT, 0); }
public TerminalNode DELETE() { return getToken(SqlBaseParser.DELETE, 0); }
public TerminalNode INSERT() { return getToken(SqlBaseParser.INSERT, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public PrivilegeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_privilege; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterPrivilege(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitPrivilege(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitPrivilege(this);
else return visitor.visitChildren(this);
}
}
public final PrivilegeContext privilege() throws RecognitionException {
PrivilegeContext _localctx = new PrivilegeContext(_ctx, getState());
enterRule(_localctx, 38, RULE_privilege);
try {
setState(353);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,36,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(349);
match(SELECT);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(350);
match(DELETE);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(351);
match(INSERT);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(352);
identifier();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class QualifiedNameContext extends ParserRuleContext {
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public QualifiedNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qualifiedName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterQualifiedName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitQualifiedName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitQualifiedName(this);
else return visitor.visitChildren(this);
}
}
public final QualifiedNameContext qualifiedName() throws RecognitionException {
QualifiedNameContext _localctx = new QualifiedNameContext(_ctx, getState());
enterRule(_localctx, 40, RULE_qualifiedName);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(355);
identifier();
setState(360);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__6) {
{
{
setState(356);
match(T__6);
setState(357);
identifier();
}
}
setState(362);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class IdentifierContext extends ParserRuleContext {
public IdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifier; }
public IdentifierContext() { }
public void copyFrom(IdentifierContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class BackQuotedIdentifierContext extends IdentifierContext {
public TerminalNode BACKQUOTED_IDENTIFIER() { return getToken(SqlBaseParser.BACKQUOTED_IDENTIFIER, 0); }
public BackQuotedIdentifierContext(IdentifierContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterBackQuotedIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitBackQuotedIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitBackQuotedIdentifier(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class QuotedIdentifierContext extends IdentifierContext {
public TerminalNode QUOTED_IDENTIFIER() { return getToken(SqlBaseParser.QUOTED_IDENTIFIER, 0); }
public QuotedIdentifierContext(IdentifierContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterQuotedIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitQuotedIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitQuotedIdentifier(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DigitIdentifierContext extends IdentifierContext {
public TerminalNode DIGIT_IDENTIFIER() { return getToken(SqlBaseParser.DIGIT_IDENTIFIER, 0); }
public DigitIdentifierContext(IdentifierContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterDigitIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitDigitIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitDigitIdentifier(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class UnquotedIdentifierContext extends IdentifierContext {
public TerminalNode IDENTIFIER() { return getToken(SqlBaseParser.IDENTIFIER, 0); }
public NonReservedContext nonReserved() {
return getRuleContext(NonReservedContext.class,0);
}
public UnquotedIdentifierContext(IdentifierContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterUnquotedIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitUnquotedIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitUnquotedIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final IdentifierContext identifier() throws RecognitionException {
IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
enterRule(_localctx, 42, RULE_identifier);
try {
setState(368);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IDENTIFIER:
_localctx = new UnquotedIdentifierContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(363);
match(IDENTIFIER);
}
break;
case QUOTED_IDENTIFIER:
_localctx = new QuotedIdentifierContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(364);
match(QUOTED_IDENTIFIER);
}
break;
case IN:
case ADD:
case ALL:
case ANALYZE:
case ANY:
case ARRAY:
case ASC:
case AT:
case BERNOULLI:
case CALL:
case CASCADE:
case CATALOGS:
case COLUMN:
case COLUMNS:
case COMMENT:
case COMMIT:
case COMMITTED:
case CURRENT:
case DATA:
case DATE:
case DAY:
case DELETE:
case DESC:
case DISTRIBUTED:
case EXCLUDING:
case EXPLAIN:
case FILTER:
case FIRST:
case FOLLOWING:
case FORMAT:
case FUNCTIONS:
case GRANT:
case GRANTS:
case GRAPHVIZ:
case HOUR:
case IF:
case INCLUDING:
case INPUT:
case INSERT:
case INTERVAL:
case ISOLATION:
case LAST:
case LATERAL:
case LEVEL:
case LIMIT:
case LOGICAL:
case MAP:
case MINUTE:
case MONTH:
case NFC:
case NFD:
case NFKC:
case NFKD:
case NO:
case NULLIF:
case NULLS:
case ONLY:
case OPTION:
case ORDINALITY:
case OUTPUT:
case OVER:
case PARTITION:
case PARTITIONS:
case PATH:
case POSITION:
case PRECEDING:
case PRIVILEGES:
case PROPERTIES:
case PUBLIC:
case RANGE:
case READ:
case RENAME:
case REPEATABLE:
case REPLACE:
case RESET:
case RESTRICT:
case REVOKE:
case ROLLBACK:
case ROW:
case ROWS:
case SCHEMA:
case SCHEMAS:
case SECOND:
case SERIALIZABLE:
case SESSION:
case SET:
case SETS:
case SHOW:
case SOME:
case START:
case STATS:
case SUBSTRING:
case SYSTEM:
case TABLE:
case TABLES:
case TABLESAMPLE:
case TEXT:
case TIME:
case TIMESTAMP:
case TO:
case TRANSACTION:
case TRY_CAST:
case TYPE:
case UNBOUNDED:
case UNCOMMITTED:
case USE:
case VALIDATE:
case VERBOSE:
case VIEW:
case WORK:
case WRITE:
case YEAR:
case ZONE:
_localctx = new UnquotedIdentifierContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(365);
nonReserved();
}
break;
case BACKQUOTED_IDENTIFIER:
_localctx = new BackQuotedIdentifierContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(366);
match(BACKQUOTED_IDENTIFIER);
}
break;
case DIGIT_IDENTIFIER:
_localctx = new DigitIdentifierContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(367);
match(DIGIT_IDENTIFIER);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class NumberContext extends ParserRuleContext {
public NumberContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_number; }
public NumberContext() { }
public void copyFrom(NumberContext ctx) {
super.copyFrom(ctx);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DecimalLiteralContext extends NumberContext {
public TerminalNode DECIMAL_VALUE() { return getToken(SqlBaseParser.DECIMAL_VALUE, 0); }
public DecimalLiteralContext(NumberContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterDecimalLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitDecimalLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitDecimalLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class DoubleLiteralContext extends NumberContext {
public TerminalNode DOUBLE_VALUE() { return getToken(SqlBaseParser.DOUBLE_VALUE, 0); }
public DoubleLiteralContext(NumberContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterDoubleLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitDoubleLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitDoubleLiteral(this);
else return visitor.visitChildren(this);
}
}
@SuppressWarnings("CheckReturnValue")
public static class IntegerLiteralContext extends NumberContext {
public TerminalNode INTEGER_VALUE() { return getToken(SqlBaseParser.INTEGER_VALUE, 0); }
public IntegerLiteralContext(NumberContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterIntegerLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitIntegerLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitIntegerLiteral(this);
else return visitor.visitChildren(this);
}
}
public final NumberContext number() throws RecognitionException {
NumberContext _localctx = new NumberContext(_ctx, getState());
enterRule(_localctx, 44, RULE_number);
try {
setState(373);
_errHandler.sync(this);
switch (_input.LA(1)) {
case DECIMAL_VALUE:
_localctx = new DecimalLiteralContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(370);
match(DECIMAL_VALUE);
}
break;
case DOUBLE_VALUE:
_localctx = new DoubleLiteralContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(371);
match(DOUBLE_VALUE);
}
break;
case INTEGER_VALUE:
_localctx = new IntegerLiteralContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(372);
match(INTEGER_VALUE);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class NonReservedContext extends ParserRuleContext {
public TerminalNode ADD() { return getToken(SqlBaseParser.ADD, 0); }
public TerminalNode ALL() { return getToken(SqlBaseParser.ALL, 0); }
public TerminalNode ANALYZE() { return getToken(SqlBaseParser.ANALYZE, 0); }
public TerminalNode ANY() { return getToken(SqlBaseParser.ANY, 0); }
public TerminalNode ARRAY() { return getToken(SqlBaseParser.ARRAY, 0); }
public TerminalNode ASC() { return getToken(SqlBaseParser.ASC, 0); }
public TerminalNode AT() { return getToken(SqlBaseParser.AT, 0); }
public TerminalNode BERNOULLI() { return getToken(SqlBaseParser.BERNOULLI, 0); }
public TerminalNode CALL() { return getToken(SqlBaseParser.CALL, 0); }
public TerminalNode CASCADE() { return getToken(SqlBaseParser.CASCADE, 0); }
public TerminalNode CATALOGS() { return getToken(SqlBaseParser.CATALOGS, 0); }
public TerminalNode COLUMN() { return getToken(SqlBaseParser.COLUMN, 0); }
public TerminalNode COLUMNS() { return getToken(SqlBaseParser.COLUMNS, 0); }
public TerminalNode COMMENT() { return getToken(SqlBaseParser.COMMENT, 0); }
public TerminalNode COMMIT() { return getToken(SqlBaseParser.COMMIT, 0); }
public TerminalNode COMMITTED() { return getToken(SqlBaseParser.COMMITTED, 0); }
public TerminalNode CURRENT() { return getToken(SqlBaseParser.CURRENT, 0); }
public TerminalNode DATA() { return getToken(SqlBaseParser.DATA, 0); }
public TerminalNode DATE() { return getToken(SqlBaseParser.DATE, 0); }
public TerminalNode DAY() { return getToken(SqlBaseParser.DAY, 0); }
public TerminalNode DESC() { return getToken(SqlBaseParser.DESC, 0); }
public TerminalNode DISTRIBUTED() { return getToken(SqlBaseParser.DISTRIBUTED, 0); }
public TerminalNode EXCLUDING() { return getToken(SqlBaseParser.EXCLUDING, 0); }
public TerminalNode EXPLAIN() { return getToken(SqlBaseParser.EXPLAIN, 0); }
public TerminalNode FILTER() { return getToken(SqlBaseParser.FILTER, 0); }
public TerminalNode FIRST() { return getToken(SqlBaseParser.FIRST, 0); }
public TerminalNode FOLLOWING() { return getToken(SqlBaseParser.FOLLOWING, 0); }
public TerminalNode FORMAT() { return getToken(SqlBaseParser.FORMAT, 0); }
public TerminalNode FUNCTIONS() { return getToken(SqlBaseParser.FUNCTIONS, 0); }
public TerminalNode GRANT() { return getToken(SqlBaseParser.GRANT, 0); }
public TerminalNode GRANTS() { return getToken(SqlBaseParser.GRANTS, 0); }
public TerminalNode GRAPHVIZ() { return getToken(SqlBaseParser.GRAPHVIZ, 0); }
public TerminalNode HOUR() { return getToken(SqlBaseParser.HOUR, 0); }
public TerminalNode IF() { return getToken(SqlBaseParser.IF, 0); }
public TerminalNode INCLUDING() { return getToken(SqlBaseParser.INCLUDING, 0); }
public TerminalNode INPUT() { return getToken(SqlBaseParser.INPUT, 0); }
public TerminalNode INTERVAL() { return getToken(SqlBaseParser.INTERVAL, 0); }
public TerminalNode ISOLATION() { return getToken(SqlBaseParser.ISOLATION, 0); }
public TerminalNode LAST() { return getToken(SqlBaseParser.LAST, 0); }
public TerminalNode LATERAL() { return getToken(SqlBaseParser.LATERAL, 0); }
public TerminalNode LEVEL() { return getToken(SqlBaseParser.LEVEL, 0); }
public TerminalNode LIMIT() { return getToken(SqlBaseParser.LIMIT, 0); }
public TerminalNode LOGICAL() { return getToken(SqlBaseParser.LOGICAL, 0); }
public TerminalNode MAP() { return getToken(SqlBaseParser.MAP, 0); }
public TerminalNode MINUTE() { return getToken(SqlBaseParser.MINUTE, 0); }
public TerminalNode MONTH() { return getToken(SqlBaseParser.MONTH, 0); }
public TerminalNode NFC() { return getToken(SqlBaseParser.NFC, 0); }
public TerminalNode NFD() { return getToken(SqlBaseParser.NFD, 0); }
public TerminalNode NFKC() { return getToken(SqlBaseParser.NFKC, 0); }
public TerminalNode NFKD() { return getToken(SqlBaseParser.NFKD, 0); }
public TerminalNode NO() { return getToken(SqlBaseParser.NO, 0); }
public TerminalNode NULLIF() { return getToken(SqlBaseParser.NULLIF, 0); }
public TerminalNode NULLS() { return getToken(SqlBaseParser.NULLS, 0); }
public TerminalNode ONLY() { return getToken(SqlBaseParser.ONLY, 0); }
public TerminalNode OPTION() { return getToken(SqlBaseParser.OPTION, 0); }
public TerminalNode ORDINALITY() { return getToken(SqlBaseParser.ORDINALITY, 0); }
public TerminalNode OUTPUT() { return getToken(SqlBaseParser.OUTPUT, 0); }
public TerminalNode OVER() { return getToken(SqlBaseParser.OVER, 0); }
public TerminalNode PARTITION() { return getToken(SqlBaseParser.PARTITION, 0); }
public TerminalNode PARTITIONS() { return getToken(SqlBaseParser.PARTITIONS, 0); }
public TerminalNode PATH() { return getToken(SqlBaseParser.PATH, 0); }
public TerminalNode POSITION() { return getToken(SqlBaseParser.POSITION, 0); }
public TerminalNode PRECEDING() { return getToken(SqlBaseParser.PRECEDING, 0); }
public TerminalNode PRIVILEGES() { return getToken(SqlBaseParser.PRIVILEGES, 0); }
public TerminalNode PROPERTIES() { return getToken(SqlBaseParser.PROPERTIES, 0); }
public TerminalNode PUBLIC() { return getToken(SqlBaseParser.PUBLIC, 0); }
public TerminalNode RANGE() { return getToken(SqlBaseParser.RANGE, 0); }
public TerminalNode READ() { return getToken(SqlBaseParser.READ, 0); }
public TerminalNode RENAME() { return getToken(SqlBaseParser.RENAME, 0); }
public TerminalNode REPEATABLE() { return getToken(SqlBaseParser.REPEATABLE, 0); }
public TerminalNode REPLACE() { return getToken(SqlBaseParser.REPLACE, 0); }
public TerminalNode RESET() { return getToken(SqlBaseParser.RESET, 0); }
public TerminalNode RESTRICT() { return getToken(SqlBaseParser.RESTRICT, 0); }
public TerminalNode REVOKE() { return getToken(SqlBaseParser.REVOKE, 0); }
public TerminalNode ROLLBACK() { return getToken(SqlBaseParser.ROLLBACK, 0); }
public TerminalNode ROW() { return getToken(SqlBaseParser.ROW, 0); }
public TerminalNode ROWS() { return getToken(SqlBaseParser.ROWS, 0); }
public TerminalNode SCHEMA() { return getToken(SqlBaseParser.SCHEMA, 0); }
public TerminalNode SCHEMAS() { return getToken(SqlBaseParser.SCHEMAS, 0); }
public TerminalNode SECOND() { return getToken(SqlBaseParser.SECOND, 0); }
public TerminalNode SERIALIZABLE() { return getToken(SqlBaseParser.SERIALIZABLE, 0); }
public TerminalNode SESSION() { return getToken(SqlBaseParser.SESSION, 0); }
public TerminalNode SET() { return getToken(SqlBaseParser.SET, 0); }
public TerminalNode SETS() { return getToken(SqlBaseParser.SETS, 0); }
public TerminalNode SHOW() { return getToken(SqlBaseParser.SHOW, 0); }
public TerminalNode SOME() { return getToken(SqlBaseParser.SOME, 0); }
public TerminalNode START() { return getToken(SqlBaseParser.START, 0); }
public TerminalNode STATS() { return getToken(SqlBaseParser.STATS, 0); }
public TerminalNode SUBSTRING() { return getToken(SqlBaseParser.SUBSTRING, 0); }
public TerminalNode SYSTEM() { return getToken(SqlBaseParser.SYSTEM, 0); }
public TerminalNode TABLES() { return getToken(SqlBaseParser.TABLES, 0); }
public TerminalNode TABLESAMPLE() { return getToken(SqlBaseParser.TABLESAMPLE, 0); }
public TerminalNode TEXT() { return getToken(SqlBaseParser.TEXT, 0); }
public TerminalNode TIME() { return getToken(SqlBaseParser.TIME, 0); }
public TerminalNode TIMESTAMP() { return getToken(SqlBaseParser.TIMESTAMP, 0); }
public TerminalNode TO() { return getToken(SqlBaseParser.TO, 0); }
public TerminalNode TRANSACTION() { return getToken(SqlBaseParser.TRANSACTION, 0); }
public TerminalNode TRY_CAST() { return getToken(SqlBaseParser.TRY_CAST, 0); }
public TerminalNode TYPE() { return getToken(SqlBaseParser.TYPE, 0); }
public TerminalNode UNBOUNDED() { return getToken(SqlBaseParser.UNBOUNDED, 0); }
public TerminalNode UNCOMMITTED() { return getToken(SqlBaseParser.UNCOMMITTED, 0); }
public TerminalNode USE() { return getToken(SqlBaseParser.USE, 0); }
public TerminalNode VALIDATE() { return getToken(SqlBaseParser.VALIDATE, 0); }
public TerminalNode VERBOSE() { return getToken(SqlBaseParser.VERBOSE, 0); }
public TerminalNode VIEW() { return getToken(SqlBaseParser.VIEW, 0); }
public TerminalNode WORK() { return getToken(SqlBaseParser.WORK, 0); }
public TerminalNode WRITE() { return getToken(SqlBaseParser.WRITE, 0); }
public TerminalNode YEAR() { return getToken(SqlBaseParser.YEAR, 0); }
public TerminalNode ZONE() { return getToken(SqlBaseParser.ZONE, 0); }
public TerminalNode IN() { return getToken(SqlBaseParser.IN, 0); }
public TerminalNode DELETE() { return getToken(SqlBaseParser.DELETE, 0); }
public TerminalNode INSERT() { return getToken(SqlBaseParser.INSERT, 0); }
public TerminalNode TABLE() { return getToken(SqlBaseParser.TABLE, 0); }
public NonReservedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nonReserved; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).enterNonReserved(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqlBaseListener ) ((SqlBaseListener)listener).exitNonReserved(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SqlBaseVisitor ) return ((SqlBaseVisitor)visitor).visitNonReserved(this);
else return visitor.visitChildren(this);
}
}
public final NonReservedContext nonReserved() throws RecognitionException {
NonReservedContext _localctx = new NonReservedContext(_ctx, getState());
enterRule(_localctx, 46, RULE_nonReserved);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(375);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 6710534491801048832L) != 0) || ((((_la - 75)) & ~0x3f) == 0 && ((1L << (_la - 75)) & -292758500183422081L) != 0) || ((((_la - 139)) & ~0x3f) == 0 && ((1L << (_la - 139)) & 531422469160699L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
switch (ruleIndex) {
case 4:
return booleanExpression_sempred((BooleanExpressionContext)_localctx, predIndex);
case 6:
return valueExpression_sempred((ValueExpressionContext)_localctx, predIndex);
case 8:
return primaryExpression_sempred((PrimaryExpressionContext)_localctx, predIndex);
case 14:
return type_sempred((TypeContext)_localctx, predIndex);
}
return true;
}
private boolean booleanExpression_sempred(BooleanExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return precpred(_ctx, 2);
case 1:
return precpred(_ctx, 1);
}
return true;
}
private boolean valueExpression_sempred(ValueExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 2:
return precpred(_ctx, 3);
case 3:
return precpred(_ctx, 2);
case 4:
return precpred(_ctx, 1);
}
return true;
}
private boolean primaryExpression_sempred(PrimaryExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 5:
return precpred(_ctx, 10);
case 6:
return precpred(_ctx, 9);
case 7:
return precpred(_ctx, 7);
}
return true;
}
private boolean type_sempred(TypeContext _localctx, int predIndex) {
switch (predIndex) {
case 8:
return precpred(_ctx, 5);
}
return true;
}
public static final String _serializedATN =
"\u0004\u0001\u00d9\u017a\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001"+
"\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004"+
"\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007"+
"\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b"+
"\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007"+
"\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007"+
"\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007"+
"\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0001\u0000\u0001"+
"\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001\u0002\u0001\u0002\u0001"+
"\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001"+
"\u0003\u0001\u0003\u0003\u0003@\b\u0003\u0001\u0004\u0001\u0004\u0001"+
"\u0004\u0003\u0004E\b\u0004\u0001\u0004\u0001\u0004\u0003\u0004I\b\u0004"+
"\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004"+
"\u0005\u0004Q\b\u0004\n\u0004\f\u0004T\t\u0004\u0001\u0005\u0001\u0005"+
"\u0001\u0005\u0001\u0005\u0003\u0005Z\b\u0005\u0001\u0005\u0001\u0005"+
"\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0003\u0005b\b\u0005"+
"\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0005\u0005"+
"i\b\u0005\n\u0005\f\u0005l\t\u0005\u0001\u0005\u0001\u0005\u0001\u0005"+
"\u0001\u0005\u0003\u0005r\b\u0005\u0001\u0005\u0003\u0005u\b\u0005\u0001"+
"\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0003\u0006{\b\u0006\u0001"+
"\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001"+
"\u0006\u0001\u0006\u0001\u0006\u0005\u0006\u0086\b\u0006\n\u0006\f\u0006"+
"\u0089\t\u0006\u0001\u0007\u0001\u0007\u0001\b\u0001\b\u0001\b\u0001\b"+
"\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+
"\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+
"\b\u0001\b\u0001\b\u0005\b\u00a5\b\b\n\b\f\b\u00a8\t\b\u0001\b\u0001\b"+
"\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+
"\b\u0003\b\u00b5\b\b\u0001\b\u0001\b\u0001\b\u0005\b\u00ba\b\b\n\b\f\b"+
"\u00bd\t\b\u0003\b\u00bf\b\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+
"\b\u0001\b\u0005\b\u00c8\b\b\n\b\f\b\u00cb\t\b\u0003\b\u00cd\b\b\u0001"+
"\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0003\b\u00d5\b\b\u0001\b\u0001"+
"\b\u0001\b\u0001\b\u0003\b\u00db\b\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+
"\b\u0001\b\u0001\b\u0003\b\u00e4\b\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+
"\b\u0001\b\u0003\b\u00ec\b\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+
"\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+
"\b\u0005\b\u00fd\b\b\n\b\f\b\u0100\t\b\u0001\t\u0001\t\u0001\t\u0001\t"+
"\u0003\t\u0106\b\t\u0003\t\u0108\b\t\u0001\n\u0001\n\u0001\u000b\u0001"+
"\u000b\u0001\f\u0001\f\u0001\r\u0001\r\u0001\u000e\u0001\u000e\u0001\u000e"+
"\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e"+
"\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e"+
"\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e"+
"\u0005\u000e\u0127\b\u000e\n\u000e\f\u000e\u012a\t\u000e\u0001\u000e\u0001"+
"\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0005"+
"\u000e\u0133\b\u000e\n\u000e\f\u000e\u0136\t\u000e\u0001\u000e\u0001\u000e"+
"\u0003\u000e\u013a\b\u000e\u0003\u000e\u013c\b\u000e\u0001\u000e\u0001"+
"\u000e\u0005\u000e\u0140\b\u000e\n\u000e\f\u000e\u0143\t\u000e\u0001\u000f"+
"\u0001\u000f\u0003\u000f\u0147\b\u000f\u0001\u0010\u0001\u0010\u0001\u0010"+
"\u0001\u0010\u0003\u0010\u014d\b\u0010\u0001\u0011\u0001\u0011\u0001\u0011"+
"\u0001\u0011\u0001\u0011\u0003\u0011\u0154\b\u0011\u0001\u0012\u0001\u0012"+
"\u0001\u0012\u0005\u0012\u0159\b\u0012\n\u0012\f\u0012\u015c\t\u0012\u0001"+
"\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0003\u0013\u0162\b\u0013\u0001"+
"\u0014\u0001\u0014\u0001\u0014\u0005\u0014\u0167\b\u0014\n\u0014\f\u0014"+
"\u016a\t\u0014\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0015"+
"\u0003\u0015\u0171\b\u0015\u0001\u0016\u0001\u0016\u0001\u0016\u0003\u0016"+
"\u0176\b\u0016\u0001\u0017\u0001\u0017\u0001\u0017\u0000\u0004\b\f\u0010"+
"\u001c\u0018\u0000\u0002\u0004\u0006\b\n\f\u000e\u0010\u0012\u0014\u0016"+
"\u0018\u001a\u001c\u001e \"$&(*,.\u0000\t\u0002\u0000\u0013\u0013\u009d"+
"\u009d\u0001\u0000\u00c2\u00c3\u0001\u0000\u00c4\u00c6\u0002\u0000\n\n"+
"..\u0001\u0000\u00bc\u00c1\u0003\u0000\n\n\u000e\u000e\u0099\u0099\u0002"+
"\u000099\u00a7\u00a7\u0001\u0000gj%\u0000\b\n\f\f\u000e\u000f\u0011\u0013"+
"\u0016\u0017\u001a\u001f$$\')+,//5588:<>>KQSTVVYY[]__begkoprsvvx~\u0080"+
"\u0084\u0086\u008c\u008e\u0092\u0094\u00a1\u00a3\u00a6\u00a8\u00a9\u00ab"+
"\u00ac\u00af\u00af\u00b1\u00b1\u00b3\u00b4\u00b8\u00bb\u01a9\u00000\u0001"+
"\u0000\u0000\u0000\u00023\u0001\u0000\u0000\u0000\u00045\u0001\u0000\u0000"+
"\u0000\u0006?\u0001\u0000\u0000\u0000\bH\u0001\u0000\u0000\u0000\nt\u0001"+
"\u0000\u0000\u0000\fz\u0001\u0000\u0000\u0000\u000e\u008a\u0001\u0000"+
"\u0000\u0000\u0010\u00eb\u0001\u0000\u0000\u0000\u0012\u0107\u0001\u0000"+
"\u0000\u0000\u0014\u0109\u0001\u0000\u0000\u0000\u0016\u010b\u0001\u0000"+
"\u0000\u0000\u0018\u010d\u0001\u0000\u0000\u0000\u001a\u010f\u0001\u0000"+
"\u0000\u0000\u001c\u013b\u0001\u0000\u0000\u0000\u001e\u0146\u0001\u0000"+
"\u0000\u0000 \u014c\u0001\u0000\u0000\u0000\"\u0153\u0001\u0000\u0000"+
"\u0000$\u0155\u0001\u0000\u0000\u0000&\u0161\u0001\u0000\u0000\u0000("+
"\u0163\u0001\u0000\u0000\u0000*\u0170\u0001\u0000\u0000\u0000,\u0175\u0001"+
"\u0000\u0000\u0000.\u0177\u0001\u0000\u0000\u000001\u0003\u0004\u0002"+
"\u000012\u0005\u0000\u0000\u00012\u0001\u0001\u0000\u0000\u000034\u0007"+
"\u0000\u0000\u00004\u0003\u0001\u0000\u0000\u000056\u0003\b\u0004\u0000"+
"6\u0005\u0001\u0000\u0000\u00007@\u0005\u00b5\u0000\u000089\u00051\u0000"+
"\u00009:\u0005P\u0000\u0000:;\u0001\u0000\u0000\u0000;<\u0003\b\u0004"+
"\u0000<=\u0005\u00a2\u0000\u0000=>\u0003\u0004\u0002\u0000>@\u0001\u0000"+
"\u0000\u0000?7\u0001\u0000\u0000\u0000?8\u0001\u0000\u0000\u0000@\u0007"+
"\u0001\u0000\u0000\u0000AB\u0006\u0004\uffff\uffff\u0000BD\u0003\f\u0006"+
"\u0000CE\u0003\n\u0005\u0000DC\u0001\u0000\u0000\u0000DE\u0001\u0000\u0000"+
"\u0000EI\u0001\u0000\u0000\u0000FG\u0005m\u0000\u0000GI\u0003\b\u0004"+
"\u0003HA\u0001\u0000\u0000\u0000HF\u0001\u0000\u0000\u0000IR\u0001\u0000"+
"\u0000\u0000JK\n\u0002\u0000\u0000KL\u0005\r\u0000\u0000LQ\u0003\b\u0004"+
"\u0003MN\n\u0001\u0000\u0000NO\u0005t\u0000\u0000OQ\u0003\b\u0004\u0002"+
"PJ\u0001\u0000\u0000\u0000PM\u0001\u0000\u0000\u0000QT\u0001\u0000\u0000"+
"\u0000RP\u0001\u0000\u0000\u0000RS\u0001\u0000\u0000\u0000S\t\u0001\u0000"+
"\u0000\u0000TR\u0001\u0000\u0000\u0000UV\u0003\u0014\n\u0000VW\u0003\f"+
"\u0006\u0000Wu\u0001\u0000\u0000\u0000XZ\u0005m\u0000\u0000YX\u0001\u0000"+
"\u0000\u0000YZ\u0001\u0000\u0000\u0000Z[\u0001\u0000\u0000\u0000[\\\u0005"+
"\u0014\u0000\u0000\\]\u0003\f\u0006\u0000]^\u0005\r\u0000\u0000^_\u0003"+
"\f\u0006\u0000_u\u0001\u0000\u0000\u0000`b\u0005m\u0000\u0000a`\u0001"+
"\u0000\u0000\u0000ab\u0001\u0000\u0000\u0000bc\u0001\u0000\u0000\u0000"+
"cd\u0005\b\u0000\u0000de\u0005\u0001\u0000\u0000ej\u0003\u0004\u0002\u0000"+
"fg\u0005\u0002\u0000\u0000gi\u0003\u0004\u0002\u0000hf\u0001\u0000\u0000"+
"\u0000il\u0001\u0000\u0000\u0000jh\u0001\u0000\u0000\u0000jk\u0001\u0000"+
"\u0000\u0000km\u0001\u0000\u0000\u0000lj\u0001\u0000\u0000\u0000mn\u0005"+
"\u0003\u0000\u0000nu\u0001\u0000\u0000\u0000oq\u0005X\u0000\u0000pr\u0005"+
"m\u0000\u0000qp\u0001\u0000\u0000\u0000qr\u0001\u0000\u0000\u0000rs\u0001"+
"\u0000\u0000\u0000su\u0005n\u0000\u0000tU\u0001\u0000\u0000\u0000tY\u0001"+
"\u0000\u0000\u0000ta\u0001\u0000\u0000\u0000to\u0001\u0000\u0000\u0000"+
"u\u000b\u0001\u0000\u0000\u0000vw\u0006\u0006\uffff\uffff\u0000w{\u0003"+
"\u0010\b\u0000xy\u0007\u0001\u0000\u0000y{\u0003\f\u0006\u0004zv\u0001"+
"\u0000\u0000\u0000zx\u0001\u0000\u0000\u0000{\u0087\u0001\u0000\u0000"+
"\u0000|}\n\u0003\u0000\u0000}~\u0007\u0002\u0000\u0000~\u0086\u0003\f"+
"\u0006\u0004\u007f\u0080\n\u0002\u0000\u0000\u0080\u0081\u0007\u0001\u0000"+
"\u0000\u0081\u0086\u0003\f\u0006\u0003\u0082\u0083\n\u0001\u0000\u0000"+
"\u0083\u0084\u0005\u00c7\u0000\u0000\u0084\u0086\u0003\f\u0006\u0002\u0085"+
"|\u0001\u0000\u0000\u0000\u0085\u007f\u0001\u0000\u0000\u0000\u0085\u0082"+
"\u0001\u0000\u0000\u0000\u0086\u0089\u0001\u0000\u0000\u0000\u0087\u0085"+
"\u0001\u0000\u0000\u0000\u0087\u0088\u0001\u0000\u0000\u0000\u0088\r\u0001"+
"\u0000\u0000\u0000\u0089\u0087\u0001\u0000\u0000\u0000\u008a\u008b\u0007"+
"\u0003\u0000\u0000\u008b\u000f\u0001\u0000\u0000\u0000\u008c\u008d\u0006"+
"\b\uffff\uffff\u0000\u008d\u00ec\u0005n\u0000\u0000\u008e\u008f\u0003"+
"*\u0015\u0000\u008f\u0090\u0003\u0012\t\u0000\u0090\u00ec\u0001\u0000"+
"\u0000\u0000\u0091\u0092\u0005\u00d4\u0000\u0000\u0092\u00ec\u0003\u0012"+
"\t\u0000\u0093\u00ec\u0003,\u0016\u0000\u0094\u00ec\u0003\u0018\f\u0000"+
"\u0095\u00ec\u0003\u0012\t\u0000\u0096\u00ec\u0005\u00ca\u0000\u0000\u0097"+
"\u00ec\u0005\u0004\u0000\u0000\u0098\u0099\u0005}\u0000\u0000\u0099\u009a"+
"\u0005\u0001\u0000\u0000\u009a\u009b\u0003\f\u0006\u0000\u009b\u009c\u0005"+
"\b\u0000\u0000\u009c\u009d\u0003\f\u0006\u0000\u009d\u009e\u0005\u0003"+
"\u0000\u0000\u009e\u00ec\u0001\u0000\u0000\u0000\u009f\u00a0\u0005P\u0000"+
"\u0000\u00a0\u00a1\u0003\b\u0004\u0000\u00a1\u00a2\u0005\u00a2\u0000\u0000"+
"\u00a2\u00a6\u0003\u0004\u0002\u0000\u00a3\u00a5\u0003\u0006\u0003\u0000"+
"\u00a4\u00a3\u0001\u0000\u0000\u0000\u00a5\u00a8\u0001\u0000\u0000\u0000"+
"\u00a6\u00a4\u0001\u0000\u0000\u0000\u00a6\u00a7\u0001\u0000\u0000\u0000"+
"\u00a7\u00a9\u0001\u0000\u0000\u0000\u00a8\u00a6\u0001\u0000\u0000\u0000"+
"\u00a9\u00aa\u00051\u0000\u0000\u00aa\u00ab\u0003\u0004\u0002\u0000\u00ab"+
"\u00ec\u0001\u0000\u0000\u0000\u00ac\u00ad\u0003(\u0014\u0000\u00ad\u00ae"+
"\u0005\u0001\u0000\u0000\u00ae\u00af\u0005\u00c4\u0000\u0000\u00af\u00b0"+
"\u0005\u0003\u0000\u0000\u00b0\u00ec\u0001\u0000\u0000\u0000\u00b1\u00b2"+
"\u0003(\u0014\u0000\u00b2\u00be\u0005\u0001\u0000\u0000\u00b3\u00b5\u0003"+
"\u000e\u0007\u0000\u00b4\u00b3\u0001\u0000\u0000\u0000\u00b4\u00b5\u0001"+
"\u0000\u0000\u0000\u00b5\u00b6\u0001\u0000\u0000\u0000\u00b6\u00bb\u0003"+
"\u0004\u0002\u0000\u00b7\u00b8\u0005\u0002\u0000\u0000\u00b8\u00ba\u0003"+
"\u0004\u0002\u0000\u00b9\u00b7\u0001\u0000\u0000\u0000\u00ba\u00bd\u0001"+
"\u0000\u0000\u0000\u00bb\u00b9\u0001\u0000\u0000\u0000\u00bb\u00bc\u0001"+
"\u0000\u0000\u0000\u00bc\u00bf\u0001\u0000\u0000\u0000\u00bd\u00bb\u0001"+
"\u0000\u0000\u0000\u00be\u00b4\u0001\u0000\u0000\u0000\u00be\u00bf\u0001"+
"\u0000\u0000\u0000\u00bf\u00c0\u0001\u0000\u0000\u0000\u00c0\u00c1\u0005"+
"\u0003\u0000\u0000\u00c1\u00ec\u0001\u0000\u0000\u0000\u00c2\u00c3\u0005"+
"\u000f\u0000\u0000\u00c3\u00cc\u0005\u0005\u0000\u0000\u00c4\u00c9\u0003"+
"\u0004\u0002\u0000\u00c5\u00c6\u0005\u0002\u0000\u0000\u00c6\u00c8\u0003"+
"\u0004\u0002\u0000\u00c7\u00c5\u0001\u0000\u0000\u0000\u00c8\u00cb\u0001"+
"\u0000\u0000\u0000\u00c9\u00c7\u0001\u0000\u0000\u0000\u00c9\u00ca\u0001"+
"\u0000\u0000\u0000\u00ca\u00cd\u0001\u0000\u0000\u0000\u00cb\u00c9\u0001"+
"\u0000\u0000\u0000\u00cc\u00c4\u0001\u0000\u0000\u0000\u00cc\u00cd\u0001"+
"\u0000\u0000\u0000\u00cd\u00ce\u0001\u0000\u0000\u0000\u00ce\u00ec\u0005"+
"\u0006\u0000\u0000\u00cf\u00ec\u0003*\u0015\u0000\u00d0\u00d4\u0005`\u0000"+
"\u0000\u00d1\u00d2\u0005\u0001\u0000\u0000\u00d2\u00d3\u0005\u00cb\u0000"+
"\u0000\u00d3\u00d5\u0005\u0003\u0000\u0000\u00d4\u00d1\u0001\u0000\u0000"+
"\u0000\u00d4\u00d5\u0001\u0000\u0000\u0000\u00d5\u00ec\u0001\u0000\u0000"+
"\u0000\u00d6\u00da\u0005a\u0000\u0000\u00d7\u00d8\u0005\u0001\u0000\u0000"+
"\u00d8\u00d9\u0005\u00cb\u0000\u0000\u00d9\u00db\u0005\u0003\u0000\u0000"+
"\u00da\u00d7\u0001\u0000\u0000\u0000\u00da\u00db\u0001\u0000\u0000\u0000"+
"\u00db\u00ec\u0001\u0000\u0000\u0000\u00dc\u00ec\u0005&\u0000\u0000\u00dd"+
"\u00ec\u0005%\u0000\u0000\u00de\u00df\u0005l\u0000\u0000\u00df\u00e0\u0005"+
"\u0001\u0000\u0000\u00e0\u00e3\u0003\f\u0006\u0000\u00e1\u00e2\u0005\u0002"+
"\u0000\u0000\u00e2\u00e4\u0003\u001a\r\u0000\u00e3\u00e1\u0001\u0000\u0000"+
"\u0000\u00e3\u00e4\u0001\u0000\u0000\u0000\u00e4\u00e5\u0001\u0000\u0000"+
"\u0000\u00e5\u00e6\u0005\u0003\u0000\u0000\u00e6\u00ec\u0001\u0000\u0000"+
"\u0000\u00e7\u00e8\u0005\u0001\u0000\u0000\u00e8\u00e9\u0003\u0004\u0002"+
"\u0000\u00e9\u00ea\u0005\u0003\u0000\u0000\u00ea\u00ec\u0001\u0000\u0000"+
"\u0000\u00eb\u008c\u0001\u0000\u0000\u0000\u00eb\u008e\u0001\u0000\u0000"+
"\u0000\u00eb\u0091\u0001\u0000\u0000\u0000\u00eb\u0093\u0001\u0000\u0000"+
"\u0000\u00eb\u0094\u0001\u0000\u0000\u0000\u00eb\u0095\u0001\u0000\u0000"+
"\u0000\u00eb\u0096\u0001\u0000\u0000\u0000\u00eb\u0097\u0001\u0000\u0000"+
"\u0000\u00eb\u0098\u0001\u0000\u0000\u0000\u00eb\u009f\u0001\u0000\u0000"+
"\u0000\u00eb\u00ac\u0001\u0000\u0000\u0000\u00eb\u00b1\u0001\u0000\u0000"+
"\u0000\u00eb\u00c2\u0001\u0000\u0000\u0000\u00eb\u00cf\u0001\u0000\u0000"+
"\u0000\u00eb\u00d0\u0001\u0000\u0000\u0000\u00eb\u00d6\u0001\u0000\u0000"+
"\u0000\u00eb\u00dc\u0001\u0000\u0000\u0000\u00eb\u00dd\u0001\u0000\u0000"+
"\u0000\u00eb\u00de\u0001\u0000\u0000\u0000\u00eb\u00e7\u0001\u0000\u0000"+
"\u0000\u00ec\u00fe\u0001\u0000\u0000\u0000\u00ed\u00ee\n\n\u0000\u0000"+
"\u00ee\u00ef\u0005\u0005\u0000\u0000\u00ef\u00f0\u0003\f\u0006\u0000\u00f0"+
"\u00f1\u0005\u0006\u0000\u0000\u00f1\u00fd\u0001\u0000\u0000\u0000\u00f2"+
"\u00f3\n\t\u0000\u0000\u00f3\u00f4\u0005\u0005\u0000\u0000\u00f4\u00f5"+
"\u0003\f\u0006\u0000\u00f5\u00f6\u0005\u0002\u0000\u0000\u00f6\u00f7\u0003"+
"\f\u0006\u0000\u00f7\u00f8\u0005\u0006\u0000\u0000\u00f8\u00fd\u0001\u0000"+
"\u0000\u0000\u00f9\u00fa\n\u0007\u0000\u0000\u00fa\u00fb\u0005\u0007\u0000"+
"\u0000\u00fb\u00fd\u0003*\u0015\u0000\u00fc\u00ed\u0001\u0000\u0000\u0000"+
"\u00fc\u00f2\u0001\u0000\u0000\u0000\u00fc\u00f9\u0001\u0000\u0000\u0000"+
"\u00fd\u0100\u0001\u0000\u0000\u0000\u00fe\u00fc\u0001\u0000\u0000\u0000"+
"\u00fe\u00ff\u0001\u0000\u0000\u0000\u00ff\u0011\u0001\u0000\u0000\u0000"+
"\u0100\u00fe\u0001\u0000\u0000\u0000\u0101\u0108\u0005\u00c8\u0000\u0000"+
"\u0102\u0105\u0005\u00c9\u0000\u0000\u0103\u0104\u0005\u00aa\u0000\u0000"+
"\u0104\u0106\u0005\u00c8\u0000\u0000\u0105\u0103\u0001\u0000\u0000\u0000"+
"\u0105\u0106\u0001\u0000\u0000\u0000\u0106\u0108\u0001\u0000\u0000\u0000"+
"\u0107\u0101\u0001\u0000\u0000\u0000\u0107\u0102\u0001\u0000\u0000\u0000"+
"\u0108\u0013\u0001\u0000\u0000\u0000\u0109\u010a\u0007\u0004\u0000\u0000"+
"\u010a\u0015\u0001\u0000\u0000\u0000\u010b\u010c\u0007\u0005\u0000\u0000"+
"\u010c\u0017\u0001\u0000\u0000\u0000\u010d\u010e\u0007\u0006\u0000\u0000"+
"\u010e\u0019\u0001\u0000\u0000\u0000\u010f\u0110\u0007\u0007\u0000\u0000"+
"\u0110\u001b\u0001\u0000\u0000\u0000\u0111\u0112\u0006\u000e\uffff\uffff"+
"\u0000\u0112\u0113\u0005\u000f\u0000\u0000\u0113\u0114\u0005\u00be\u0000"+
"\u0000\u0114\u0115\u0003\u001c\u000e\u0000\u0115\u0116\u0005\u00c0\u0000"+
"\u0000\u0116\u013c\u0001\u0000\u0000\u0000\u0117\u0118\u0005c\u0000\u0000"+
"\u0118\u0119\u0005\u00be\u0000\u0000\u0119\u011a\u0003\u001c\u000e\u0000"+
"\u011a\u011b\u0005\u0002\u0000\u0000\u011b\u011c\u0003\u001c\u000e\u0000"+
"\u011c\u011d\u0005\u00c0\u0000\u0000\u011d\u013c\u0001\u0000\u0000\u0000"+
"\u011e\u011f\u0005\u008e\u0000\u0000\u011f\u0120\u0005\u0001\u0000\u0000"+
"\u0120\u0121\u0003*\u0015\u0000\u0121\u0128\u0003\u001c\u000e\u0000\u0122"+
"\u0123\u0005\u0002\u0000\u0000\u0123\u0124\u0003*\u0015\u0000\u0124\u0125"+
"\u0003\u001c\u000e\u0000\u0125\u0127\u0001\u0000\u0000\u0000\u0126\u0122"+
"\u0001\u0000\u0000\u0000\u0127\u012a\u0001\u0000\u0000\u0000\u0128\u0126"+
"\u0001\u0000\u0000\u0000\u0128\u0129\u0001\u0000\u0000\u0000\u0129\u012b"+
"\u0001\u0000\u0000\u0000\u012a\u0128\u0001\u0000\u0000\u0000\u012b\u012c"+
"\u0005\u0003\u0000\u0000\u012c\u013c\u0001\u0000\u0000\u0000\u012d\u0139"+
"\u0003 \u0010\u0000\u012e\u012f\u0005\u0001\u0000\u0000\u012f\u0134\u0003"+
"\u001e\u000f\u0000\u0130\u0131\u0005\u0002\u0000\u0000\u0131\u0133\u0003"+
"\u001e\u000f\u0000\u0132\u0130\u0001\u0000\u0000\u0000\u0133\u0136\u0001"+
"\u0000\u0000\u0000\u0134\u0132\u0001\u0000\u0000\u0000\u0134\u0135\u0001"+
"\u0000\u0000\u0000\u0135\u0137\u0001\u0000\u0000\u0000\u0136\u0134\u0001"+
"\u0000\u0000\u0000\u0137\u0138\u0005\u0003\u0000\u0000\u0138\u013a\u0001"+
"\u0000\u0000\u0000\u0139\u012e\u0001\u0000\u0000\u0000\u0139\u013a\u0001"+
"\u0000\u0000\u0000\u013a\u013c\u0001\u0000\u0000\u0000\u013b\u0111\u0001"+
"\u0000\u0000\u0000\u013b\u0117\u0001\u0000\u0000\u0000\u013b\u011e\u0001"+
"\u0000\u0000\u0000\u013b\u012d\u0001\u0000\u0000\u0000\u013c\u0141\u0001"+
"\u0000\u0000\u0000\u013d\u013e\n\u0005\u0000\u0000\u013e\u0140\u0005\u000f"+
"\u0000\u0000\u013f\u013d\u0001\u0000\u0000\u0000\u0140\u0143\u0001\u0000"+
"\u0000\u0000\u0141\u013f\u0001\u0000\u0000\u0000\u0141\u0142\u0001\u0000"+
"\u0000\u0000\u0142\u001d\u0001\u0000\u0000\u0000\u0143\u0141\u0001\u0000"+
"\u0000\u0000\u0144\u0147\u0005\u00cb\u0000\u0000\u0145\u0147\u0003\u001c"+
"\u000e\u0000\u0146\u0144\u0001\u0000\u0000\u0000\u0146\u0145\u0001\u0000"+
"\u0000\u0000\u0147\u001f\u0001\u0000\u0000\u0000\u0148\u014d\u0005\u00d2"+
"\u0000\u0000\u0149\u014d\u0005\u00d3\u0000\u0000\u014a\u014d\u0005\u00d4"+
"\u0000\u0000\u014b\u014d\u0003*\u0015\u0000\u014c\u0148\u0001\u0000\u0000"+
"\u0000\u014c\u0149\u0001\u0000\u0000\u0000\u014c\u014a\u0001\u0000\u0000"+
"\u0000\u014c\u014b\u0001\u0000\u0000\u0000\u014d!\u0001\u0000\u0000\u0000"+
"\u014e\u014f\u0003*\u0015\u0000\u014f\u0150\u0005\u0007\u0000\u0000\u0150"+
"\u0151\u0003*\u0015\u0000\u0151\u0154\u0001\u0000\u0000\u0000\u0152\u0154"+
"\u0003*\u0015\u0000\u0153\u014e\u0001\u0000\u0000\u0000\u0153\u0152\u0001"+
"\u0000\u0000\u0000\u0154#\u0001\u0000\u0000\u0000\u0155\u015a\u0003\""+
"\u0011\u0000\u0156\u0157\u0005\u0002\u0000\u0000\u0157\u0159\u0003\"\u0011"+
"\u0000\u0158\u0156\u0001\u0000\u0000\u0000\u0159\u015c\u0001\u0000\u0000"+
"\u0000\u015a\u0158\u0001\u0000\u0000\u0000\u015a\u015b\u0001\u0000\u0000"+
"\u0000\u015b%\u0001\u0000\u0000\u0000\u015c\u015a\u0001\u0000\u0000\u0000"+
"\u015d\u0162\u0005\u0093\u0000\u0000\u015e\u0162\u0005+\u0000\u0000\u015f"+
"\u0162\u0005T\u0000\u0000\u0160\u0162\u0003*\u0015\u0000\u0161\u015d\u0001"+
"\u0000\u0000\u0000\u0161\u015e\u0001\u0000\u0000\u0000\u0161\u015f\u0001"+
"\u0000\u0000\u0000\u0161\u0160\u0001\u0000\u0000\u0000\u0162\'\u0001\u0000"+
"\u0000\u0000\u0163\u0168\u0003*\u0015\u0000\u0164\u0165\u0005\u0007\u0000"+
"\u0000\u0165\u0167\u0003*\u0015\u0000\u0166\u0164\u0001\u0000\u0000\u0000"+
"\u0167\u016a\u0001\u0000\u0000\u0000\u0168\u0166\u0001\u0000\u0000\u0000"+
"\u0168\u0169\u0001\u0000\u0000\u0000\u0169)\u0001\u0000\u0000\u0000\u016a"+
"\u0168\u0001\u0000\u0000\u0000\u016b\u0171\u0005\u00ce\u0000\u0000\u016c"+
"\u0171\u0005\u00d0\u0000\u0000\u016d\u0171\u0003.\u0017\u0000\u016e\u0171"+
"\u0005\u00d1\u0000\u0000\u016f\u0171\u0005\u00cf\u0000\u0000\u0170\u016b"+
"\u0001\u0000\u0000\u0000\u0170\u016c\u0001\u0000\u0000\u0000\u0170\u016d"+
"\u0001\u0000\u0000\u0000\u0170\u016e\u0001\u0000\u0000\u0000\u0170\u016f"+
"\u0001\u0000\u0000\u0000\u0171+\u0001\u0000\u0000\u0000\u0172\u0176\u0005"+
"\u00cc\u0000\u0000\u0173\u0176\u0005\u00cd\u0000\u0000\u0174\u0176\u0005"+
"\u00cb\u0000\u0000\u0175\u0172\u0001\u0000\u0000\u0000\u0175\u0173\u0001"+
"\u0000\u0000\u0000\u0175\u0174\u0001\u0000\u0000\u0000\u0176-\u0001\u0000"+
"\u0000\u0000\u0177\u0178\u0007\b\u0000\u0000\u0178/\u0001\u0000\u0000"+
"\u0000(?DHPRYajqtz\u0085\u0087\u00a6\u00b4\u00bb\u00be\u00c9\u00cc\u00d4"+
"\u00da\u00e3\u00eb\u00fc\u00fe\u0105\u0107\u0128\u0134\u0139\u013b\u0141"+
"\u0146\u014c\u0153\u015a\u0161\u0168\u0170\u0175";
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);
}
}
}