org.apache.spark.sql.catalyst.parser.extensions.IcebergSqlExtensionsParser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of iceberg-spark3-extensions Show documentation
Show all versions of iceberg-spark3-extensions Show documentation
A table format for huge analytic datasets
// Generated from org.apache.spark.sql.catalyst.parser.extensions/IcebergSqlExtensions.g4 by ANTLR 4.7.1
package org.apache.spark.sql.catalyst.parser.extensions;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class IcebergSqlExtensionsParser extends Parser {
static { RuntimeMetaData.checkVersion("4.7.1", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, ADD=6, ALTER=7, AS=8, ASC=9, BY=10,
CALL=11, DESC=12, DROP=13, FIELD=14, FIRST=15, LAST=16, NULLS=17, ORDERED=18,
PARTITION=19, TABLE=20, WRITE=21, TRUE=22, FALSE=23, MAP=24, PLUS=25,
MINUS=26, STRING=27, BIGINT_LITERAL=28, SMALLINT_LITERAL=29, TINYINT_LITERAL=30,
INTEGER_VALUE=31, EXPONENT_VALUE=32, DECIMAL_VALUE=33, FLOAT_LITERAL=34,
DOUBLE_LITERAL=35, BIGDECIMAL_LITERAL=36, IDENTIFIER=37, BACKQUOTED_IDENTIFIER=38,
SIMPLE_COMMENT=39, BRACKETED_COMMENT=40, WS=41, UNRECOGNIZED=42;
public static final int
RULE_singleStatement = 0, RULE_statement = 1, RULE_callArgument = 2, RULE_order = 3,
RULE_orderField = 4, RULE_transform = 5, RULE_transformArgument = 6, RULE_expression = 7,
RULE_constant = 8, RULE_stringMap = 9, RULE_booleanValue = 10, RULE_number = 11,
RULE_multipartIdentifier = 12, RULE_identifier = 13, RULE_quotedIdentifier = 14,
RULE_nonReserved = 15;
public static final String[] ruleNames = {
"singleStatement", "statement", "callArgument", "order", "orderField",
"transform", "transformArgument", "expression", "constant", "stringMap",
"booleanValue", "number", "multipartIdentifier", "identifier", "quotedIdentifier",
"nonReserved"
};
private static final String[] _LITERAL_NAMES = {
null, "'('", "','", "')'", "'=>'", "'.'", "'ADD'", "'ALTER'", "'AS'",
"'ASC'", "'BY'", "'CALL'", "'DESC'", "'DROP'", "'FIELD'", "'FIRST'", "'LAST'",
"'NULLS'", "'ORDERED'", "'PARTITION'", "'TABLE'", "'WRITE'", "'TRUE'",
"'FALSE'", "'MAP'", "'+'", "'-'"
};
private static final String[] _SYMBOLIC_NAMES = {
null, null, null, null, null, null, "ADD", "ALTER", "AS", "ASC", "BY",
"CALL", "DESC", "DROP", "FIELD", "FIRST", "LAST", "NULLS", "ORDERED",
"PARTITION", "TABLE", "WRITE", "TRUE", "FALSE", "MAP", "PLUS", "MINUS",
"STRING", "BIGINT_LITERAL", "SMALLINT_LITERAL", "TINYINT_LITERAL", "INTEGER_VALUE",
"EXPONENT_VALUE", "DECIMAL_VALUE", "FLOAT_LITERAL", "DOUBLE_LITERAL",
"BIGDECIMAL_LITERAL", "IDENTIFIER", "BACKQUOTED_IDENTIFIER", "SIMPLE_COMMENT",
"BRACKETED_COMMENT", "WS", "UNRECOGNIZED"
};
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 "IcebergSqlExtensions.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public IcebergSqlExtensionsParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class SingleStatementContext extends ParserRuleContext {
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public TerminalNode EOF() { return getToken(IcebergSqlExtensionsParser.EOF, 0); }
public SingleStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_singleStatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterSingleStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitSingleStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitSingleStatement(this);
else return visitor.visitChildren(this);
}
}
public final SingleStatementContext singleStatement() throws RecognitionException {
SingleStatementContext _localctx = new SingleStatementContext(_ctx, getState());
enterRule(_localctx, 0, RULE_singleStatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(32);
statement();
setState(33);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StatementContext extends ParserRuleContext {
public StatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statement; }
public StatementContext() { }
public void copyFrom(StatementContext ctx) {
super.copyFrom(ctx);
}
}
public static class CallContext extends StatementContext {
public TerminalNode CALL() { return getToken(IcebergSqlExtensionsParser.CALL, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public List callArgument() {
return getRuleContexts(CallArgumentContext.class);
}
public CallArgumentContext callArgument(int i) {
return getRuleContext(CallArgumentContext.class,i);
}
public CallContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterCall(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitCall(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitCall(this);
else return visitor.visitChildren(this);
}
}
public static class SetTableOrderContext extends StatementContext {
public TerminalNode ALTER() { return getToken(IcebergSqlExtensionsParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(IcebergSqlExtensionsParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode WRITE() { return getToken(IcebergSqlExtensionsParser.WRITE, 0); }
public TerminalNode ORDERED() { return getToken(IcebergSqlExtensionsParser.ORDERED, 0); }
public TerminalNode BY() { return getToken(IcebergSqlExtensionsParser.BY, 0); }
public OrderContext order() {
return getRuleContext(OrderContext.class,0);
}
public SetTableOrderContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterSetTableOrder(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitSetTableOrder(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitSetTableOrder(this);
else return visitor.visitChildren(this);
}
}
public static class AddPartitionFieldContext extends StatementContext {
public IdentifierContext name;
public TerminalNode ALTER() { return getToken(IcebergSqlExtensionsParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(IcebergSqlExtensionsParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode ADD() { return getToken(IcebergSqlExtensionsParser.ADD, 0); }
public TerminalNode PARTITION() { return getToken(IcebergSqlExtensionsParser.PARTITION, 0); }
public TerminalNode FIELD() { return getToken(IcebergSqlExtensionsParser.FIELD, 0); }
public TransformContext transform() {
return getRuleContext(TransformContext.class,0);
}
public TerminalNode AS() { return getToken(IcebergSqlExtensionsParser.AS, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public AddPartitionFieldContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterAddPartitionField(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitAddPartitionField(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitAddPartitionField(this);
else return visitor.visitChildren(this);
}
}
public static class DropPartitionFieldContext extends StatementContext {
public TerminalNode ALTER() { return getToken(IcebergSqlExtensionsParser.ALTER, 0); }
public TerminalNode TABLE() { return getToken(IcebergSqlExtensionsParser.TABLE, 0); }
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public TerminalNode DROP() { return getToken(IcebergSqlExtensionsParser.DROP, 0); }
public TerminalNode PARTITION() { return getToken(IcebergSqlExtensionsParser.PARTITION, 0); }
public TerminalNode FIELD() { return getToken(IcebergSqlExtensionsParser.FIELD, 0); }
public TransformContext transform() {
return getRuleContext(TransformContext.class,0);
}
public DropPartitionFieldContext(StatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterDropPartitionField(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitDropPartitionField(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitDropPartitionField(this);
else return visitor.visitChildren(this);
}
}
public final StatementContext statement() throws RecognitionException {
StatementContext _localctx = new StatementContext(_ctx, getState());
enterRule(_localctx, 2, RULE_statement);
int _la;
try {
setState(77);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
case 1:
_localctx = new CallContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(35);
match(CALL);
setState(36);
multipartIdentifier();
setState(37);
match(T__0);
setState(46);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALTER) | (1L << AS) | (1L << ASC) | (1L << BY) | (1L << CALL) | (1L << DESC) | (1L << DROP) | (1L << FIELD) | (1L << FIRST) | (1L << LAST) | (1L << NULLS) | (1L << ORDERED) | (1L << PARTITION) | (1L << TABLE) | (1L << WRITE) | (1L << TRUE) | (1L << FALSE) | (1L << MAP) | (1L << MINUS) | (1L << STRING) | (1L << BIGINT_LITERAL) | (1L << SMALLINT_LITERAL) | (1L << TINYINT_LITERAL) | (1L << INTEGER_VALUE) | (1L << EXPONENT_VALUE) | (1L << DECIMAL_VALUE) | (1L << FLOAT_LITERAL) | (1L << DOUBLE_LITERAL) | (1L << BIGDECIMAL_LITERAL) | (1L << IDENTIFIER) | (1L << BACKQUOTED_IDENTIFIER))) != 0)) {
{
setState(38);
callArgument();
setState(43);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(39);
match(T__1);
setState(40);
callArgument();
}
}
setState(45);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(48);
match(T__2);
}
break;
case 2:
_localctx = new AddPartitionFieldContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(50);
match(ALTER);
setState(51);
match(TABLE);
setState(52);
multipartIdentifier();
setState(53);
match(ADD);
setState(54);
match(PARTITION);
setState(55);
match(FIELD);
setState(56);
transform();
setState(59);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(57);
match(AS);
setState(58);
((AddPartitionFieldContext)_localctx).name = identifier();
}
}
}
break;
case 3:
_localctx = new DropPartitionFieldContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(61);
match(ALTER);
setState(62);
match(TABLE);
setState(63);
multipartIdentifier();
setState(64);
match(DROP);
setState(65);
match(PARTITION);
setState(66);
match(FIELD);
setState(67);
transform();
}
break;
case 4:
_localctx = new SetTableOrderContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(69);
match(ALTER);
setState(70);
match(TABLE);
setState(71);
multipartIdentifier();
setState(72);
match(WRITE);
setState(73);
match(ORDERED);
setState(74);
match(BY);
setState(75);
order();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CallArgumentContext extends ParserRuleContext {
public CallArgumentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_callArgument; }
public CallArgumentContext() { }
public void copyFrom(CallArgumentContext ctx) {
super.copyFrom(ctx);
}
}
public static class PositionalArgumentContext extends CallArgumentContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public PositionalArgumentContext(CallArgumentContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterPositionalArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitPositionalArgument(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitPositionalArgument(this);
else return visitor.visitChildren(this);
}
}
public static class NamedArgumentContext extends CallArgumentContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public NamedArgumentContext(CallArgumentContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterNamedArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitNamedArgument(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitNamedArgument(this);
else return visitor.visitChildren(this);
}
}
public final CallArgumentContext callArgument() throws RecognitionException {
CallArgumentContext _localctx = new CallArgumentContext(_ctx, getState());
enterRule(_localctx, 4, RULE_callArgument);
try {
setState(84);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
case 1:
_localctx = new PositionalArgumentContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(79);
expression();
}
break;
case 2:
_localctx = new NamedArgumentContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(80);
identifier();
setState(81);
match(T__3);
setState(82);
expression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OrderContext extends ParserRuleContext {
public OrderFieldContext orderField;
public List fields = new ArrayList();
public List orderField() {
return getRuleContexts(OrderFieldContext.class);
}
public OrderFieldContext orderField(int i) {
return getRuleContext(OrderFieldContext.class,i);
}
public OrderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_order; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterOrder(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitOrder(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitOrder(this);
else return visitor.visitChildren(this);
}
}
public final OrderContext order() throws RecognitionException {
OrderContext _localctx = new OrderContext(_ctx, getState());
enterRule(_localctx, 6, RULE_order);
int _la;
try {
setState(105);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ADD:
case ALTER:
case AS:
case ASC:
case BY:
case CALL:
case DESC:
case DROP:
case FIELD:
case FIRST:
case LAST:
case NULLS:
case ORDERED:
case PARTITION:
case TABLE:
case WRITE:
case TRUE:
case FALSE:
case MAP:
case IDENTIFIER:
case BACKQUOTED_IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(86);
((OrderContext)_localctx).orderField = orderField();
((OrderContext)_localctx).fields.add(((OrderContext)_localctx).orderField);
setState(91);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(87);
match(T__1);
setState(88);
((OrderContext)_localctx).orderField = orderField();
((OrderContext)_localctx).fields.add(((OrderContext)_localctx).orderField);
}
}
setState(93);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case T__0:
enterOuterAlt(_localctx, 2);
{
setState(94);
match(T__0);
setState(95);
((OrderContext)_localctx).orderField = orderField();
((OrderContext)_localctx).fields.add(((OrderContext)_localctx).orderField);
setState(100);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(96);
match(T__1);
setState(97);
((OrderContext)_localctx).orderField = orderField();
((OrderContext)_localctx).fields.add(((OrderContext)_localctx).orderField);
}
}
setState(102);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(103);
match(T__2);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OrderFieldContext extends ParserRuleContext {
public Token direction;
public Token nullOrder;
public TransformContext transform() {
return getRuleContext(TransformContext.class,0);
}
public TerminalNode NULLS() { return getToken(IcebergSqlExtensionsParser.NULLS, 0); }
public TerminalNode ASC() { return getToken(IcebergSqlExtensionsParser.ASC, 0); }
public TerminalNode DESC() { return getToken(IcebergSqlExtensionsParser.DESC, 0); }
public TerminalNode FIRST() { return getToken(IcebergSqlExtensionsParser.FIRST, 0); }
public TerminalNode LAST() { return getToken(IcebergSqlExtensionsParser.LAST, 0); }
public OrderFieldContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_orderField; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterOrderField(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitOrderField(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitOrderField(this);
else return visitor.visitChildren(this);
}
}
public final OrderFieldContext orderField() throws RecognitionException {
OrderFieldContext _localctx = new OrderFieldContext(_ctx, getState());
enterRule(_localctx, 8, RULE_orderField);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(107);
transform();
setState(109);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ASC || _la==DESC) {
{
setState(108);
((OrderFieldContext)_localctx).direction = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==ASC || _la==DESC) ) {
((OrderFieldContext)_localctx).direction = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(113);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NULLS) {
{
setState(111);
match(NULLS);
setState(112);
((OrderFieldContext)_localctx).nullOrder = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==FIRST || _la==LAST) ) {
((OrderFieldContext)_localctx).nullOrder = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TransformContext extends ParserRuleContext {
public TransformContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_transform; }
public TransformContext() { }
public void copyFrom(TransformContext ctx) {
super.copyFrom(ctx);
}
}
public static class IdentityTransformContext extends TransformContext {
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public IdentityTransformContext(TransformContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterIdentityTransform(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitIdentityTransform(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitIdentityTransform(this);
else return visitor.visitChildren(this);
}
}
public static class ApplyTransformContext extends TransformContext {
public IdentifierContext transformName;
public TransformArgumentContext transformArgument;
public List arguments = new ArrayList();
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public List transformArgument() {
return getRuleContexts(TransformArgumentContext.class);
}
public TransformArgumentContext transformArgument(int i) {
return getRuleContext(TransformArgumentContext.class,i);
}
public ApplyTransformContext(TransformContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterApplyTransform(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitApplyTransform(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitApplyTransform(this);
else return visitor.visitChildren(this);
}
}
public final TransformContext transform() throws RecognitionException {
TransformContext _localctx = new TransformContext(_ctx, getState());
enterRule(_localctx, 10, RULE_transform);
int _la;
try {
setState(128);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
case 1:
_localctx = new IdentityTransformContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(115);
multipartIdentifier();
}
break;
case 2:
_localctx = new ApplyTransformContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(116);
((ApplyTransformContext)_localctx).transformName = identifier();
setState(117);
match(T__0);
setState(118);
((ApplyTransformContext)_localctx).transformArgument = transformArgument();
((ApplyTransformContext)_localctx).arguments.add(((ApplyTransformContext)_localctx).transformArgument);
setState(123);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(119);
match(T__1);
setState(120);
((ApplyTransformContext)_localctx).transformArgument = transformArgument();
((ApplyTransformContext)_localctx).arguments.add(((ApplyTransformContext)_localctx).transformArgument);
}
}
setState(125);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(126);
match(T__2);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TransformArgumentContext extends ParserRuleContext {
public MultipartIdentifierContext multipartIdentifier() {
return getRuleContext(MultipartIdentifierContext.class,0);
}
public ConstantContext constant() {
return getRuleContext(ConstantContext.class,0);
}
public TransformArgumentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_transformArgument; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterTransformArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitTransformArgument(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitTransformArgument(this);
else return visitor.visitChildren(this);
}
}
public final TransformArgumentContext transformArgument() throws RecognitionException {
TransformArgumentContext _localctx = new TransformArgumentContext(_ctx, getState());
enterRule(_localctx, 12, RULE_transformArgument);
try {
setState(132);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(130);
multipartIdentifier();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(131);
constant();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionContext extends ParserRuleContext {
public ConstantContext constant() {
return getRuleContext(ConstantContext.class,0);
}
public StringMapContext stringMap() {
return getRuleContext(StringMapContext.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 IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitExpression(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionContext expression() throws RecognitionException {
ExpressionContext _localctx = new ExpressionContext(_ctx, getState());
enterRule(_localctx, 14, RULE_expression);
try {
setState(136);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(134);
constant();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(135);
stringMap();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstantContext extends ParserRuleContext {
public ConstantContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constant; }
public ConstantContext() { }
public void copyFrom(ConstantContext ctx) {
super.copyFrom(ctx);
}
}
public static class StringLiteralContext extends ConstantContext {
public List STRING() { return getTokens(IcebergSqlExtensionsParser.STRING); }
public TerminalNode STRING(int i) {
return getToken(IcebergSqlExtensionsParser.STRING, i);
}
public StringLiteralContext(ConstantContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterStringLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitStringLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitStringLiteral(this);
else return visitor.visitChildren(this);
}
}
public static class TypeConstructorContext extends ConstantContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode STRING() { return getToken(IcebergSqlExtensionsParser.STRING, 0); }
public TypeConstructorContext(ConstantContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterTypeConstructor(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitTypeConstructor(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitTypeConstructor(this);
else return visitor.visitChildren(this);
}
}
public static class NumericLiteralContext extends ConstantContext {
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public NumericLiteralContext(ConstantContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterNumericLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitNumericLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitNumericLiteral(this);
else return visitor.visitChildren(this);
}
}
public static class BooleanLiteralContext extends ConstantContext {
public BooleanValueContext booleanValue() {
return getRuleContext(BooleanValueContext.class,0);
}
public BooleanLiteralContext(ConstantContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterBooleanLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitBooleanLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitBooleanLiteral(this);
else return visitor.visitChildren(this);
}
}
public final ConstantContext constant() throws RecognitionException {
ConstantContext _localctx = new ConstantContext(_ctx, getState());
enterRule(_localctx, 16, RULE_constant);
int _la;
try {
setState(148);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
case 1:
_localctx = new NumericLiteralContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(138);
number();
}
break;
case 2:
_localctx = new BooleanLiteralContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(139);
booleanValue();
}
break;
case 3:
_localctx = new StringLiteralContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(141);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(140);
match(STRING);
}
}
setState(143);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==STRING );
}
break;
case 4:
_localctx = new TypeConstructorContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(145);
identifier();
setState(146);
match(STRING);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StringMapContext extends ParserRuleContext {
public TerminalNode MAP() { return getToken(IcebergSqlExtensionsParser.MAP, 0); }
public List constant() {
return getRuleContexts(ConstantContext.class);
}
public ConstantContext constant(int i) {
return getRuleContext(ConstantContext.class,i);
}
public StringMapContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stringMap; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterStringMap(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitStringMap(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitStringMap(this);
else return visitor.visitChildren(this);
}
}
public final StringMapContext stringMap() throws RecognitionException {
StringMapContext _localctx = new StringMapContext(_ctx, getState());
enterRule(_localctx, 18, RULE_stringMap);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(150);
match(MAP);
setState(151);
match(T__0);
setState(152);
constant();
setState(157);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__1) {
{
{
setState(153);
match(T__1);
setState(154);
constant();
}
}
setState(159);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(160);
match(T__2);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BooleanValueContext extends ParserRuleContext {
public TerminalNode TRUE() { return getToken(IcebergSqlExtensionsParser.TRUE, 0); }
public TerminalNode FALSE() { return getToken(IcebergSqlExtensionsParser.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 IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterBooleanValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitBooleanValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitBooleanValue(this);
else return visitor.visitChildren(this);
}
}
public final BooleanValueContext booleanValue() throws RecognitionException {
BooleanValueContext _localctx = new BooleanValueContext(_ctx, getState());
enterRule(_localctx, 20, RULE_booleanValue);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(162);
_la = _input.LA(1);
if ( !(_la==TRUE || _la==FALSE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class 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);
}
}
public static class DecimalLiteralContext extends NumberContext {
public TerminalNode DECIMAL_VALUE() { return getToken(IcebergSqlExtensionsParser.DECIMAL_VALUE, 0); }
public TerminalNode MINUS() { return getToken(IcebergSqlExtensionsParser.MINUS, 0); }
public DecimalLiteralContext(NumberContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterDecimalLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitDecimalLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitDecimalLiteral(this);
else return visitor.visitChildren(this);
}
}
public static class BigIntLiteralContext extends NumberContext {
public TerminalNode BIGINT_LITERAL() { return getToken(IcebergSqlExtensionsParser.BIGINT_LITERAL, 0); }
public TerminalNode MINUS() { return getToken(IcebergSqlExtensionsParser.MINUS, 0); }
public BigIntLiteralContext(NumberContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterBigIntLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitBigIntLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitBigIntLiteral(this);
else return visitor.visitChildren(this);
}
}
public static class TinyIntLiteralContext extends NumberContext {
public TerminalNode TINYINT_LITERAL() { return getToken(IcebergSqlExtensionsParser.TINYINT_LITERAL, 0); }
public TerminalNode MINUS() { return getToken(IcebergSqlExtensionsParser.MINUS, 0); }
public TinyIntLiteralContext(NumberContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterTinyIntLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitTinyIntLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitTinyIntLiteral(this);
else return visitor.visitChildren(this);
}
}
public static class BigDecimalLiteralContext extends NumberContext {
public TerminalNode BIGDECIMAL_LITERAL() { return getToken(IcebergSqlExtensionsParser.BIGDECIMAL_LITERAL, 0); }
public TerminalNode MINUS() { return getToken(IcebergSqlExtensionsParser.MINUS, 0); }
public BigDecimalLiteralContext(NumberContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterBigDecimalLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitBigDecimalLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitBigDecimalLiteral(this);
else return visitor.visitChildren(this);
}
}
public static class ExponentLiteralContext extends NumberContext {
public TerminalNode EXPONENT_VALUE() { return getToken(IcebergSqlExtensionsParser.EXPONENT_VALUE, 0); }
public TerminalNode MINUS() { return getToken(IcebergSqlExtensionsParser.MINUS, 0); }
public ExponentLiteralContext(NumberContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterExponentLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitExponentLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitExponentLiteral(this);
else return visitor.visitChildren(this);
}
}
public static class DoubleLiteralContext extends NumberContext {
public TerminalNode DOUBLE_LITERAL() { return getToken(IcebergSqlExtensionsParser.DOUBLE_LITERAL, 0); }
public TerminalNode MINUS() { return getToken(IcebergSqlExtensionsParser.MINUS, 0); }
public DoubleLiteralContext(NumberContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterDoubleLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitDoubleLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitDoubleLiteral(this);
else return visitor.visitChildren(this);
}
}
public static class IntegerLiteralContext extends NumberContext {
public TerminalNode INTEGER_VALUE() { return getToken(IcebergSqlExtensionsParser.INTEGER_VALUE, 0); }
public TerminalNode MINUS() { return getToken(IcebergSqlExtensionsParser.MINUS, 0); }
public IntegerLiteralContext(NumberContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterIntegerLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitIntegerLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitIntegerLiteral(this);
else return visitor.visitChildren(this);
}
}
public static class FloatLiteralContext extends NumberContext {
public TerminalNode FLOAT_LITERAL() { return getToken(IcebergSqlExtensionsParser.FLOAT_LITERAL, 0); }
public TerminalNode MINUS() { return getToken(IcebergSqlExtensionsParser.MINUS, 0); }
public FloatLiteralContext(NumberContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterFloatLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitFloatLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitFloatLiteral(this);
else return visitor.visitChildren(this);
}
}
public static class SmallIntLiteralContext extends NumberContext {
public TerminalNode SMALLINT_LITERAL() { return getToken(IcebergSqlExtensionsParser.SMALLINT_LITERAL, 0); }
public TerminalNode MINUS() { return getToken(IcebergSqlExtensionsParser.MINUS, 0); }
public SmallIntLiteralContext(NumberContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterSmallIntLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitSmallIntLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitSmallIntLiteral(this);
else return visitor.visitChildren(this);
}
}
public final NumberContext number() throws RecognitionException {
NumberContext _localctx = new NumberContext(_ctx, getState());
enterRule(_localctx, 22, RULE_number);
int _la;
try {
setState(200);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) {
case 1:
_localctx = new ExponentLiteralContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(165);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(164);
match(MINUS);
}
}
setState(167);
match(EXPONENT_VALUE);
}
break;
case 2:
_localctx = new DecimalLiteralContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(169);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(168);
match(MINUS);
}
}
setState(171);
match(DECIMAL_VALUE);
}
break;
case 3:
_localctx = new IntegerLiteralContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(173);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(172);
match(MINUS);
}
}
setState(175);
match(INTEGER_VALUE);
}
break;
case 4:
_localctx = new BigIntLiteralContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(177);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(176);
match(MINUS);
}
}
setState(179);
match(BIGINT_LITERAL);
}
break;
case 5:
_localctx = new SmallIntLiteralContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(181);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(180);
match(MINUS);
}
}
setState(183);
match(SMALLINT_LITERAL);
}
break;
case 6:
_localctx = new TinyIntLiteralContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(185);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(184);
match(MINUS);
}
}
setState(187);
match(TINYINT_LITERAL);
}
break;
case 7:
_localctx = new DoubleLiteralContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(189);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(188);
match(MINUS);
}
}
setState(191);
match(DOUBLE_LITERAL);
}
break;
case 8:
_localctx = new FloatLiteralContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(193);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(192);
match(MINUS);
}
}
setState(195);
match(FLOAT_LITERAL);
}
break;
case 9:
_localctx = new BigDecimalLiteralContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(197);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MINUS) {
{
setState(196);
match(MINUS);
}
}
setState(199);
match(BIGDECIMAL_LITERAL);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MultipartIdentifierContext extends ParserRuleContext {
public IdentifierContext identifier;
public List parts = new ArrayList();
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public MultipartIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_multipartIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterMultipartIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitMultipartIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitMultipartIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final MultipartIdentifierContext multipartIdentifier() throws RecognitionException {
MultipartIdentifierContext _localctx = new MultipartIdentifierContext(_ctx, getState());
enterRule(_localctx, 24, RULE_multipartIdentifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(202);
((MultipartIdentifierContext)_localctx).identifier = identifier();
((MultipartIdentifierContext)_localctx).parts.add(((MultipartIdentifierContext)_localctx).identifier);
setState(207);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__4) {
{
{
setState(203);
match(T__4);
setState(204);
((MultipartIdentifierContext)_localctx).identifier = identifier();
((MultipartIdentifierContext)_localctx).parts.add(((MultipartIdentifierContext)_localctx).identifier);
}
}
setState(209);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class 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);
}
}
public static class QuotedIdentifierAlternativeContext extends IdentifierContext {
public QuotedIdentifierContext quotedIdentifier() {
return getRuleContext(QuotedIdentifierContext.class,0);
}
public QuotedIdentifierAlternativeContext(IdentifierContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterQuotedIdentifierAlternative(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitQuotedIdentifierAlternative(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitQuotedIdentifierAlternative(this);
else return visitor.visitChildren(this);
}
}
public static class UnquotedIdentifierContext extends IdentifierContext {
public TerminalNode IDENTIFIER() { return getToken(IcebergSqlExtensionsParser.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 IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterUnquotedIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitUnquotedIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitUnquotedIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final IdentifierContext identifier() throws RecognitionException {
IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
enterRule(_localctx, 26, RULE_identifier);
try {
setState(213);
_errHandler.sync(this);
switch (_input.LA(1)) {
case IDENTIFIER:
_localctx = new UnquotedIdentifierContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(210);
match(IDENTIFIER);
}
break;
case BACKQUOTED_IDENTIFIER:
_localctx = new QuotedIdentifierAlternativeContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(211);
quotedIdentifier();
}
break;
case ADD:
case ALTER:
case AS:
case ASC:
case BY:
case CALL:
case DESC:
case DROP:
case FIELD:
case FIRST:
case LAST:
case NULLS:
case ORDERED:
case PARTITION:
case TABLE:
case WRITE:
case TRUE:
case FALSE:
case MAP:
_localctx = new UnquotedIdentifierContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(212);
nonReserved();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QuotedIdentifierContext extends ParserRuleContext {
public TerminalNode BACKQUOTED_IDENTIFIER() { return getToken(IcebergSqlExtensionsParser.BACKQUOTED_IDENTIFIER, 0); }
public QuotedIdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_quotedIdentifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterQuotedIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitQuotedIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitQuotedIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final QuotedIdentifierContext quotedIdentifier() throws RecognitionException {
QuotedIdentifierContext _localctx = new QuotedIdentifierContext(_ctx, getState());
enterRule(_localctx, 28, RULE_quotedIdentifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(215);
match(BACKQUOTED_IDENTIFIER);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NonReservedContext extends ParserRuleContext {
public TerminalNode ADD() { return getToken(IcebergSqlExtensionsParser.ADD, 0); }
public TerminalNode ALTER() { return getToken(IcebergSqlExtensionsParser.ALTER, 0); }
public TerminalNode AS() { return getToken(IcebergSqlExtensionsParser.AS, 0); }
public TerminalNode ASC() { return getToken(IcebergSqlExtensionsParser.ASC, 0); }
public TerminalNode BY() { return getToken(IcebergSqlExtensionsParser.BY, 0); }
public TerminalNode CALL() { return getToken(IcebergSqlExtensionsParser.CALL, 0); }
public TerminalNode DESC() { return getToken(IcebergSqlExtensionsParser.DESC, 0); }
public TerminalNode DROP() { return getToken(IcebergSqlExtensionsParser.DROP, 0); }
public TerminalNode FIELD() { return getToken(IcebergSqlExtensionsParser.FIELD, 0); }
public TerminalNode FIRST() { return getToken(IcebergSqlExtensionsParser.FIRST, 0); }
public TerminalNode LAST() { return getToken(IcebergSqlExtensionsParser.LAST, 0); }
public TerminalNode NULLS() { return getToken(IcebergSqlExtensionsParser.NULLS, 0); }
public TerminalNode ORDERED() { return getToken(IcebergSqlExtensionsParser.ORDERED, 0); }
public TerminalNode PARTITION() { return getToken(IcebergSqlExtensionsParser.PARTITION, 0); }
public TerminalNode TABLE() { return getToken(IcebergSqlExtensionsParser.TABLE, 0); }
public TerminalNode WRITE() { return getToken(IcebergSqlExtensionsParser.WRITE, 0); }
public TerminalNode TRUE() { return getToken(IcebergSqlExtensionsParser.TRUE, 0); }
public TerminalNode FALSE() { return getToken(IcebergSqlExtensionsParser.FALSE, 0); }
public TerminalNode MAP() { return getToken(IcebergSqlExtensionsParser.MAP, 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 IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).enterNonReserved(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof IcebergSqlExtensionsListener ) ((IcebergSqlExtensionsListener)listener).exitNonReserved(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof IcebergSqlExtensionsVisitor ) return ((IcebergSqlExtensionsVisitor)visitor).visitNonReserved(this);
else return visitor.visitChildren(this);
}
}
public final NonReservedContext nonReserved() throws RecognitionException {
NonReservedContext _localctx = new NonReservedContext(_ctx, getState());
enterRule(_localctx, 30, RULE_nonReserved);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(217);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << ALTER) | (1L << AS) | (1L << ASC) | (1L << BY) | (1L << CALL) | (1L << DESC) | (1L << DROP) | (1L << FIELD) | (1L << FIRST) | (1L << LAST) | (1L << NULLS) | (1L << ORDERED) | (1L << PARTITION) | (1L << TABLE) | (1L << WRITE) | (1L << TRUE) | (1L << FALSE) | (1L << MAP))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static final String _serializedATN =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3,\u00de\4\2\t\2\4"+
"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\3\2\3\2\3"+
"\2\3\3\3\3\3\3\3\3\3\3\3\3\7\3,\n\3\f\3\16\3/\13\3\5\3\61\n\3\3\3\3\3"+
"\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\5\3>\n\3\3\3\3\3\3\3\3\3\3\3\3\3"+
"\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\5\3P\n\3\3\4\3\4\3\4\3\4\3\4"+
"\5\4W\n\4\3\5\3\5\3\5\7\5\\\n\5\f\5\16\5_\13\5\3\5\3\5\3\5\3\5\7\5e\n"+
"\5\f\5\16\5h\13\5\3\5\3\5\5\5l\n\5\3\6\3\6\5\6p\n\6\3\6\3\6\5\6t\n\6\3"+
"\7\3\7\3\7\3\7\3\7\3\7\7\7|\n\7\f\7\16\7\177\13\7\3\7\3\7\5\7\u0083\n"+
"\7\3\b\3\b\5\b\u0087\n\b\3\t\3\t\5\t\u008b\n\t\3\n\3\n\3\n\6\n\u0090\n"+
"\n\r\n\16\n\u0091\3\n\3\n\3\n\5\n\u0097\n\n\3\13\3\13\3\13\3\13\3\13\7"+
"\13\u009e\n\13\f\13\16\13\u00a1\13\13\3\13\3\13\3\f\3\f\3\r\5\r\u00a8"+
"\n\r\3\r\3\r\5\r\u00ac\n\r\3\r\3\r\5\r\u00b0\n\r\3\r\3\r\5\r\u00b4\n\r"+
"\3\r\3\r\5\r\u00b8\n\r\3\r\3\r\5\r\u00bc\n\r\3\r\3\r\5\r\u00c0\n\r\3\r"+
"\3\r\5\r\u00c4\n\r\3\r\3\r\5\r\u00c8\n\r\3\r\5\r\u00cb\n\r\3\16\3\16\3"+
"\16\7\16\u00d0\n\16\f\16\16\16\u00d3\13\16\3\17\3\17\3\17\5\17\u00d8\n"+
"\17\3\20\3\20\3\21\3\21\3\21\2\2\22\2\4\6\b\n\f\16\20\22\24\26\30\32\34"+
"\36 \2\6\4\2\13\13\16\16\3\2\21\22\3\2\30\31\3\2\b\32\2\u00f6\2\"\3\2"+
"\2\2\4O\3\2\2\2\6V\3\2\2\2\bk\3\2\2\2\nm\3\2\2\2\f\u0082\3\2\2\2\16\u0086"+
"\3\2\2\2\20\u008a\3\2\2\2\22\u0096\3\2\2\2\24\u0098\3\2\2\2\26\u00a4\3"+
"\2\2\2\30\u00ca\3\2\2\2\32\u00cc\3\2\2\2\34\u00d7\3\2\2\2\36\u00d9\3\2"+
"\2\2 \u00db\3\2\2\2\"#\5\4\3\2#$\7\2\2\3$\3\3\2\2\2%&\7\r\2\2&\'\5\32"+
"\16\2\'\60\7\3\2\2(-\5\6\4\2)*\7\4\2\2*,\5\6\4\2+)\3\2\2\2,/\3\2\2\2-"+
"+\3\2\2\2-.\3\2\2\2.\61\3\2\2\2/-\3\2\2\2\60(\3\2\2\2\60\61\3\2\2\2\61"+
"\62\3\2\2\2\62\63\7\5\2\2\63P\3\2\2\2\64\65\7\t\2\2\65\66\7\26\2\2\66"+
"\67\5\32\16\2\678\7\b\2\289\7\25\2\29:\7\20\2\2:=\5\f\7\2;<\7\n\2\2<>"+
"\5\34\17\2=;\3\2\2\2=>\3\2\2\2>P\3\2\2\2?@\7\t\2\2@A\7\26\2\2AB\5\32\16"+
"\2BC\7\17\2\2CD\7\25\2\2DE\7\20\2\2EF\5\f\7\2FP\3\2\2\2GH\7\t\2\2HI\7"+
"\26\2\2IJ\5\32\16\2JK\7\27\2\2KL\7\24\2\2LM\7\f\2\2MN\5\b\5\2NP\3\2\2"+
"\2O%\3\2\2\2O\64\3\2\2\2O?\3\2\2\2OG\3\2\2\2P\5\3\2\2\2QW\5\20\t\2RS\5"+
"\34\17\2ST\7\6\2\2TU\5\20\t\2UW\3\2\2\2VQ\3\2\2\2VR\3\2\2\2W\7\3\2\2\2"+
"X]\5\n\6\2YZ\7\4\2\2Z\\\5\n\6\2[Y\3\2\2\2\\_\3\2\2\2][\3\2\2\2]^\3\2\2"+
"\2^l\3\2\2\2_]\3\2\2\2`a\7\3\2\2af\5\n\6\2bc\7\4\2\2ce\5\n\6\2db\3\2\2"+
"\2eh\3\2\2\2fd\3\2\2\2fg\3\2\2\2gi\3\2\2\2hf\3\2\2\2ij\7\5\2\2jl\3\2\2"+
"\2kX\3\2\2\2k`\3\2\2\2l\t\3\2\2\2mo\5\f\7\2np\t\2\2\2on\3\2\2\2op\3\2"+
"\2\2ps\3\2\2\2qr\7\23\2\2rt\t\3\2\2sq\3\2\2\2st\3\2\2\2t\13\3\2\2\2u\u0083"+
"\5\32\16\2vw\5\34\17\2wx\7\3\2\2x}\5\16\b\2yz\7\4\2\2z|\5\16\b\2{y\3\2"+
"\2\2|\177\3\2\2\2}{\3\2\2\2}~\3\2\2\2~\u0080\3\2\2\2\177}\3\2\2\2\u0080"+
"\u0081\7\5\2\2\u0081\u0083\3\2\2\2\u0082u\3\2\2\2\u0082v\3\2\2\2\u0083"+
"\r\3\2\2\2\u0084\u0087\5\32\16\2\u0085\u0087\5\22\n\2\u0086\u0084\3\2"+
"\2\2\u0086\u0085\3\2\2\2\u0087\17\3\2\2\2\u0088\u008b\5\22\n\2\u0089\u008b"+
"\5\24\13\2\u008a\u0088\3\2\2\2\u008a\u0089\3\2\2\2\u008b\21\3\2\2\2\u008c"+
"\u0097\5\30\r\2\u008d\u0097\5\26\f\2\u008e\u0090\7\35\2\2\u008f\u008e"+
"\3\2\2\2\u0090\u0091\3\2\2\2\u0091\u008f\3\2\2\2\u0091\u0092\3\2\2\2\u0092"+
"\u0097\3\2\2\2\u0093\u0094\5\34\17\2\u0094\u0095\7\35\2\2\u0095\u0097"+
"\3\2\2\2\u0096\u008c\3\2\2\2\u0096\u008d\3\2\2\2\u0096\u008f\3\2\2\2\u0096"+
"\u0093\3\2\2\2\u0097\23\3\2\2\2\u0098\u0099\7\32\2\2\u0099\u009a\7\3\2"+
"\2\u009a\u009f\5\22\n\2\u009b\u009c\7\4\2\2\u009c\u009e\5\22\n\2\u009d"+
"\u009b\3\2\2\2\u009e\u00a1\3\2\2\2\u009f\u009d\3\2\2\2\u009f\u00a0\3\2"+
"\2\2\u00a0\u00a2\3\2\2\2\u00a1\u009f\3\2\2\2\u00a2\u00a3\7\5\2\2\u00a3"+
"\25\3\2\2\2\u00a4\u00a5\t\4\2\2\u00a5\27\3\2\2\2\u00a6\u00a8\7\34\2\2"+
"\u00a7\u00a6\3\2\2\2\u00a7\u00a8\3\2\2\2\u00a8\u00a9\3\2\2\2\u00a9\u00cb"+
"\7\"\2\2\u00aa\u00ac\7\34\2\2\u00ab\u00aa\3\2\2\2\u00ab\u00ac\3\2\2\2"+
"\u00ac\u00ad\3\2\2\2\u00ad\u00cb\7#\2\2\u00ae\u00b0\7\34\2\2\u00af\u00ae"+
"\3\2\2\2\u00af\u00b0\3\2\2\2\u00b0\u00b1\3\2\2\2\u00b1\u00cb\7!\2\2\u00b2"+
"\u00b4\7\34\2\2\u00b3\u00b2\3\2\2\2\u00b3\u00b4\3\2\2\2\u00b4\u00b5\3"+
"\2\2\2\u00b5\u00cb\7\36\2\2\u00b6\u00b8\7\34\2\2\u00b7\u00b6\3\2\2\2\u00b7"+
"\u00b8\3\2\2\2\u00b8\u00b9\3\2\2\2\u00b9\u00cb\7\37\2\2\u00ba\u00bc\7"+
"\34\2\2\u00bb\u00ba\3\2\2\2\u00bb\u00bc\3\2\2\2\u00bc\u00bd\3\2\2\2\u00bd"+
"\u00cb\7 \2\2\u00be\u00c0\7\34\2\2\u00bf\u00be\3\2\2\2\u00bf\u00c0\3\2"+
"\2\2\u00c0\u00c1\3\2\2\2\u00c1\u00cb\7%\2\2\u00c2\u00c4\7\34\2\2\u00c3"+
"\u00c2\3\2\2\2\u00c3\u00c4\3\2\2\2\u00c4\u00c5\3\2\2\2\u00c5\u00cb\7$"+
"\2\2\u00c6\u00c8\7\34\2\2\u00c7\u00c6\3\2\2\2\u00c7\u00c8\3\2\2\2\u00c8"+
"\u00c9\3\2\2\2\u00c9\u00cb\7&\2\2\u00ca\u00a7\3\2\2\2\u00ca\u00ab\3\2"+
"\2\2\u00ca\u00af\3\2\2\2\u00ca\u00b3\3\2\2\2\u00ca\u00b7\3\2\2\2\u00ca"+
"\u00bb\3\2\2\2\u00ca\u00bf\3\2\2\2\u00ca\u00c3\3\2\2\2\u00ca\u00c7\3\2"+
"\2\2\u00cb\31\3\2\2\2\u00cc\u00d1\5\34\17\2\u00cd\u00ce\7\7\2\2\u00ce"+
"\u00d0\5\34\17\2\u00cf\u00cd\3\2\2\2\u00d0\u00d3\3\2\2\2\u00d1\u00cf\3"+
"\2\2\2\u00d1\u00d2\3\2\2\2\u00d2\33\3\2\2\2\u00d3\u00d1\3\2\2\2\u00d4"+
"\u00d8\7\'\2\2\u00d5\u00d8\5\36\20\2\u00d6\u00d8\5 \21\2\u00d7\u00d4\3"+
"\2\2\2\u00d7\u00d5\3\2\2\2\u00d7\u00d6\3\2\2\2\u00d8\35\3\2\2\2\u00d9"+
"\u00da\7(\2\2\u00da\37\3\2\2\2\u00db\u00dc\t\5\2\2\u00dc!\3\2\2\2\37-"+
"\60=OV]fkos}\u0082\u0086\u008a\u0091\u0096\u009f\u00a7\u00ab\u00af\u00b3"+
"\u00b7\u00bb\u00bf\u00c3\u00c7\u00ca\u00d1\u00d7";
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);
}
}
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy