Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.finos.legend.engine.language.pure.grammar.from.antlr4.connection.SnowflakeParserGrammar Maven / Gradle / Ivy
// Generated from org/finos/legend/engine/language/pure/grammar/from/antlr4/connection/SnowflakeParserGrammar.g4 by ANTLR 4.8
package org.finos.legend.engine.language.pure.grammar.from.antlr4.connection;
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 SnowflakeParserGrammar extends Parser {
static { RuntimeMetaData.checkVersion("4.8", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
NAME=1, SNOWFLAKE=2, ACCOUNT=3, WAREHOUSE=4, REGION=5, CLOUDTYPE=6, QUOTED_IDENTIFIERS_IGNORE_CASE=7,
PROXYHOST=8, PROXYPORT=9, NONPROXYHOSTS=10, TEMPTABLEDB=11, TEMPTABLESCHEMA=12,
ACCOUNTTYPE=13, ORGANIZATION=14, ROLE=15, ENABLE_QUERY_TAGS=16, SNOWFLAKE_PUBLIC_AUTH=17,
SNOWFLAKE_AUTH_KEY_VAULT_REFERENCE=18, SNOWFLAKE_AUTH_PASSPHRASE_VAULT_REFERENCE=19,
SNOWFLAKE_AUTH_PUBLIC_USERNAME=20, WHITESPACE=21, COMMENT=22, LINE_COMMENT=23,
ISLAND_OPEN=24, STRING=25, BOOLEAN=26, TRUE=27, FALSE=28, INTEGER=29,
FLOAT=30, DECIMAL=31, DATE=32, STRICTTIME=33, LATEST_DATE=34, FILE_NAME=35,
FILE_NAME_END=36, PATH_SEPARATOR=37, AND=38, OR=39, NOT=40, COMMA=41,
EQUAL=42, TEST_EQUAL=43, TEST_NOT_EQUAL=44, PERCENT=45, ARROW=46, BRACE_OPEN=47,
BRACE_CLOSE=48, BRACKET_OPEN=49, BRACKET_CLOSE=50, PAREN_OPEN=51, PAREN_CLOSE=52,
COLON=53, DOT=54, DOLLAR=55, DOT_DOT=56, SEMI_COLON=57, NEW_SYMBOL=58,
PIPE=59, TILDE=60, AT=61, PLUS=62, STAR=63, MINUS=64, DIVIDE=65, LESS_THAN=66,
LESS_OR_EQUAL=67, GREATER_THAN=68, GREATER_OR_EQUAL=69, VALID_STRING=70,
INVALID=71, ISLAND_START=72, ISLAND_END=73, ISLAND_HASH=74, ISLAND_BRACE_OPEN=75,
ISLAND_BRACE_CLOSE=76, ISLAND_CONTENT=77;
public static final int
RULE_identifier = 0, RULE_snowflakeDatasourceSpecification = 1, RULE_dbName = 2,
RULE_dbWarehouse = 3, RULE_dbAccount = 4, RULE_dbProxyHost = 5, RULE_dbProxyPort = 6,
RULE_dbNonProxyHosts = 7, RULE_dbTempTableDb = 8, RULE_dbTempTableSchema = 9,
RULE_dbAccountType = 10, RULE_dbOrganization = 11, RULE_snowflakeRegion = 12,
RULE_cloudType = 13, RULE_snowflakeQuotedIdentifiersIgnoreCase = 14, RULE_dbRole = 15,
RULE_enableQueryTags = 16, RULE_snowflakePublicAuth = 17, RULE_snowflakePublicAuthKeyVaultRef = 18,
RULE_snowflakePublicAuthPassPhraseVaultRef = 19, RULE_snowflakePublicAuthUserName = 20,
RULE_qualifiedName = 21, RULE_packagePath = 22, RULE_word = 23, RULE_islandDefinition = 24,
RULE_islandContent = 25;
private static String[] makeRuleNames() {
return new String[] {
"identifier", "snowflakeDatasourceSpecification", "dbName", "dbWarehouse",
"dbAccount", "dbProxyHost", "dbProxyPort", "dbNonProxyHosts", "dbTempTableDb",
"dbTempTableSchema", "dbAccountType", "dbOrganization", "snowflakeRegion",
"cloudType", "snowflakeQuotedIdentifiersIgnoreCase", "dbRole", "enableQueryTags",
"snowflakePublicAuth", "snowflakePublicAuthKeyVaultRef", "snowflakePublicAuthPassPhraseVaultRef",
"snowflakePublicAuthUserName", "qualifiedName", "packagePath", "word",
"islandDefinition", "islandContent"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, "'name'", "'Snowflake'", "'account'", "'warehouse'", "'region'",
"'cloudType'", "'quotedIdentifiersIgnoreCase'", "'proxyHost'", "'proxyPort'",
"'nonProxyHosts'", "'tempTableDb'", "'tempTableSchema'", "'accountType'",
"'organization'", "'role'", "'enableQueryTags'", "'SnowflakePublic'",
"'privateKeyVaultReference'", "'passPhraseVaultReference'", "'publicUserName'",
null, null, null, null, null, null, null, null, null, null, null, null,
null, "'%latest'", null, null, null, "'&&'", "'||'", "'!'", "','", "'='",
"'=='", "'!='", "'%'", "'->'", null, null, "'['", "']'", "'('", "')'",
"':'", "'.'", "'$'", "'..'", "';'", "'^'", "'|'", "'~'", "'@'", "'+'",
"'*'", "'-'", "'/'", "'<'", "'<='", "'>'", "'>='", null, null, "'#{'",
"'}#'", "'#'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, "NAME", "SNOWFLAKE", "ACCOUNT", "WAREHOUSE", "REGION", "CLOUDTYPE",
"QUOTED_IDENTIFIERS_IGNORE_CASE", "PROXYHOST", "PROXYPORT", "NONPROXYHOSTS",
"TEMPTABLEDB", "TEMPTABLESCHEMA", "ACCOUNTTYPE", "ORGANIZATION", "ROLE",
"ENABLE_QUERY_TAGS", "SNOWFLAKE_PUBLIC_AUTH", "SNOWFLAKE_AUTH_KEY_VAULT_REFERENCE",
"SNOWFLAKE_AUTH_PASSPHRASE_VAULT_REFERENCE", "SNOWFLAKE_AUTH_PUBLIC_USERNAME",
"WHITESPACE", "COMMENT", "LINE_COMMENT", "ISLAND_OPEN", "STRING", "BOOLEAN",
"TRUE", "FALSE", "INTEGER", "FLOAT", "DECIMAL", "DATE", "STRICTTIME",
"LATEST_DATE", "FILE_NAME", "FILE_NAME_END", "PATH_SEPARATOR", "AND",
"OR", "NOT", "COMMA", "EQUAL", "TEST_EQUAL", "TEST_NOT_EQUAL", "PERCENT",
"ARROW", "BRACE_OPEN", "BRACE_CLOSE", "BRACKET_OPEN", "BRACKET_CLOSE",
"PAREN_OPEN", "PAREN_CLOSE", "COLON", "DOT", "DOLLAR", "DOT_DOT", "SEMI_COLON",
"NEW_SYMBOL", "PIPE", "TILDE", "AT", "PLUS", "STAR", "MINUS", "DIVIDE",
"LESS_THAN", "LESS_OR_EQUAL", "GREATER_THAN", "GREATER_OR_EQUAL", "VALID_STRING",
"INVALID", "ISLAND_START", "ISLAND_END", "ISLAND_HASH", "ISLAND_BRACE_OPEN",
"ISLAND_BRACE_CLOSE", "ISLAND_CONTENT"
};
}
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 "SnowflakeParserGrammar.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public SnowflakeParserGrammar(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class IdentifierContext extends ParserRuleContext {
public TerminalNode VALID_STRING() { return getToken(SnowflakeParserGrammar.VALID_STRING, 0); }
public IdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).enterIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).exitIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnowflakeParserGrammarVisitor ) return ((SnowflakeParserGrammarVisitor)visitor).visitIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final IdentifierContext identifier() throws RecognitionException {
IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
enterRule(_localctx, 0, RULE_identifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(52);
match(VALID_STRING);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SnowflakeDatasourceSpecificationContext extends ParserRuleContext {
public TerminalNode SNOWFLAKE() { return getToken(SnowflakeParserGrammar.SNOWFLAKE, 0); }
public TerminalNode BRACE_OPEN() { return getToken(SnowflakeParserGrammar.BRACE_OPEN, 0); }
public TerminalNode BRACE_CLOSE() { return getToken(SnowflakeParserGrammar.BRACE_CLOSE, 0); }
public List dbName() {
return getRuleContexts(DbNameContext.class);
}
public DbNameContext dbName(int i) {
return getRuleContext(DbNameContext.class,i);
}
public List dbAccount() {
return getRuleContexts(DbAccountContext.class);
}
public DbAccountContext dbAccount(int i) {
return getRuleContext(DbAccountContext.class,i);
}
public List dbWarehouse() {
return getRuleContexts(DbWarehouseContext.class);
}
public DbWarehouseContext dbWarehouse(int i) {
return getRuleContext(DbWarehouseContext.class,i);
}
public List snowflakeRegion() {
return getRuleContexts(SnowflakeRegionContext.class);
}
public SnowflakeRegionContext snowflakeRegion(int i) {
return getRuleContext(SnowflakeRegionContext.class,i);
}
public List cloudType() {
return getRuleContexts(CloudTypeContext.class);
}
public CloudTypeContext cloudType(int i) {
return getRuleContext(CloudTypeContext.class,i);
}
public List snowflakeQuotedIdentifiersIgnoreCase() {
return getRuleContexts(SnowflakeQuotedIdentifiersIgnoreCaseContext.class);
}
public SnowflakeQuotedIdentifiersIgnoreCaseContext snowflakeQuotedIdentifiersIgnoreCase(int i) {
return getRuleContext(SnowflakeQuotedIdentifiersIgnoreCaseContext.class,i);
}
public List dbProxyHost() {
return getRuleContexts(DbProxyHostContext.class);
}
public DbProxyHostContext dbProxyHost(int i) {
return getRuleContext(DbProxyHostContext.class,i);
}
public List dbProxyPort() {
return getRuleContexts(DbProxyPortContext.class);
}
public DbProxyPortContext dbProxyPort(int i) {
return getRuleContext(DbProxyPortContext.class,i);
}
public List dbNonProxyHosts() {
return getRuleContexts(DbNonProxyHostsContext.class);
}
public DbNonProxyHostsContext dbNonProxyHosts(int i) {
return getRuleContext(DbNonProxyHostsContext.class,i);
}
public List dbTempTableDb() {
return getRuleContexts(DbTempTableDbContext.class);
}
public DbTempTableDbContext dbTempTableDb(int i) {
return getRuleContext(DbTempTableDbContext.class,i);
}
public List dbTempTableSchema() {
return getRuleContexts(DbTempTableSchemaContext.class);
}
public DbTempTableSchemaContext dbTempTableSchema(int i) {
return getRuleContext(DbTempTableSchemaContext.class,i);
}
public List dbAccountType() {
return getRuleContexts(DbAccountTypeContext.class);
}
public DbAccountTypeContext dbAccountType(int i) {
return getRuleContext(DbAccountTypeContext.class,i);
}
public List dbOrganization() {
return getRuleContexts(DbOrganizationContext.class);
}
public DbOrganizationContext dbOrganization(int i) {
return getRuleContext(DbOrganizationContext.class,i);
}
public List dbRole() {
return getRuleContexts(DbRoleContext.class);
}
public DbRoleContext dbRole(int i) {
return getRuleContext(DbRoleContext.class,i);
}
public List enableQueryTags() {
return getRuleContexts(EnableQueryTagsContext.class);
}
public EnableQueryTagsContext enableQueryTags(int i) {
return getRuleContext(EnableQueryTagsContext.class,i);
}
public SnowflakeDatasourceSpecificationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_snowflakeDatasourceSpecification; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).enterSnowflakeDatasourceSpecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).exitSnowflakeDatasourceSpecification(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnowflakeParserGrammarVisitor ) return ((SnowflakeParserGrammarVisitor)visitor).visitSnowflakeDatasourceSpecification(this);
else return visitor.visitChildren(this);
}
}
public final SnowflakeDatasourceSpecificationContext snowflakeDatasourceSpecification() throws RecognitionException {
SnowflakeDatasourceSpecificationContext _localctx = new SnowflakeDatasourceSpecificationContext(_ctx, getState());
enterRule(_localctx, 2, RULE_snowflakeDatasourceSpecification);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(54);
match(SNOWFLAKE);
setState(55);
match(BRACE_OPEN);
setState(73);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NAME) | (1L << ACCOUNT) | (1L << WAREHOUSE) | (1L << REGION) | (1L << CLOUDTYPE) | (1L << QUOTED_IDENTIFIERS_IGNORE_CASE) | (1L << PROXYHOST) | (1L << PROXYPORT) | (1L << NONPROXYHOSTS) | (1L << TEMPTABLEDB) | (1L << TEMPTABLESCHEMA) | (1L << ACCOUNTTYPE) | (1L << ORGANIZATION) | (1L << ROLE) | (1L << ENABLE_QUERY_TAGS))) != 0)) {
{
setState(71);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NAME:
{
setState(56);
dbName();
}
break;
case ACCOUNT:
{
setState(57);
dbAccount();
}
break;
case WAREHOUSE:
{
setState(58);
dbWarehouse();
}
break;
case REGION:
{
setState(59);
snowflakeRegion();
}
break;
case CLOUDTYPE:
{
setState(60);
cloudType();
}
break;
case QUOTED_IDENTIFIERS_IGNORE_CASE:
{
setState(61);
snowflakeQuotedIdentifiersIgnoreCase();
}
break;
case PROXYHOST:
{
setState(62);
dbProxyHost();
}
break;
case PROXYPORT:
{
setState(63);
dbProxyPort();
}
break;
case NONPROXYHOSTS:
{
setState(64);
dbNonProxyHosts();
}
break;
case TEMPTABLEDB:
{
setState(65);
dbTempTableDb();
}
break;
case TEMPTABLESCHEMA:
{
setState(66);
dbTempTableSchema();
}
break;
case ACCOUNTTYPE:
{
setState(67);
dbAccountType();
}
break;
case ORGANIZATION:
{
setState(68);
dbOrganization();
}
break;
case ROLE:
{
setState(69);
dbRole();
}
break;
case ENABLE_QUERY_TAGS:
{
setState(70);
enableQueryTags();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(75);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(76);
match(BRACE_CLOSE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DbNameContext extends ParserRuleContext {
public TerminalNode NAME() { return getToken(SnowflakeParserGrammar.NAME, 0); }
public TerminalNode COLON() { return getToken(SnowflakeParserGrammar.COLON, 0); }
public TerminalNode STRING() { return getToken(SnowflakeParserGrammar.STRING, 0); }
public TerminalNode SEMI_COLON() { return getToken(SnowflakeParserGrammar.SEMI_COLON, 0); }
public DbNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dbName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).enterDbName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).exitDbName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnowflakeParserGrammarVisitor ) return ((SnowflakeParserGrammarVisitor)visitor).visitDbName(this);
else return visitor.visitChildren(this);
}
}
public final DbNameContext dbName() throws RecognitionException {
DbNameContext _localctx = new DbNameContext(_ctx, getState());
enterRule(_localctx, 4, RULE_dbName);
try {
enterOuterAlt(_localctx, 1);
{
setState(78);
match(NAME);
setState(79);
match(COLON);
setState(80);
match(STRING);
setState(81);
match(SEMI_COLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DbWarehouseContext extends ParserRuleContext {
public TerminalNode WAREHOUSE() { return getToken(SnowflakeParserGrammar.WAREHOUSE, 0); }
public TerminalNode COLON() { return getToken(SnowflakeParserGrammar.COLON, 0); }
public TerminalNode STRING() { return getToken(SnowflakeParserGrammar.STRING, 0); }
public TerminalNode SEMI_COLON() { return getToken(SnowflakeParserGrammar.SEMI_COLON, 0); }
public DbWarehouseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dbWarehouse; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).enterDbWarehouse(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).exitDbWarehouse(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnowflakeParserGrammarVisitor ) return ((SnowflakeParserGrammarVisitor)visitor).visitDbWarehouse(this);
else return visitor.visitChildren(this);
}
}
public final DbWarehouseContext dbWarehouse() throws RecognitionException {
DbWarehouseContext _localctx = new DbWarehouseContext(_ctx, getState());
enterRule(_localctx, 6, RULE_dbWarehouse);
try {
enterOuterAlt(_localctx, 1);
{
setState(83);
match(WAREHOUSE);
setState(84);
match(COLON);
setState(85);
match(STRING);
setState(86);
match(SEMI_COLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DbAccountContext extends ParserRuleContext {
public TerminalNode ACCOUNT() { return getToken(SnowflakeParserGrammar.ACCOUNT, 0); }
public TerminalNode COLON() { return getToken(SnowflakeParserGrammar.COLON, 0); }
public TerminalNode STRING() { return getToken(SnowflakeParserGrammar.STRING, 0); }
public TerminalNode SEMI_COLON() { return getToken(SnowflakeParserGrammar.SEMI_COLON, 0); }
public DbAccountContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dbAccount; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).enterDbAccount(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).exitDbAccount(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnowflakeParserGrammarVisitor ) return ((SnowflakeParserGrammarVisitor)visitor).visitDbAccount(this);
else return visitor.visitChildren(this);
}
}
public final DbAccountContext dbAccount() throws RecognitionException {
DbAccountContext _localctx = new DbAccountContext(_ctx, getState());
enterRule(_localctx, 8, RULE_dbAccount);
try {
enterOuterAlt(_localctx, 1);
{
setState(88);
match(ACCOUNT);
setState(89);
match(COLON);
setState(90);
match(STRING);
setState(91);
match(SEMI_COLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DbProxyHostContext extends ParserRuleContext {
public TerminalNode PROXYHOST() { return getToken(SnowflakeParserGrammar.PROXYHOST, 0); }
public TerminalNode COLON() { return getToken(SnowflakeParserGrammar.COLON, 0); }
public TerminalNode STRING() { return getToken(SnowflakeParserGrammar.STRING, 0); }
public TerminalNode SEMI_COLON() { return getToken(SnowflakeParserGrammar.SEMI_COLON, 0); }
public DbProxyHostContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dbProxyHost; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).enterDbProxyHost(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).exitDbProxyHost(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnowflakeParserGrammarVisitor ) return ((SnowflakeParserGrammarVisitor)visitor).visitDbProxyHost(this);
else return visitor.visitChildren(this);
}
}
public final DbProxyHostContext dbProxyHost() throws RecognitionException {
DbProxyHostContext _localctx = new DbProxyHostContext(_ctx, getState());
enterRule(_localctx, 10, RULE_dbProxyHost);
try {
enterOuterAlt(_localctx, 1);
{
setState(93);
match(PROXYHOST);
setState(94);
match(COLON);
setState(95);
match(STRING);
setState(96);
match(SEMI_COLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DbProxyPortContext extends ParserRuleContext {
public TerminalNode PROXYPORT() { return getToken(SnowflakeParserGrammar.PROXYPORT, 0); }
public TerminalNode COLON() { return getToken(SnowflakeParserGrammar.COLON, 0); }
public TerminalNode STRING() { return getToken(SnowflakeParserGrammar.STRING, 0); }
public TerminalNode SEMI_COLON() { return getToken(SnowflakeParserGrammar.SEMI_COLON, 0); }
public DbProxyPortContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dbProxyPort; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).enterDbProxyPort(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).exitDbProxyPort(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnowflakeParserGrammarVisitor ) return ((SnowflakeParserGrammarVisitor)visitor).visitDbProxyPort(this);
else return visitor.visitChildren(this);
}
}
public final DbProxyPortContext dbProxyPort() throws RecognitionException {
DbProxyPortContext _localctx = new DbProxyPortContext(_ctx, getState());
enterRule(_localctx, 12, RULE_dbProxyPort);
try {
enterOuterAlt(_localctx, 1);
{
setState(98);
match(PROXYPORT);
setState(99);
match(COLON);
setState(100);
match(STRING);
setState(101);
match(SEMI_COLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DbNonProxyHostsContext extends ParserRuleContext {
public TerminalNode NONPROXYHOSTS() { return getToken(SnowflakeParserGrammar.NONPROXYHOSTS, 0); }
public TerminalNode COLON() { return getToken(SnowflakeParserGrammar.COLON, 0); }
public TerminalNode STRING() { return getToken(SnowflakeParserGrammar.STRING, 0); }
public TerminalNode SEMI_COLON() { return getToken(SnowflakeParserGrammar.SEMI_COLON, 0); }
public DbNonProxyHostsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dbNonProxyHosts; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).enterDbNonProxyHosts(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).exitDbNonProxyHosts(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnowflakeParserGrammarVisitor ) return ((SnowflakeParserGrammarVisitor)visitor).visitDbNonProxyHosts(this);
else return visitor.visitChildren(this);
}
}
public final DbNonProxyHostsContext dbNonProxyHosts() throws RecognitionException {
DbNonProxyHostsContext _localctx = new DbNonProxyHostsContext(_ctx, getState());
enterRule(_localctx, 14, RULE_dbNonProxyHosts);
try {
enterOuterAlt(_localctx, 1);
{
setState(103);
match(NONPROXYHOSTS);
setState(104);
match(COLON);
setState(105);
match(STRING);
setState(106);
match(SEMI_COLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DbTempTableDbContext extends ParserRuleContext {
public TerminalNode TEMPTABLEDB() { return getToken(SnowflakeParserGrammar.TEMPTABLEDB, 0); }
public TerminalNode COLON() { return getToken(SnowflakeParserGrammar.COLON, 0); }
public TerminalNode STRING() { return getToken(SnowflakeParserGrammar.STRING, 0); }
public TerminalNode SEMI_COLON() { return getToken(SnowflakeParserGrammar.SEMI_COLON, 0); }
public DbTempTableDbContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dbTempTableDb; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).enterDbTempTableDb(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).exitDbTempTableDb(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnowflakeParserGrammarVisitor ) return ((SnowflakeParserGrammarVisitor)visitor).visitDbTempTableDb(this);
else return visitor.visitChildren(this);
}
}
public final DbTempTableDbContext dbTempTableDb() throws RecognitionException {
DbTempTableDbContext _localctx = new DbTempTableDbContext(_ctx, getState());
enterRule(_localctx, 16, RULE_dbTempTableDb);
try {
enterOuterAlt(_localctx, 1);
{
setState(108);
match(TEMPTABLEDB);
setState(109);
match(COLON);
setState(110);
match(STRING);
setState(111);
match(SEMI_COLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DbTempTableSchemaContext extends ParserRuleContext {
public TerminalNode TEMPTABLESCHEMA() { return getToken(SnowflakeParserGrammar.TEMPTABLESCHEMA, 0); }
public TerminalNode COLON() { return getToken(SnowflakeParserGrammar.COLON, 0); }
public TerminalNode STRING() { return getToken(SnowflakeParserGrammar.STRING, 0); }
public TerminalNode SEMI_COLON() { return getToken(SnowflakeParserGrammar.SEMI_COLON, 0); }
public DbTempTableSchemaContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dbTempTableSchema; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).enterDbTempTableSchema(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).exitDbTempTableSchema(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnowflakeParserGrammarVisitor ) return ((SnowflakeParserGrammarVisitor)visitor).visitDbTempTableSchema(this);
else return visitor.visitChildren(this);
}
}
public final DbTempTableSchemaContext dbTempTableSchema() throws RecognitionException {
DbTempTableSchemaContext _localctx = new DbTempTableSchemaContext(_ctx, getState());
enterRule(_localctx, 18, RULE_dbTempTableSchema);
try {
enterOuterAlt(_localctx, 1);
{
setState(113);
match(TEMPTABLESCHEMA);
setState(114);
match(COLON);
setState(115);
match(STRING);
setState(116);
match(SEMI_COLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DbAccountTypeContext extends ParserRuleContext {
public TerminalNode ACCOUNTTYPE() { return getToken(SnowflakeParserGrammar.ACCOUNTTYPE, 0); }
public TerminalNode COLON() { return getToken(SnowflakeParserGrammar.COLON, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode SEMI_COLON() { return getToken(SnowflakeParserGrammar.SEMI_COLON, 0); }
public DbAccountTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dbAccountType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).enterDbAccountType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).exitDbAccountType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnowflakeParserGrammarVisitor ) return ((SnowflakeParserGrammarVisitor)visitor).visitDbAccountType(this);
else return visitor.visitChildren(this);
}
}
public final DbAccountTypeContext dbAccountType() throws RecognitionException {
DbAccountTypeContext _localctx = new DbAccountTypeContext(_ctx, getState());
enterRule(_localctx, 20, RULE_dbAccountType);
try {
enterOuterAlt(_localctx, 1);
{
setState(118);
match(ACCOUNTTYPE);
setState(119);
match(COLON);
setState(120);
identifier();
setState(121);
match(SEMI_COLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DbOrganizationContext extends ParserRuleContext {
public TerminalNode ORGANIZATION() { return getToken(SnowflakeParserGrammar.ORGANIZATION, 0); }
public TerminalNode COLON() { return getToken(SnowflakeParserGrammar.COLON, 0); }
public TerminalNode STRING() { return getToken(SnowflakeParserGrammar.STRING, 0); }
public TerminalNode SEMI_COLON() { return getToken(SnowflakeParserGrammar.SEMI_COLON, 0); }
public DbOrganizationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dbOrganization; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).enterDbOrganization(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).exitDbOrganization(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnowflakeParserGrammarVisitor ) return ((SnowflakeParserGrammarVisitor)visitor).visitDbOrganization(this);
else return visitor.visitChildren(this);
}
}
public final DbOrganizationContext dbOrganization() throws RecognitionException {
DbOrganizationContext _localctx = new DbOrganizationContext(_ctx, getState());
enterRule(_localctx, 22, RULE_dbOrganization);
try {
enterOuterAlt(_localctx, 1);
{
setState(123);
match(ORGANIZATION);
setState(124);
match(COLON);
setState(125);
match(STRING);
setState(126);
match(SEMI_COLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SnowflakeRegionContext extends ParserRuleContext {
public TerminalNode REGION() { return getToken(SnowflakeParserGrammar.REGION, 0); }
public TerminalNode COLON() { return getToken(SnowflakeParserGrammar.COLON, 0); }
public TerminalNode STRING() { return getToken(SnowflakeParserGrammar.STRING, 0); }
public TerminalNode SEMI_COLON() { return getToken(SnowflakeParserGrammar.SEMI_COLON, 0); }
public SnowflakeRegionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_snowflakeRegion; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).enterSnowflakeRegion(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).exitSnowflakeRegion(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnowflakeParserGrammarVisitor ) return ((SnowflakeParserGrammarVisitor)visitor).visitSnowflakeRegion(this);
else return visitor.visitChildren(this);
}
}
public final SnowflakeRegionContext snowflakeRegion() throws RecognitionException {
SnowflakeRegionContext _localctx = new SnowflakeRegionContext(_ctx, getState());
enterRule(_localctx, 24, RULE_snowflakeRegion);
try {
enterOuterAlt(_localctx, 1);
{
setState(128);
match(REGION);
setState(129);
match(COLON);
setState(130);
match(STRING);
setState(131);
match(SEMI_COLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CloudTypeContext extends ParserRuleContext {
public TerminalNode CLOUDTYPE() { return getToken(SnowflakeParserGrammar.CLOUDTYPE, 0); }
public TerminalNode COLON() { return getToken(SnowflakeParserGrammar.COLON, 0); }
public TerminalNode STRING() { return getToken(SnowflakeParserGrammar.STRING, 0); }
public TerminalNode SEMI_COLON() { return getToken(SnowflakeParserGrammar.SEMI_COLON, 0); }
public CloudTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_cloudType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).enterCloudType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).exitCloudType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnowflakeParserGrammarVisitor ) return ((SnowflakeParserGrammarVisitor)visitor).visitCloudType(this);
else return visitor.visitChildren(this);
}
}
public final CloudTypeContext cloudType() throws RecognitionException {
CloudTypeContext _localctx = new CloudTypeContext(_ctx, getState());
enterRule(_localctx, 26, RULE_cloudType);
try {
enterOuterAlt(_localctx, 1);
{
setState(133);
match(CLOUDTYPE);
setState(134);
match(COLON);
setState(135);
match(STRING);
setState(136);
match(SEMI_COLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SnowflakeQuotedIdentifiersIgnoreCaseContext extends ParserRuleContext {
public TerminalNode QUOTED_IDENTIFIERS_IGNORE_CASE() { return getToken(SnowflakeParserGrammar.QUOTED_IDENTIFIERS_IGNORE_CASE, 0); }
public TerminalNode COLON() { return getToken(SnowflakeParserGrammar.COLON, 0); }
public TerminalNode BOOLEAN() { return getToken(SnowflakeParserGrammar.BOOLEAN, 0); }
public TerminalNode SEMI_COLON() { return getToken(SnowflakeParserGrammar.SEMI_COLON, 0); }
public SnowflakeQuotedIdentifiersIgnoreCaseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_snowflakeQuotedIdentifiersIgnoreCase; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).enterSnowflakeQuotedIdentifiersIgnoreCase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).exitSnowflakeQuotedIdentifiersIgnoreCase(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnowflakeParserGrammarVisitor ) return ((SnowflakeParserGrammarVisitor)visitor).visitSnowflakeQuotedIdentifiersIgnoreCase(this);
else return visitor.visitChildren(this);
}
}
public final SnowflakeQuotedIdentifiersIgnoreCaseContext snowflakeQuotedIdentifiersIgnoreCase() throws RecognitionException {
SnowflakeQuotedIdentifiersIgnoreCaseContext _localctx = new SnowflakeQuotedIdentifiersIgnoreCaseContext(_ctx, getState());
enterRule(_localctx, 28, RULE_snowflakeQuotedIdentifiersIgnoreCase);
try {
enterOuterAlt(_localctx, 1);
{
setState(138);
match(QUOTED_IDENTIFIERS_IGNORE_CASE);
setState(139);
match(COLON);
setState(140);
match(BOOLEAN);
setState(141);
match(SEMI_COLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DbRoleContext extends ParserRuleContext {
public TerminalNode ROLE() { return getToken(SnowflakeParserGrammar.ROLE, 0); }
public TerminalNode COLON() { return getToken(SnowflakeParserGrammar.COLON, 0); }
public TerminalNode STRING() { return getToken(SnowflakeParserGrammar.STRING, 0); }
public TerminalNode SEMI_COLON() { return getToken(SnowflakeParserGrammar.SEMI_COLON, 0); }
public DbRoleContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dbRole; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).enterDbRole(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).exitDbRole(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnowflakeParserGrammarVisitor ) return ((SnowflakeParserGrammarVisitor)visitor).visitDbRole(this);
else return visitor.visitChildren(this);
}
}
public final DbRoleContext dbRole() throws RecognitionException {
DbRoleContext _localctx = new DbRoleContext(_ctx, getState());
enterRule(_localctx, 30, RULE_dbRole);
try {
enterOuterAlt(_localctx, 1);
{
setState(143);
match(ROLE);
setState(144);
match(COLON);
setState(145);
match(STRING);
setState(146);
match(SEMI_COLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnableQueryTagsContext extends ParserRuleContext {
public TerminalNode ENABLE_QUERY_TAGS() { return getToken(SnowflakeParserGrammar.ENABLE_QUERY_TAGS, 0); }
public TerminalNode COLON() { return getToken(SnowflakeParserGrammar.COLON, 0); }
public TerminalNode BOOLEAN() { return getToken(SnowflakeParserGrammar.BOOLEAN, 0); }
public TerminalNode SEMI_COLON() { return getToken(SnowflakeParserGrammar.SEMI_COLON, 0); }
public EnableQueryTagsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enableQueryTags; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).enterEnableQueryTags(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).exitEnableQueryTags(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnowflakeParserGrammarVisitor ) return ((SnowflakeParserGrammarVisitor)visitor).visitEnableQueryTags(this);
else return visitor.visitChildren(this);
}
}
public final EnableQueryTagsContext enableQueryTags() throws RecognitionException {
EnableQueryTagsContext _localctx = new EnableQueryTagsContext(_ctx, getState());
enterRule(_localctx, 32, RULE_enableQueryTags);
try {
enterOuterAlt(_localctx, 1);
{
setState(148);
match(ENABLE_QUERY_TAGS);
setState(149);
match(COLON);
setState(150);
match(BOOLEAN);
setState(151);
match(SEMI_COLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SnowflakePublicAuthContext extends ParserRuleContext {
public TerminalNode SNOWFLAKE_PUBLIC_AUTH() { return getToken(SnowflakeParserGrammar.SNOWFLAKE_PUBLIC_AUTH, 0); }
public TerminalNode BRACE_OPEN() { return getToken(SnowflakeParserGrammar.BRACE_OPEN, 0); }
public TerminalNode BRACE_CLOSE() { return getToken(SnowflakeParserGrammar.BRACE_CLOSE, 0); }
public List snowflakePublicAuthKeyVaultRef() {
return getRuleContexts(SnowflakePublicAuthKeyVaultRefContext.class);
}
public SnowflakePublicAuthKeyVaultRefContext snowflakePublicAuthKeyVaultRef(int i) {
return getRuleContext(SnowflakePublicAuthKeyVaultRefContext.class,i);
}
public List snowflakePublicAuthPassPhraseVaultRef() {
return getRuleContexts(SnowflakePublicAuthPassPhraseVaultRefContext.class);
}
public SnowflakePublicAuthPassPhraseVaultRefContext snowflakePublicAuthPassPhraseVaultRef(int i) {
return getRuleContext(SnowflakePublicAuthPassPhraseVaultRefContext.class,i);
}
public List snowflakePublicAuthUserName() {
return getRuleContexts(SnowflakePublicAuthUserNameContext.class);
}
public SnowflakePublicAuthUserNameContext snowflakePublicAuthUserName(int i) {
return getRuleContext(SnowflakePublicAuthUserNameContext.class,i);
}
public SnowflakePublicAuthContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_snowflakePublicAuth; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).enterSnowflakePublicAuth(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).exitSnowflakePublicAuth(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnowflakeParserGrammarVisitor ) return ((SnowflakeParserGrammarVisitor)visitor).visitSnowflakePublicAuth(this);
else return visitor.visitChildren(this);
}
}
public final SnowflakePublicAuthContext snowflakePublicAuth() throws RecognitionException {
SnowflakePublicAuthContext _localctx = new SnowflakePublicAuthContext(_ctx, getState());
enterRule(_localctx, 34, RULE_snowflakePublicAuth);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(153);
match(SNOWFLAKE_PUBLIC_AUTH);
setState(154);
match(BRACE_OPEN);
setState(160);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << SNOWFLAKE_AUTH_KEY_VAULT_REFERENCE) | (1L << SNOWFLAKE_AUTH_PASSPHRASE_VAULT_REFERENCE) | (1L << SNOWFLAKE_AUTH_PUBLIC_USERNAME))) != 0)) {
{
setState(158);
_errHandler.sync(this);
switch (_input.LA(1)) {
case SNOWFLAKE_AUTH_KEY_VAULT_REFERENCE:
{
setState(155);
snowflakePublicAuthKeyVaultRef();
}
break;
case SNOWFLAKE_AUTH_PASSPHRASE_VAULT_REFERENCE:
{
setState(156);
snowflakePublicAuthPassPhraseVaultRef();
}
break;
case SNOWFLAKE_AUTH_PUBLIC_USERNAME:
{
setState(157);
snowflakePublicAuthUserName();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(162);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(163);
match(BRACE_CLOSE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SnowflakePublicAuthKeyVaultRefContext extends ParserRuleContext {
public TerminalNode SNOWFLAKE_AUTH_KEY_VAULT_REFERENCE() { return getToken(SnowflakeParserGrammar.SNOWFLAKE_AUTH_KEY_VAULT_REFERENCE, 0); }
public TerminalNode COLON() { return getToken(SnowflakeParserGrammar.COLON, 0); }
public TerminalNode STRING() { return getToken(SnowflakeParserGrammar.STRING, 0); }
public TerminalNode SEMI_COLON() { return getToken(SnowflakeParserGrammar.SEMI_COLON, 0); }
public SnowflakePublicAuthKeyVaultRefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_snowflakePublicAuthKeyVaultRef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).enterSnowflakePublicAuthKeyVaultRef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).exitSnowflakePublicAuthKeyVaultRef(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnowflakeParserGrammarVisitor ) return ((SnowflakeParserGrammarVisitor)visitor).visitSnowflakePublicAuthKeyVaultRef(this);
else return visitor.visitChildren(this);
}
}
public final SnowflakePublicAuthKeyVaultRefContext snowflakePublicAuthKeyVaultRef() throws RecognitionException {
SnowflakePublicAuthKeyVaultRefContext _localctx = new SnowflakePublicAuthKeyVaultRefContext(_ctx, getState());
enterRule(_localctx, 36, RULE_snowflakePublicAuthKeyVaultRef);
try {
enterOuterAlt(_localctx, 1);
{
setState(165);
match(SNOWFLAKE_AUTH_KEY_VAULT_REFERENCE);
setState(166);
match(COLON);
setState(167);
match(STRING);
setState(168);
match(SEMI_COLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SnowflakePublicAuthPassPhraseVaultRefContext extends ParserRuleContext {
public TerminalNode SNOWFLAKE_AUTH_PASSPHRASE_VAULT_REFERENCE() { return getToken(SnowflakeParserGrammar.SNOWFLAKE_AUTH_PASSPHRASE_VAULT_REFERENCE, 0); }
public TerminalNode COLON() { return getToken(SnowflakeParserGrammar.COLON, 0); }
public TerminalNode STRING() { return getToken(SnowflakeParserGrammar.STRING, 0); }
public TerminalNode SEMI_COLON() { return getToken(SnowflakeParserGrammar.SEMI_COLON, 0); }
public SnowflakePublicAuthPassPhraseVaultRefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_snowflakePublicAuthPassPhraseVaultRef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).enterSnowflakePublicAuthPassPhraseVaultRef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).exitSnowflakePublicAuthPassPhraseVaultRef(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnowflakeParserGrammarVisitor ) return ((SnowflakeParserGrammarVisitor)visitor).visitSnowflakePublicAuthPassPhraseVaultRef(this);
else return visitor.visitChildren(this);
}
}
public final SnowflakePublicAuthPassPhraseVaultRefContext snowflakePublicAuthPassPhraseVaultRef() throws RecognitionException {
SnowflakePublicAuthPassPhraseVaultRefContext _localctx = new SnowflakePublicAuthPassPhraseVaultRefContext(_ctx, getState());
enterRule(_localctx, 38, RULE_snowflakePublicAuthPassPhraseVaultRef);
try {
enterOuterAlt(_localctx, 1);
{
setState(170);
match(SNOWFLAKE_AUTH_PASSPHRASE_VAULT_REFERENCE);
setState(171);
match(COLON);
setState(172);
match(STRING);
setState(173);
match(SEMI_COLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SnowflakePublicAuthUserNameContext extends ParserRuleContext {
public TerminalNode SNOWFLAKE_AUTH_PUBLIC_USERNAME() { return getToken(SnowflakeParserGrammar.SNOWFLAKE_AUTH_PUBLIC_USERNAME, 0); }
public TerminalNode COLON() { return getToken(SnowflakeParserGrammar.COLON, 0); }
public TerminalNode STRING() { return getToken(SnowflakeParserGrammar.STRING, 0); }
public TerminalNode SEMI_COLON() { return getToken(SnowflakeParserGrammar.SEMI_COLON, 0); }
public SnowflakePublicAuthUserNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_snowflakePublicAuthUserName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).enterSnowflakePublicAuthUserName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).exitSnowflakePublicAuthUserName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnowflakeParserGrammarVisitor ) return ((SnowflakeParserGrammarVisitor)visitor).visitSnowflakePublicAuthUserName(this);
else return visitor.visitChildren(this);
}
}
public final SnowflakePublicAuthUserNameContext snowflakePublicAuthUserName() throws RecognitionException {
SnowflakePublicAuthUserNameContext _localctx = new SnowflakePublicAuthUserNameContext(_ctx, getState());
enterRule(_localctx, 40, RULE_snowflakePublicAuthUserName);
try {
enterOuterAlt(_localctx, 1);
{
setState(175);
match(SNOWFLAKE_AUTH_PUBLIC_USERNAME);
setState(176);
match(COLON);
setState(177);
match(STRING);
setState(178);
match(SEMI_COLON);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QualifiedNameContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public PackagePathContext packagePath() {
return getRuleContext(PackagePathContext.class,0);
}
public TerminalNode PATH_SEPARATOR() { return getToken(SnowflakeParserGrammar.PATH_SEPARATOR, 0); }
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 SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).enterQualifiedName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).exitQualifiedName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnowflakeParserGrammarVisitor ) return ((SnowflakeParserGrammarVisitor)visitor).visitQualifiedName(this);
else return visitor.visitChildren(this);
}
}
public final QualifiedNameContext qualifiedName() throws RecognitionException {
QualifiedNameContext _localctx = new QualifiedNameContext(_ctx, getState());
enterRule(_localctx, 42, RULE_qualifiedName);
try {
enterOuterAlt(_localctx, 1);
{
setState(183);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
case 1:
{
setState(180);
packagePath();
setState(181);
match(PATH_SEPARATOR);
}
break;
}
setState(185);
identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PackagePathContext extends ParserRuleContext {
public List identifier() {
return getRuleContexts(IdentifierContext.class);
}
public IdentifierContext identifier(int i) {
return getRuleContext(IdentifierContext.class,i);
}
public List PATH_SEPARATOR() { return getTokens(SnowflakeParserGrammar.PATH_SEPARATOR); }
public TerminalNode PATH_SEPARATOR(int i) {
return getToken(SnowflakeParserGrammar.PATH_SEPARATOR, i);
}
public PackagePathContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_packagePath; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).enterPackagePath(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).exitPackagePath(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnowflakeParserGrammarVisitor ) return ((SnowflakeParserGrammarVisitor)visitor).visitPackagePath(this);
else return visitor.visitChildren(this);
}
}
public final PackagePathContext packagePath() throws RecognitionException {
PackagePathContext _localctx = new PackagePathContext(_ctx, getState());
enterRule(_localctx, 44, RULE_packagePath);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(187);
identifier();
setState(192);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(188);
match(PATH_SEPARATOR);
setState(189);
identifier();
}
}
}
setState(194);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WordContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode BOOLEAN() { return getToken(SnowflakeParserGrammar.BOOLEAN, 0); }
public TerminalNode INTEGER() { return getToken(SnowflakeParserGrammar.INTEGER, 0); }
public WordContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_word; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).enterWord(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).exitWord(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnowflakeParserGrammarVisitor ) return ((SnowflakeParserGrammarVisitor)visitor).visitWord(this);
else return visitor.visitChildren(this);
}
}
public final WordContext word() throws RecognitionException {
WordContext _localctx = new WordContext(_ctx, getState());
enterRule(_localctx, 46, RULE_word);
try {
setState(198);
_errHandler.sync(this);
switch (_input.LA(1)) {
case VALID_STRING:
enterOuterAlt(_localctx, 1);
{
setState(195);
identifier();
}
break;
case BOOLEAN:
enterOuterAlt(_localctx, 2);
{
setState(196);
match(BOOLEAN);
}
break;
case INTEGER:
enterOuterAlt(_localctx, 3);
{
setState(197);
match(INTEGER);
}
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 IslandDefinitionContext extends ParserRuleContext {
public TerminalNode ISLAND_OPEN() { return getToken(SnowflakeParserGrammar.ISLAND_OPEN, 0); }
public IslandContentContext islandContent() {
return getRuleContext(IslandContentContext.class,0);
}
public IslandDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_islandDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).enterIslandDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).exitIslandDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnowflakeParserGrammarVisitor ) return ((SnowflakeParserGrammarVisitor)visitor).visitIslandDefinition(this);
else return visitor.visitChildren(this);
}
}
public final IslandDefinitionContext islandDefinition() throws RecognitionException {
IslandDefinitionContext _localctx = new IslandDefinitionContext(_ctx, getState());
enterRule(_localctx, 48, RULE_islandDefinition);
try {
enterOuterAlt(_localctx, 1);
{
setState(200);
match(ISLAND_OPEN);
setState(201);
islandContent();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IslandContentContext extends ParserRuleContext {
public List ISLAND_START() { return getTokens(SnowflakeParserGrammar.ISLAND_START); }
public TerminalNode ISLAND_START(int i) {
return getToken(SnowflakeParserGrammar.ISLAND_START, i);
}
public List ISLAND_BRACE_OPEN() { return getTokens(SnowflakeParserGrammar.ISLAND_BRACE_OPEN); }
public TerminalNode ISLAND_BRACE_OPEN(int i) {
return getToken(SnowflakeParserGrammar.ISLAND_BRACE_OPEN, i);
}
public List ISLAND_CONTENT() { return getTokens(SnowflakeParserGrammar.ISLAND_CONTENT); }
public TerminalNode ISLAND_CONTENT(int i) {
return getToken(SnowflakeParserGrammar.ISLAND_CONTENT, i);
}
public List ISLAND_HASH() { return getTokens(SnowflakeParserGrammar.ISLAND_HASH); }
public TerminalNode ISLAND_HASH(int i) {
return getToken(SnowflakeParserGrammar.ISLAND_HASH, i);
}
public List ISLAND_BRACE_CLOSE() { return getTokens(SnowflakeParserGrammar.ISLAND_BRACE_CLOSE); }
public TerminalNode ISLAND_BRACE_CLOSE(int i) {
return getToken(SnowflakeParserGrammar.ISLAND_BRACE_CLOSE, i);
}
public List ISLAND_END() { return getTokens(SnowflakeParserGrammar.ISLAND_END); }
public TerminalNode ISLAND_END(int i) {
return getToken(SnowflakeParserGrammar.ISLAND_END, i);
}
public IslandContentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_islandContent; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).enterIslandContent(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SnowflakeParserGrammarListener ) ((SnowflakeParserGrammarListener)listener).exitIslandContent(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SnowflakeParserGrammarVisitor ) return ((SnowflakeParserGrammarVisitor)visitor).visitIslandContent(this);
else return visitor.visitChildren(this);
}
}
public final IslandContentContext islandContent() throws RecognitionException {
IslandContentContext _localctx = new IslandContentContext(_ctx, getState());
enterRule(_localctx, 50, RULE_islandContent);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(206);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & ((1L << (ISLAND_START - 72)) | (1L << (ISLAND_END - 72)) | (1L << (ISLAND_HASH - 72)) | (1L << (ISLAND_BRACE_OPEN - 72)) | (1L << (ISLAND_BRACE_CLOSE - 72)) | (1L << (ISLAND_CONTENT - 72)))) != 0)) {
{
{
setState(203);
_la = _input.LA(1);
if ( !(((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & ((1L << (ISLAND_START - 72)) | (1L << (ISLAND_END - 72)) | (1L << (ISLAND_HASH - 72)) | (1L << (ISLAND_BRACE_OPEN - 72)) | (1L << (ISLAND_BRACE_CLOSE - 72)) | (1L << (ISLAND_CONTENT - 72)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(208);
_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 final String _serializedATN =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3O\u00d4\4\2\t\2\4"+
"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
"\4\32\t\32\4\33\t\33\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3"+
"\3\3\3\3\3\3\3\3\3\3\3\3\3\7\3J\n\3\f\3\16\3M\13\3\3\3\3\3\3\4\3\4\3\4"+
"\3\4\3\4\3\5\3\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\7\3\7\3\7\3\7\3\7\3"+
"\b\3\b\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\13\3\13\3"+
"\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\r\3\r\3\r\3\r\3\r\3\16\3\16\3\16\3"+
"\16\3\16\3\17\3\17\3\17\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3\21\3\21\3"+
"\21\3\21\3\21\3\22\3\22\3\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\7\23\u00a1"+
"\n\23\f\23\16\23\u00a4\13\23\3\23\3\23\3\24\3\24\3\24\3\24\3\24\3\25\3"+
"\25\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\26\3\27\3\27\3\27\5\27\u00ba"+
"\n\27\3\27\3\27\3\30\3\30\3\30\7\30\u00c1\n\30\f\30\16\30\u00c4\13\30"+
"\3\31\3\31\3\31\5\31\u00c9\n\31\3\32\3\32\3\32\3\33\7\33\u00cf\n\33\f"+
"\33\16\33\u00d2\13\33\3\33\2\2\34\2\4\6\b\n\f\16\20\22\24\26\30\32\34"+
"\36 \"$&(*,.\60\62\64\2\3\3\2JO\2\u00d0\2\66\3\2\2\2\48\3\2\2\2\6P\3\2"+
"\2\2\bU\3\2\2\2\nZ\3\2\2\2\f_\3\2\2\2\16d\3\2\2\2\20i\3\2\2\2\22n\3\2"+
"\2\2\24s\3\2\2\2\26x\3\2\2\2\30}\3\2\2\2\32\u0082\3\2\2\2\34\u0087\3\2"+
"\2\2\36\u008c\3\2\2\2 \u0091\3\2\2\2\"\u0096\3\2\2\2$\u009b\3\2\2\2&\u00a7"+
"\3\2\2\2(\u00ac\3\2\2\2*\u00b1\3\2\2\2,\u00b9\3\2\2\2.\u00bd\3\2\2\2\60"+
"\u00c8\3\2\2\2\62\u00ca\3\2\2\2\64\u00d0\3\2\2\2\66\67\7H\2\2\67\3\3\2"+
"\2\289\7\4\2\29K\7\61\2\2:J\5\6\4\2;J\5\n\6\2J"+
"\5\34\17\2?J\5\36\20\2@J\5\f\7\2AJ\5\16\b\2BJ\5\20\t\2CJ\5\22\n\2DJ\5"+
"\24\13\2EJ\5\26\f\2FJ\5\30\r\2GJ\5 \21\2HJ\5\"\22\2I:\3\2\2\2I;\3\2\2"+
"\2I<\3\2\2\2I=\3\2\2\2I>\3\2\2\2I?\3\2\2\2I@\3\2\2\2IA\3\2\2\2IB\3\2\2"+
"\2IC\3\2\2\2ID\3\2\2\2IE\3\2\2\2IF\3\2\2\2IG\3\2\2\2IH\3\2\2\2JM\3\2\2"+
"\2KI\3\2\2\2KL\3\2\2\2LN\3\2\2\2MK\3\2\2\2NO\7\62\2\2O\5\3\2\2\2PQ\7\3"+
"\2\2QR\7\67\2\2RS\7\33\2\2ST\7;\2\2T\7\3\2\2\2UV\7\6\2\2VW\7\67\2\2WX"+
"\7\33\2\2XY\7;\2\2Y\t\3\2\2\2Z[\7\5\2\2[\\\7\67\2\2\\]\7\33\2\2]^\7;\2"+
"\2^\13\3\2\2\2_`\7\n\2\2`a\7\67\2\2ab\7\33\2\2bc\7;\2\2c\r\3\2\2\2de\7"+
"\13\2\2ef\7\67\2\2fg\7\33\2\2gh\7;\2\2h\17\3\2\2\2ij\7\f\2\2jk\7\67\2"+
"\2kl\7\33\2\2lm\7;\2\2m\21\3\2\2\2no\7\r\2\2op\7\67\2\2pq\7\33\2\2qr\7"+
";\2\2r\23\3\2\2\2st\7\16\2\2tu\7\67\2\2uv\7\33\2\2vw\7;\2\2w\25\3\2\2"+
"\2xy\7\17\2\2yz\7\67\2\2z{\5\2\2\2{|\7;\2\2|\27\3\2\2\2}~\7\20\2\2~\177"+
"\7\67\2\2\177\u0080\7\33\2\2\u0080\u0081\7;\2\2\u0081\31\3\2\2\2\u0082"+
"\u0083\7\7\2\2\u0083\u0084\7\67\2\2\u0084\u0085\7\33\2\2\u0085\u0086\7"+
";\2\2\u0086\33\3\2\2\2\u0087\u0088\7\b\2\2\u0088\u0089\7\67\2\2\u0089"+
"\u008a\7\33\2\2\u008a\u008b\7;\2\2\u008b\35\3\2\2\2\u008c\u008d\7\t\2"+
"\2\u008d\u008e\7\67\2\2\u008e\u008f\7\34\2\2\u008f\u0090\7;\2\2\u0090"+
"\37\3\2\2\2\u0091\u0092\7\21\2\2\u0092\u0093\7\67\2\2\u0093\u0094\7\33"+
"\2\2\u0094\u0095\7;\2\2\u0095!\3\2\2\2\u0096\u0097\7\22\2\2\u0097\u0098"+
"\7\67\2\2\u0098\u0099\7\34\2\2\u0099\u009a\7;\2\2\u009a#\3\2\2\2\u009b"+
"\u009c\7\23\2\2\u009c\u00a2\7\61\2\2\u009d\u00a1\5&\24\2\u009e\u00a1\5"+
"(\25\2\u009f\u00a1\5*\26\2\u00a0\u009d\3\2\2\2\u00a0\u009e\3\2\2\2\u00a0"+
"\u009f\3\2\2\2\u00a1\u00a4\3\2\2\2\u00a2\u00a0\3\2\2\2\u00a2\u00a3\3\2"+
"\2\2\u00a3\u00a5\3\2\2\2\u00a4\u00a2\3\2\2\2\u00a5\u00a6\7\62\2\2\u00a6"+
"%\3\2\2\2\u00a7\u00a8\7\24\2\2\u00a8\u00a9\7\67\2\2\u00a9\u00aa\7\33\2"+
"\2\u00aa\u00ab\7;\2\2\u00ab\'\3\2\2\2\u00ac\u00ad\7\25\2\2\u00ad\u00ae"+
"\7\67\2\2\u00ae\u00af\7\33\2\2\u00af\u00b0\7;\2\2\u00b0)\3\2\2\2\u00b1"+
"\u00b2\7\26\2\2\u00b2\u00b3\7\67\2\2\u00b3\u00b4\7\33\2\2\u00b4\u00b5"+
"\7;\2\2\u00b5+\3\2\2\2\u00b6\u00b7\5.\30\2\u00b7\u00b8\7\'\2\2\u00b8\u00ba"+
"\3\2\2\2\u00b9\u00b6\3\2\2\2\u00b9\u00ba\3\2\2\2\u00ba\u00bb\3\2\2\2\u00bb"+
"\u00bc\5\2\2\2\u00bc-\3\2\2\2\u00bd\u00c2\5\2\2\2\u00be\u00bf\7\'\2\2"+
"\u00bf\u00c1\5\2\2\2\u00c0\u00be\3\2\2\2\u00c1\u00c4\3\2\2\2\u00c2\u00c0"+
"\3\2\2\2\u00c2\u00c3\3\2\2\2\u00c3/\3\2\2\2\u00c4\u00c2\3\2\2\2\u00c5"+
"\u00c9\5\2\2\2\u00c6\u00c9\7\34\2\2\u00c7\u00c9\7\37\2\2\u00c8\u00c5\3"+
"\2\2\2\u00c8\u00c6\3\2\2\2\u00c8\u00c7\3\2\2\2\u00c9\61\3\2\2\2\u00ca"+
"\u00cb\7\32\2\2\u00cb\u00cc\5\64\33\2\u00cc\63\3\2\2\2\u00cd\u00cf\t\2"+
"\2\2\u00ce\u00cd\3\2\2\2\u00cf\u00d2\3\2\2\2\u00d0\u00ce\3\2\2\2\u00d0"+
"\u00d1\3\2\2\2\u00d1\65\3\2\2\2\u00d2\u00d0\3\2\2\2\nIK\u00a0\u00a2\u00b9"+
"\u00c2\u00c8\u00d0";
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);
}
}
}
