com.squareup.sqldelight.SqliteParser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of compiler Show documentation
Show all versions of compiler Show documentation
Common code shared between the Gradle and IntelliJ plugin
// Generated from com/squareup/sqldelight/Sqlite.g4 by ANTLR 4.5
package com.squareup.sqldelight;
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 SqliteParser extends Parser {
static { RuntimeMetaData.checkVersion("4.5", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
T__0=1, T__1=2, K_JAVA_BOOLEAN=3, K_JAVA_INTEGER=4, K_JAVA_LONG=5, K_JAVA_FLOAT=6,
K_JAVA_DOUBLE=7, K_JAVA_STRING=8, K_JAVA_BYTE_ARRAY=9, K_INTEGER=10, K_REAL=11,
K_TEXT=12, K_BLOB=13, SCOL=14, DOT=15, OPEN_PAR=16, CLOSE_PAR=17, COMMA=18,
ASSIGN=19, STAR=20, PLUS=21, MINUS=22, TILDE=23, PIPE2=24, DIV=25, MOD=26,
LT2=27, GT2=28, AMP=29, PIPE=30, LT=31, LT_EQ=32, GT=33, GT_EQ=34, EQ=35,
NOT_EQ1=36, NOT_EQ2=37, QUOTE=38, K_ABORT=39, K_ACTION=40, K_ADD=41, K_AFTER=42,
K_ALL=43, K_ALTER=44, K_ANALYZE=45, K_AND=46, K_AS=47, K_ASC=48, K_ATTACH=49,
K_AUTOINCREMENT=50, K_BEFORE=51, K_BEGIN=52, K_BETWEEN=53, K_BY=54, K_CASCADE=55,
K_CASE=56, K_CAST=57, K_CHECK=58, K_COLLATE=59, K_COLUMN=60, K_COMMIT=61,
K_CONFLICT=62, K_CONSTRAINT=63, K_CREATE=64, K_CROSS=65, K_CURRENT_DATE=66,
K_CURRENT_TIME=67, K_CURRENT_TIMESTAMP=68, K_DATABASE=69, K_DEFAULT=70,
K_DEFERRABLE=71, K_DEFERRED=72, K_DELETE=73, K_DESC=74, K_DETACH=75, K_DISTINCT=76,
K_DROP=77, K_EACH=78, K_ELSE=79, K_END=80, K_ESCAPE=81, K_EXCEPT=82, K_EXCLUSIVE=83,
K_EXISTS=84, K_EXPLAIN=85, K_FAIL=86, K_FOR=87, K_FOREIGN_KEY=88, K_FROM=89,
K_FULL=90, K_GLOB=91, K_GROUP=92, K_HAVING=93, K_IF=94, K_IGNORE=95, K_IMMEDIATE=96,
K_IN=97, K_INDEX=98, K_INDEXED=99, K_INITIALLY=100, K_INNER=101, K_INSERT=102,
K_INSTEAD=103, K_INTERSECT=104, K_INTO=105, K_IS=106, K_ISNULL=107, K_JOIN=108,
K_LEFT=109, K_LIKE=110, K_LIMIT=111, K_MATCH=112, K_NATURAL=113, K_NO=114,
K_NOT=115, K_NOTNULL=116, K_NULL=117, K_OF=118, K_OFFSET=119, K_ON=120,
K_OR=121, K_ORDER=122, K_OUTER=123, K_PLAN=124, K_PRAGMA=125, K_PRIMARY_KEY=126,
K_QUERY=127, K_RAISE=128, K_RECURSIVE=129, K_REFERENCES=130, K_REGEXP=131,
K_REINDEX=132, K_RELEASE=133, K_RENAME=134, K_REPLACE=135, K_RESTRICT=136,
K_RIGHT=137, K_ROLLBACK=138, K_ROW=139, K_SAVEPOINT=140, K_SELECT=141,
K_SET=142, K_TABLE=143, K_TEMP=144, K_TEMPORARY=145, K_THEN=146, K_TO=147,
K_TRANSACTION=148, K_TRIGGER=149, K_UNION=150, K_UNIQUE=151, K_UPDATE=152,
K_USING=153, K_VACUUM=154, K_VALUES=155, K_VIEW=156, K_WHEN=157, K_WHERE=158,
K_WITH=159, K_WITHOUT=160, IDENTIFIER=161, NUMERIC_LITERAL=162, BIND_PARAMETER=163,
STRING_LITERAL=164, BLOB_LITERAL=165, SINGLE_LINE_COMMENT=166, MULTILINE_COMMENT=167,
SPACES=168, UNEXPECTED_CHAR=169;
public static final int
RULE_parse = 0, RULE_error = 1, RULE_sql_stmt_list = 2, RULE_sql_stmt = 3,
RULE_alter_table_stmt = 4, RULE_analyze_stmt = 5, RULE_create_index_stmt = 6,
RULE_create_table_stmt = 7, RULE_create_trigger_stmt = 8, RULE_create_view_stmt = 9,
RULE_delete_stmt = 10, RULE_delete_stmt_limited = 11, RULE_drop_index_stmt = 12,
RULE_drop_table_stmt = 13, RULE_drop_trigger_stmt = 14, RULE_drop_view_stmt = 15,
RULE_insert_stmt = 16, RULE_pragma_stmt = 17, RULE_reindex_stmt = 18,
RULE_release_stmt = 19, RULE_savepoint_stmt = 20, RULE_select_stmt = 21,
RULE_select_or_values = 22, RULE_values = 23, RULE_update_stmt = 24, RULE_update_stmt_limited = 25,
RULE_vacuum_stmt = 26, RULE_column_def = 27, RULE_type_name = 28, RULE_column_constraint = 29,
RULE_conflict_clause = 30, RULE_expr = 31, RULE_foreign_key_clause = 32,
RULE_raise_function = 33, RULE_indexed_column = 34, RULE_table_constraint = 35,
RULE_with_clause = 36, RULE_qualified_table_name = 37, RULE_ordering_term = 38,
RULE_pragma_value = 39, RULE_common_table_expression = 40, RULE_result_column = 41,
RULE_table_or_subquery = 42, RULE_join_clause = 43, RULE_join_operator = 44,
RULE_join_constraint = 45, RULE_compound_operator = 46, RULE_signed_number = 47,
RULE_literal_value = 48, RULE_unary_operator = 49, RULE_error_message = 50,
RULE_column_alias = 51, RULE_keyword = 52, RULE_name = 53, RULE_function_name = 54,
RULE_table_name = 55, RULE_table_or_index_name = 56, RULE_new_table_name = 57,
RULE_column_name = 58, RULE_sql_stmt_name = 59, RULE_collation_name = 60,
RULE_foreign_table = 61, RULE_index_name = 62, RULE_trigger_name = 63,
RULE_view_name = 64, RULE_pragma_name = 65, RULE_savepoint_name = 66,
RULE_table_alias = 67, RULE_sqlite_type_name = 68, RULE_java_type_name = 69,
RULE_any_name = 70;
public static final String[] ruleNames = {
"parse", "error", "sql_stmt_list", "sql_stmt", "alter_table_stmt", "analyze_stmt",
"create_index_stmt", "create_table_stmt", "create_trigger_stmt", "create_view_stmt",
"delete_stmt", "delete_stmt_limited", "drop_index_stmt", "drop_table_stmt",
"drop_trigger_stmt", "drop_view_stmt", "insert_stmt", "pragma_stmt", "reindex_stmt",
"release_stmt", "savepoint_stmt", "select_stmt", "select_or_values", "values",
"update_stmt", "update_stmt_limited", "vacuum_stmt", "column_def", "type_name",
"column_constraint", "conflict_clause", "expr", "foreign_key_clause",
"raise_function", "indexed_column", "table_constraint", "with_clause",
"qualified_table_name", "ordering_term", "pragma_value", "common_table_expression",
"result_column", "table_or_subquery", "join_clause", "join_operator",
"join_constraint", "compound_operator", "signed_number", "literal_value",
"unary_operator", "error_message", "column_alias", "keyword", "name",
"function_name", "table_name", "table_or_index_name", "new_table_name",
"column_name", "sql_stmt_name", "collation_name", "foreign_table", "index_name",
"trigger_name", "view_name", "pragma_name", "savepoint_name", "table_alias",
"sqlite_type_name", "java_type_name", "any_name"
};
private static final String[] _LITERAL_NAMES = {
null, "':'", "'?'", null, null, null, null, null, null, null, null, null,
null, null, "';'", "'.'", "'('", "')'", "','", "'='", "'*'", "'+'", "'-'",
"'~'", "'||'", "'/'", "'%'", "'<<'", "'>>'", "'&'", "'|'", "'<'", "'<='",
"'>'", "'>='", "'=='", "'!='", "'<>'", "'''"
};
private static final String[] _SYMBOLIC_NAMES = {
null, null, null, "K_JAVA_BOOLEAN", "K_JAVA_INTEGER", "K_JAVA_LONG", "K_JAVA_FLOAT",
"K_JAVA_DOUBLE", "K_JAVA_STRING", "K_JAVA_BYTE_ARRAY", "K_INTEGER", "K_REAL",
"K_TEXT", "K_BLOB", "SCOL", "DOT", "OPEN_PAR", "CLOSE_PAR", "COMMA", "ASSIGN",
"STAR", "PLUS", "MINUS", "TILDE", "PIPE2", "DIV", "MOD", "LT2", "GT2",
"AMP", "PIPE", "LT", "LT_EQ", "GT", "GT_EQ", "EQ", "NOT_EQ1", "NOT_EQ2",
"QUOTE", "K_ABORT", "K_ACTION", "K_ADD", "K_AFTER", "K_ALL", "K_ALTER",
"K_ANALYZE", "K_AND", "K_AS", "K_ASC", "K_ATTACH", "K_AUTOINCREMENT",
"K_BEFORE", "K_BEGIN", "K_BETWEEN", "K_BY", "K_CASCADE", "K_CASE", "K_CAST",
"K_CHECK", "K_COLLATE", "K_COLUMN", "K_COMMIT", "K_CONFLICT", "K_CONSTRAINT",
"K_CREATE", "K_CROSS", "K_CURRENT_DATE", "K_CURRENT_TIME", "K_CURRENT_TIMESTAMP",
"K_DATABASE", "K_DEFAULT", "K_DEFERRABLE", "K_DEFERRED", "K_DELETE", "K_DESC",
"K_DETACH", "K_DISTINCT", "K_DROP", "K_EACH", "K_ELSE", "K_END", "K_ESCAPE",
"K_EXCEPT", "K_EXCLUSIVE", "K_EXISTS", "K_EXPLAIN", "K_FAIL", "K_FOR",
"K_FOREIGN_KEY", "K_FROM", "K_FULL", "K_GLOB", "K_GROUP", "K_HAVING",
"K_IF", "K_IGNORE", "K_IMMEDIATE", "K_IN", "K_INDEX", "K_INDEXED", "K_INITIALLY",
"K_INNER", "K_INSERT", "K_INSTEAD", "K_INTERSECT", "K_INTO", "K_IS", "K_ISNULL",
"K_JOIN", "K_LEFT", "K_LIKE", "K_LIMIT", "K_MATCH", "K_NATURAL", "K_NO",
"K_NOT", "K_NOTNULL", "K_NULL", "K_OF", "K_OFFSET", "K_ON", "K_OR", "K_ORDER",
"K_OUTER", "K_PLAN", "K_PRAGMA", "K_PRIMARY_KEY", "K_QUERY", "K_RAISE",
"K_RECURSIVE", "K_REFERENCES", "K_REGEXP", "K_REINDEX", "K_RELEASE", "K_RENAME",
"K_REPLACE", "K_RESTRICT", "K_RIGHT", "K_ROLLBACK", "K_ROW", "K_SAVEPOINT",
"K_SELECT", "K_SET", "K_TABLE", "K_TEMP", "K_TEMPORARY", "K_THEN", "K_TO",
"K_TRANSACTION", "K_TRIGGER", "K_UNION", "K_UNIQUE", "K_UPDATE", "K_USING",
"K_VACUUM", "K_VALUES", "K_VIEW", "K_WHEN", "K_WHERE", "K_WITH", "K_WITHOUT",
"IDENTIFIER", "NUMERIC_LITERAL", "BIND_PARAMETER", "STRING_LITERAL", "BLOB_LITERAL",
"SINGLE_LINE_COMMENT", "MULTILINE_COMMENT", "SPACES", "UNEXPECTED_CHAR"
};
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 "Sqlite.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public SqliteParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class ParseContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(SqliteParser.EOF, 0); }
public Sql_stmt_listContext sql_stmt_list() {
return getRuleContext(Sql_stmt_listContext.class,0);
}
public ErrorContext error() {
return getRuleContext(ErrorContext.class,0);
}
public ParseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parse; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterParse(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitParse(this);
}
}
public final ParseContext parse() throws RecognitionException {
ParseContext _localctx = new ParseContext(_ctx, getState());
enterRule(_localctx, 0, RULE_parse);
try {
enterOuterAlt(_localctx, 1);
{
setState(144);
switch (_input.LA(1)) {
case EOF:
case K_CREATE:
case IDENTIFIER:
{
setState(142);
sql_stmt_list();
}
break;
case UNEXPECTED_CHAR:
{
setState(143);
error();
}
break;
default:
throw new NoViableAltException(this);
}
setState(146);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ErrorContext extends ParserRuleContext {
public TerminalNode UNEXPECTED_CHAR() { return getToken(SqliteParser.UNEXPECTED_CHAR, 0); }
public ErrorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_error; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterError(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitError(this);
}
}
public final ErrorContext error() throws RecognitionException {
ErrorContext _localctx = new ErrorContext(_ctx, getState());
enterRule(_localctx, 2, RULE_error);
try {
enterOuterAlt(_localctx, 1);
{
setState(148);
match(UNEXPECTED_CHAR);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Sql_stmt_listContext extends ParserRuleContext {
public Create_table_stmtContext create_table_stmt() {
return getRuleContext(Create_table_stmtContext.class,0);
}
public List sql_stmt() {
return getRuleContexts(Sql_stmtContext.class);
}
public Sql_stmtContext sql_stmt(int i) {
return getRuleContext(Sql_stmtContext.class,i);
}
public Sql_stmt_listContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sql_stmt_list; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterSql_stmt_list(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitSql_stmt_list(this);
}
}
public final Sql_stmt_listContext sql_stmt_list() throws RecognitionException {
Sql_stmt_listContext _localctx = new Sql_stmt_listContext(_ctx, getState());
enterRule(_localctx, 4, RULE_sql_stmt_list);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(153);
_la = _input.LA(1);
if (_la==K_CREATE) {
{
setState(150);
create_table_stmt();
setState(151);
match(SCOL);
}
}
setState(160);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==IDENTIFIER) {
{
{
setState(155);
sql_stmt();
setState(156);
match(SCOL);
}
}
setState(162);
_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 Sql_stmtContext extends ParserRuleContext {
public Sql_stmt_nameContext sql_stmt_name() {
return getRuleContext(Sql_stmt_nameContext.class,0);
}
public Alter_table_stmtContext alter_table_stmt() {
return getRuleContext(Alter_table_stmtContext.class,0);
}
public Analyze_stmtContext analyze_stmt() {
return getRuleContext(Analyze_stmtContext.class,0);
}
public Create_index_stmtContext create_index_stmt() {
return getRuleContext(Create_index_stmtContext.class,0);
}
public Create_trigger_stmtContext create_trigger_stmt() {
return getRuleContext(Create_trigger_stmtContext.class,0);
}
public Create_view_stmtContext create_view_stmt() {
return getRuleContext(Create_view_stmtContext.class,0);
}
public Delete_stmtContext delete_stmt() {
return getRuleContext(Delete_stmtContext.class,0);
}
public Delete_stmt_limitedContext delete_stmt_limited() {
return getRuleContext(Delete_stmt_limitedContext.class,0);
}
public Drop_index_stmtContext drop_index_stmt() {
return getRuleContext(Drop_index_stmtContext.class,0);
}
public Drop_table_stmtContext drop_table_stmt() {
return getRuleContext(Drop_table_stmtContext.class,0);
}
public Drop_trigger_stmtContext drop_trigger_stmt() {
return getRuleContext(Drop_trigger_stmtContext.class,0);
}
public Drop_view_stmtContext drop_view_stmt() {
return getRuleContext(Drop_view_stmtContext.class,0);
}
public Insert_stmtContext insert_stmt() {
return getRuleContext(Insert_stmtContext.class,0);
}
public Pragma_stmtContext pragma_stmt() {
return getRuleContext(Pragma_stmtContext.class,0);
}
public Reindex_stmtContext reindex_stmt() {
return getRuleContext(Reindex_stmtContext.class,0);
}
public Release_stmtContext release_stmt() {
return getRuleContext(Release_stmtContext.class,0);
}
public Savepoint_stmtContext savepoint_stmt() {
return getRuleContext(Savepoint_stmtContext.class,0);
}
public Select_stmtContext select_stmt() {
return getRuleContext(Select_stmtContext.class,0);
}
public Update_stmtContext update_stmt() {
return getRuleContext(Update_stmtContext.class,0);
}
public Update_stmt_limitedContext update_stmt_limited() {
return getRuleContext(Update_stmt_limitedContext.class,0);
}
public Vacuum_stmtContext vacuum_stmt() {
return getRuleContext(Vacuum_stmtContext.class,0);
}
public TerminalNode K_EXPLAIN() { return getToken(SqliteParser.K_EXPLAIN, 0); }
public TerminalNode K_QUERY() { return getToken(SqliteParser.K_QUERY, 0); }
public TerminalNode K_PLAN() { return getToken(SqliteParser.K_PLAN, 0); }
public Sql_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sql_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterSql_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitSql_stmt(this);
}
}
public final Sql_stmtContext sql_stmt() throws RecognitionException {
Sql_stmtContext _localctx = new Sql_stmtContext(_ctx, getState());
enterRule(_localctx, 6, RULE_sql_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(163);
sql_stmt_name();
setState(164);
match(T__0);
setState(170);
_la = _input.LA(1);
if (_la==K_EXPLAIN) {
{
setState(165);
match(K_EXPLAIN);
setState(168);
_la = _input.LA(1);
if (_la==K_QUERY) {
{
setState(166);
match(K_QUERY);
setState(167);
match(K_PLAN);
}
}
}
}
setState(192);
switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
case 1:
{
setState(172);
alter_table_stmt();
}
break;
case 2:
{
setState(173);
analyze_stmt();
}
break;
case 3:
{
setState(174);
create_index_stmt();
}
break;
case 4:
{
setState(175);
create_trigger_stmt();
}
break;
case 5:
{
setState(176);
create_view_stmt();
}
break;
case 6:
{
setState(177);
delete_stmt();
}
break;
case 7:
{
setState(178);
delete_stmt_limited();
}
break;
case 8:
{
setState(179);
drop_index_stmt();
}
break;
case 9:
{
setState(180);
drop_table_stmt();
}
break;
case 10:
{
setState(181);
drop_trigger_stmt();
}
break;
case 11:
{
setState(182);
drop_view_stmt();
}
break;
case 12:
{
setState(183);
insert_stmt();
}
break;
case 13:
{
setState(184);
pragma_stmt();
}
break;
case 14:
{
setState(185);
reindex_stmt();
}
break;
case 15:
{
setState(186);
release_stmt();
}
break;
case 16:
{
setState(187);
savepoint_stmt();
}
break;
case 17:
{
setState(188);
select_stmt();
}
break;
case 18:
{
setState(189);
update_stmt();
}
break;
case 19:
{
setState(190);
update_stmt_limited();
}
break;
case 20:
{
setState(191);
vacuum_stmt();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Alter_table_stmtContext extends ParserRuleContext {
public TerminalNode K_ALTER() { return getToken(SqliteParser.K_ALTER, 0); }
public TerminalNode K_TABLE() { return getToken(SqliteParser.K_TABLE, 0); }
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public TerminalNode K_RENAME() { return getToken(SqliteParser.K_RENAME, 0); }
public TerminalNode K_TO() { return getToken(SqliteParser.K_TO, 0); }
public New_table_nameContext new_table_name() {
return getRuleContext(New_table_nameContext.class,0);
}
public TerminalNode K_ADD() { return getToken(SqliteParser.K_ADD, 0); }
public Column_defContext column_def() {
return getRuleContext(Column_defContext.class,0);
}
public TerminalNode K_COLUMN() { return getToken(SqliteParser.K_COLUMN, 0); }
public Alter_table_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_alter_table_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterAlter_table_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitAlter_table_stmt(this);
}
}
public final Alter_table_stmtContext alter_table_stmt() throws RecognitionException {
Alter_table_stmtContext _localctx = new Alter_table_stmtContext(_ctx, getState());
enterRule(_localctx, 8, RULE_alter_table_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(194);
match(K_ALTER);
setState(195);
match(K_TABLE);
setState(196);
table_name();
setState(205);
switch (_input.LA(1)) {
case K_RENAME:
{
setState(197);
match(K_RENAME);
setState(198);
match(K_TO);
setState(199);
new_table_name();
}
break;
case K_ADD:
{
setState(200);
match(K_ADD);
setState(202);
_la = _input.LA(1);
if (_la==K_COLUMN) {
{
setState(201);
match(K_COLUMN);
}
}
setState(204);
column_def();
}
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 Analyze_stmtContext extends ParserRuleContext {
public TerminalNode K_ANALYZE() { return getToken(SqliteParser.K_ANALYZE, 0); }
public Table_or_index_nameContext table_or_index_name() {
return getRuleContext(Table_or_index_nameContext.class,0);
}
public Analyze_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_analyze_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterAnalyze_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitAnalyze_stmt(this);
}
}
public final Analyze_stmtContext analyze_stmt() throws RecognitionException {
Analyze_stmtContext _localctx = new Analyze_stmtContext(_ctx, getState());
enterRule(_localctx, 10, RULE_analyze_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(207);
match(K_ANALYZE);
setState(208);
table_or_index_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Create_index_stmtContext extends ParserRuleContext {
public TerminalNode K_CREATE() { return getToken(SqliteParser.K_CREATE, 0); }
public TerminalNode K_INDEX() { return getToken(SqliteParser.K_INDEX, 0); }
public Index_nameContext index_name() {
return getRuleContext(Index_nameContext.class,0);
}
public TerminalNode K_ON() { return getToken(SqliteParser.K_ON, 0); }
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public List indexed_column() {
return getRuleContexts(Indexed_columnContext.class);
}
public Indexed_columnContext indexed_column(int i) {
return getRuleContext(Indexed_columnContext.class,i);
}
public TerminalNode K_UNIQUE() { return getToken(SqliteParser.K_UNIQUE, 0); }
public TerminalNode K_IF() { return getToken(SqliteParser.K_IF, 0); }
public TerminalNode K_NOT() { return getToken(SqliteParser.K_NOT, 0); }
public TerminalNode K_EXISTS() { return getToken(SqliteParser.K_EXISTS, 0); }
public TerminalNode K_WHERE() { return getToken(SqliteParser.K_WHERE, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public Create_index_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_create_index_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterCreate_index_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitCreate_index_stmt(this);
}
}
public final Create_index_stmtContext create_index_stmt() throws RecognitionException {
Create_index_stmtContext _localctx = new Create_index_stmtContext(_ctx, getState());
enterRule(_localctx, 12, RULE_create_index_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(210);
match(K_CREATE);
setState(212);
_la = _input.LA(1);
if (_la==K_UNIQUE) {
{
setState(211);
match(K_UNIQUE);
}
}
setState(214);
match(K_INDEX);
setState(218);
_la = _input.LA(1);
if (_la==K_IF) {
{
setState(215);
match(K_IF);
setState(216);
match(K_NOT);
setState(217);
match(K_EXISTS);
}
}
setState(220);
index_name();
setState(221);
match(K_ON);
setState(222);
table_name();
setState(223);
match(OPEN_PAR);
setState(224);
indexed_column();
setState(229);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(225);
match(COMMA);
setState(226);
indexed_column();
}
}
setState(231);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(232);
match(CLOSE_PAR);
setState(235);
_la = _input.LA(1);
if (_la==K_WHERE) {
{
setState(233);
match(K_WHERE);
setState(234);
expr(0);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Create_table_stmtContext extends ParserRuleContext {
public TerminalNode K_CREATE() { return getToken(SqliteParser.K_CREATE, 0); }
public TerminalNode K_TABLE() { return getToken(SqliteParser.K_TABLE, 0); }
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public List column_def() {
return getRuleContexts(Column_defContext.class);
}
public Column_defContext column_def(int i) {
return getRuleContext(Column_defContext.class,i);
}
public TerminalNode K_AS() { return getToken(SqliteParser.K_AS, 0); }
public Select_stmtContext select_stmt() {
return getRuleContext(Select_stmtContext.class,0);
}
public TerminalNode K_IF() { return getToken(SqliteParser.K_IF, 0); }
public TerminalNode K_NOT() { return getToken(SqliteParser.K_NOT, 0); }
public TerminalNode K_EXISTS() { return getToken(SqliteParser.K_EXISTS, 0); }
public TerminalNode K_TEMP() { return getToken(SqliteParser.K_TEMP, 0); }
public TerminalNode K_TEMPORARY() { return getToken(SqliteParser.K_TEMPORARY, 0); }
public List table_constraint() {
return getRuleContexts(Table_constraintContext.class);
}
public Table_constraintContext table_constraint(int i) {
return getRuleContext(Table_constraintContext.class,i);
}
public TerminalNode K_WITHOUT() { return getToken(SqliteParser.K_WITHOUT, 0); }
public TerminalNode IDENTIFIER() { return getToken(SqliteParser.IDENTIFIER, 0); }
public Create_table_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_create_table_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterCreate_table_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitCreate_table_stmt(this);
}
}
public final Create_table_stmtContext create_table_stmt() throws RecognitionException {
Create_table_stmtContext _localctx = new Create_table_stmtContext(_ctx, getState());
enterRule(_localctx, 14, RULE_create_table_stmt);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(237);
match(K_CREATE);
setState(239);
_la = _input.LA(1);
if (_la==K_TEMP || _la==K_TEMPORARY) {
{
setState(238);
_la = _input.LA(1);
if ( !(_la==K_TEMP || _la==K_TEMPORARY) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
setState(241);
match(K_TABLE);
setState(245);
_la = _input.LA(1);
if (_la==K_IF) {
{
setState(242);
match(K_IF);
setState(243);
match(K_NOT);
setState(244);
match(K_EXISTS);
}
}
setState(247);
table_name();
setState(271);
switch (_input.LA(1)) {
case OPEN_PAR:
{
setState(248);
match(OPEN_PAR);
setState(249);
column_def();
setState(254);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(250);
match(COMMA);
setState(251);
column_def();
}
}
}
setState(256);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
}
setState(261);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(257);
match(COMMA);
setState(258);
table_constraint();
}
}
setState(263);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(264);
match(CLOSE_PAR);
setState(267);
_la = _input.LA(1);
if (_la==K_WITHOUT) {
{
setState(265);
match(K_WITHOUT);
setState(266);
match(IDENTIFIER);
}
}
}
break;
case K_AS:
{
setState(269);
match(K_AS);
setState(270);
select_stmt();
}
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 Create_trigger_stmtContext extends ParserRuleContext {
public TerminalNode K_CREATE() { return getToken(SqliteParser.K_CREATE, 0); }
public TerminalNode K_TRIGGER() { return getToken(SqliteParser.K_TRIGGER, 0); }
public Trigger_nameContext trigger_name() {
return getRuleContext(Trigger_nameContext.class,0);
}
public TerminalNode K_ON() { return getToken(SqliteParser.K_ON, 0); }
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public TerminalNode K_BEGIN() { return getToken(SqliteParser.K_BEGIN, 0); }
public TerminalNode K_END() { return getToken(SqliteParser.K_END, 0); }
public TerminalNode K_DELETE() { return getToken(SqliteParser.K_DELETE, 0); }
public TerminalNode K_INSERT() { return getToken(SqliteParser.K_INSERT, 0); }
public TerminalNode K_UPDATE() { return getToken(SqliteParser.K_UPDATE, 0); }
public TerminalNode K_IF() { return getToken(SqliteParser.K_IF, 0); }
public TerminalNode K_NOT() { return getToken(SqliteParser.K_NOT, 0); }
public TerminalNode K_EXISTS() { return getToken(SqliteParser.K_EXISTS, 0); }
public TerminalNode K_BEFORE() { return getToken(SqliteParser.K_BEFORE, 0); }
public TerminalNode K_AFTER() { return getToken(SqliteParser.K_AFTER, 0); }
public TerminalNode K_INSTEAD() { return getToken(SqliteParser.K_INSTEAD, 0); }
public List K_OF() { return getTokens(SqliteParser.K_OF); }
public TerminalNode K_OF(int i) {
return getToken(SqliteParser.K_OF, i);
}
public TerminalNode K_FOR() { return getToken(SqliteParser.K_FOR, 0); }
public TerminalNode K_EACH() { return getToken(SqliteParser.K_EACH, 0); }
public TerminalNode K_ROW() { return getToken(SqliteParser.K_ROW, 0); }
public TerminalNode K_WHEN() { return getToken(SqliteParser.K_WHEN, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode K_TEMP() { return getToken(SqliteParser.K_TEMP, 0); }
public TerminalNode K_TEMPORARY() { return getToken(SqliteParser.K_TEMPORARY, 0); }
public List column_name() {
return getRuleContexts(Column_nameContext.class);
}
public Column_nameContext column_name(int i) {
return getRuleContext(Column_nameContext.class,i);
}
public List update_stmt() {
return getRuleContexts(Update_stmtContext.class);
}
public Update_stmtContext update_stmt(int i) {
return getRuleContext(Update_stmtContext.class,i);
}
public List insert_stmt() {
return getRuleContexts(Insert_stmtContext.class);
}
public Insert_stmtContext insert_stmt(int i) {
return getRuleContext(Insert_stmtContext.class,i);
}
public List delete_stmt() {
return getRuleContexts(Delete_stmtContext.class);
}
public Delete_stmtContext delete_stmt(int i) {
return getRuleContext(Delete_stmtContext.class,i);
}
public List select_stmt() {
return getRuleContexts(Select_stmtContext.class);
}
public Select_stmtContext select_stmt(int i) {
return getRuleContext(Select_stmtContext.class,i);
}
public Create_trigger_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_create_trigger_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterCreate_trigger_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitCreate_trigger_stmt(this);
}
}
public final Create_trigger_stmtContext create_trigger_stmt() throws RecognitionException {
Create_trigger_stmtContext _localctx = new Create_trigger_stmtContext(_ctx, getState());
enterRule(_localctx, 16, RULE_create_trigger_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(273);
match(K_CREATE);
setState(275);
_la = _input.LA(1);
if (_la==K_TEMP || _la==K_TEMPORARY) {
{
setState(274);
_la = _input.LA(1);
if ( !(_la==K_TEMP || _la==K_TEMPORARY) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
setState(277);
match(K_TRIGGER);
setState(281);
_la = _input.LA(1);
if (_la==K_IF) {
{
setState(278);
match(K_IF);
setState(279);
match(K_NOT);
setState(280);
match(K_EXISTS);
}
}
setState(283);
trigger_name();
setState(288);
switch (_input.LA(1)) {
case K_BEFORE:
{
setState(284);
match(K_BEFORE);
}
break;
case K_AFTER:
{
setState(285);
match(K_AFTER);
}
break;
case K_INSTEAD:
{
setState(286);
match(K_INSTEAD);
setState(287);
match(K_OF);
}
break;
case K_DELETE:
case K_INSERT:
case K_UPDATE:
break;
default:
throw new NoViableAltException(this);
}
setState(304);
switch (_input.LA(1)) {
case K_DELETE:
{
setState(290);
match(K_DELETE);
}
break;
case K_INSERT:
{
setState(291);
match(K_INSERT);
}
break;
case K_UPDATE:
{
setState(292);
match(K_UPDATE);
setState(302);
_la = _input.LA(1);
if (_la==K_OF) {
{
setState(293);
match(K_OF);
setState(294);
column_name();
setState(299);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(295);
match(COMMA);
setState(296);
column_name();
}
}
setState(301);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(306);
match(K_ON);
setState(307);
table_name();
setState(311);
_la = _input.LA(1);
if (_la==K_FOR) {
{
setState(308);
match(K_FOR);
setState(309);
match(K_EACH);
setState(310);
match(K_ROW);
}
}
setState(315);
_la = _input.LA(1);
if (_la==K_WHEN) {
{
setState(313);
match(K_WHEN);
setState(314);
expr(0);
}
}
setState(317);
match(K_BEGIN);
setState(326);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(322);
switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) {
case 1:
{
setState(318);
update_stmt();
}
break;
case 2:
{
setState(319);
insert_stmt();
}
break;
case 3:
{
setState(320);
delete_stmt();
}
break;
case 4:
{
setState(321);
select_stmt();
}
break;
}
setState(324);
match(SCOL);
}
}
setState(328);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & ((1L << (K_DELETE - 73)) | (1L << (K_INSERT - 73)) | (1L << (K_REPLACE - 73)))) != 0) || ((((_la - 141)) & ~0x3f) == 0 && ((1L << (_la - 141)) & ((1L << (K_SELECT - 141)) | (1L << (K_UPDATE - 141)) | (1L << (K_VALUES - 141)) | (1L << (K_WITH - 141)))) != 0) );
setState(330);
match(K_END);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Create_view_stmtContext extends ParserRuleContext {
public TerminalNode K_CREATE() { return getToken(SqliteParser.K_CREATE, 0); }
public TerminalNode K_VIEW() { return getToken(SqliteParser.K_VIEW, 0); }
public View_nameContext view_name() {
return getRuleContext(View_nameContext.class,0);
}
public TerminalNode K_AS() { return getToken(SqliteParser.K_AS, 0); }
public Select_stmtContext select_stmt() {
return getRuleContext(Select_stmtContext.class,0);
}
public TerminalNode K_IF() { return getToken(SqliteParser.K_IF, 0); }
public TerminalNode K_NOT() { return getToken(SqliteParser.K_NOT, 0); }
public TerminalNode K_EXISTS() { return getToken(SqliteParser.K_EXISTS, 0); }
public TerminalNode K_TEMP() { return getToken(SqliteParser.K_TEMP, 0); }
public TerminalNode K_TEMPORARY() { return getToken(SqliteParser.K_TEMPORARY, 0); }
public Create_view_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_create_view_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterCreate_view_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitCreate_view_stmt(this);
}
}
public final Create_view_stmtContext create_view_stmt() throws RecognitionException {
Create_view_stmtContext _localctx = new Create_view_stmtContext(_ctx, getState());
enterRule(_localctx, 18, RULE_create_view_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(332);
match(K_CREATE);
setState(334);
_la = _input.LA(1);
if (_la==K_TEMP || _la==K_TEMPORARY) {
{
setState(333);
_la = _input.LA(1);
if ( !(_la==K_TEMP || _la==K_TEMPORARY) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
setState(336);
match(K_VIEW);
setState(340);
_la = _input.LA(1);
if (_la==K_IF) {
{
setState(337);
match(K_IF);
setState(338);
match(K_NOT);
setState(339);
match(K_EXISTS);
}
}
setState(342);
view_name();
setState(343);
match(K_AS);
setState(344);
select_stmt();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Delete_stmtContext extends ParserRuleContext {
public TerminalNode K_DELETE() { return getToken(SqliteParser.K_DELETE, 0); }
public TerminalNode K_FROM() { return getToken(SqliteParser.K_FROM, 0); }
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public With_clauseContext with_clause() {
return getRuleContext(With_clauseContext.class,0);
}
public TerminalNode K_WHERE() { return getToken(SqliteParser.K_WHERE, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public Delete_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_delete_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterDelete_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitDelete_stmt(this);
}
}
public final Delete_stmtContext delete_stmt() throws RecognitionException {
Delete_stmtContext _localctx = new Delete_stmtContext(_ctx, getState());
enterRule(_localctx, 20, RULE_delete_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(347);
_la = _input.LA(1);
if (_la==K_WITH) {
{
setState(346);
with_clause();
}
}
setState(349);
match(K_DELETE);
setState(350);
match(K_FROM);
setState(351);
table_name();
setState(354);
_la = _input.LA(1);
if (_la==K_WHERE) {
{
setState(352);
match(K_WHERE);
setState(353);
expr(0);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Delete_stmt_limitedContext extends ParserRuleContext {
public TerminalNode K_DELETE() { return getToken(SqliteParser.K_DELETE, 0); }
public TerminalNode K_FROM() { return getToken(SqliteParser.K_FROM, 0); }
public Qualified_table_nameContext qualified_table_name() {
return getRuleContext(Qualified_table_nameContext.class,0);
}
public With_clauseContext with_clause() {
return getRuleContext(With_clauseContext.class,0);
}
public TerminalNode K_WHERE() { return getToken(SqliteParser.K_WHERE, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode K_LIMIT() { return getToken(SqliteParser.K_LIMIT, 0); }
public TerminalNode K_ORDER() { return getToken(SqliteParser.K_ORDER, 0); }
public TerminalNode K_BY() { return getToken(SqliteParser.K_BY, 0); }
public List ordering_term() {
return getRuleContexts(Ordering_termContext.class);
}
public Ordering_termContext ordering_term(int i) {
return getRuleContext(Ordering_termContext.class,i);
}
public TerminalNode K_OFFSET() { return getToken(SqliteParser.K_OFFSET, 0); }
public Delete_stmt_limitedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_delete_stmt_limited; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterDelete_stmt_limited(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitDelete_stmt_limited(this);
}
}
public final Delete_stmt_limitedContext delete_stmt_limited() throws RecognitionException {
Delete_stmt_limitedContext _localctx = new Delete_stmt_limitedContext(_ctx, getState());
enterRule(_localctx, 22, RULE_delete_stmt_limited);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(357);
_la = _input.LA(1);
if (_la==K_WITH) {
{
setState(356);
with_clause();
}
}
setState(359);
match(K_DELETE);
setState(360);
match(K_FROM);
setState(361);
qualified_table_name();
setState(364);
_la = _input.LA(1);
if (_la==K_WHERE) {
{
setState(362);
match(K_WHERE);
setState(363);
expr(0);
}
}
setState(384);
_la = _input.LA(1);
if (_la==K_LIMIT || _la==K_ORDER) {
{
setState(376);
_la = _input.LA(1);
if (_la==K_ORDER) {
{
setState(366);
match(K_ORDER);
setState(367);
match(K_BY);
setState(368);
ordering_term();
setState(373);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(369);
match(COMMA);
setState(370);
ordering_term();
}
}
setState(375);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(378);
match(K_LIMIT);
setState(379);
expr(0);
setState(382);
_la = _input.LA(1);
if (_la==COMMA || _la==K_OFFSET) {
{
setState(380);
_la = _input.LA(1);
if ( !(_la==COMMA || _la==K_OFFSET) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(381);
expr(0);
}
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Drop_index_stmtContext extends ParserRuleContext {
public TerminalNode K_DROP() { return getToken(SqliteParser.K_DROP, 0); }
public TerminalNode K_INDEX() { return getToken(SqliteParser.K_INDEX, 0); }
public Index_nameContext index_name() {
return getRuleContext(Index_nameContext.class,0);
}
public TerminalNode K_IF() { return getToken(SqliteParser.K_IF, 0); }
public TerminalNode K_EXISTS() { return getToken(SqliteParser.K_EXISTS, 0); }
public Drop_index_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_drop_index_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterDrop_index_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitDrop_index_stmt(this);
}
}
public final Drop_index_stmtContext drop_index_stmt() throws RecognitionException {
Drop_index_stmtContext _localctx = new Drop_index_stmtContext(_ctx, getState());
enterRule(_localctx, 24, RULE_drop_index_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(386);
match(K_DROP);
setState(387);
match(K_INDEX);
setState(390);
_la = _input.LA(1);
if (_la==K_IF) {
{
setState(388);
match(K_IF);
setState(389);
match(K_EXISTS);
}
}
setState(392);
index_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Drop_table_stmtContext extends ParserRuleContext {
public TerminalNode K_DROP() { return getToken(SqliteParser.K_DROP, 0); }
public TerminalNode K_TABLE() { return getToken(SqliteParser.K_TABLE, 0); }
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public TerminalNode K_IF() { return getToken(SqliteParser.K_IF, 0); }
public TerminalNode K_EXISTS() { return getToken(SqliteParser.K_EXISTS, 0); }
public Drop_table_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_drop_table_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterDrop_table_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitDrop_table_stmt(this);
}
}
public final Drop_table_stmtContext drop_table_stmt() throws RecognitionException {
Drop_table_stmtContext _localctx = new Drop_table_stmtContext(_ctx, getState());
enterRule(_localctx, 26, RULE_drop_table_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(394);
match(K_DROP);
setState(395);
match(K_TABLE);
setState(398);
_la = _input.LA(1);
if (_la==K_IF) {
{
setState(396);
match(K_IF);
setState(397);
match(K_EXISTS);
}
}
setState(400);
table_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Drop_trigger_stmtContext extends ParserRuleContext {
public TerminalNode K_DROP() { return getToken(SqliteParser.K_DROP, 0); }
public TerminalNode K_TRIGGER() { return getToken(SqliteParser.K_TRIGGER, 0); }
public Trigger_nameContext trigger_name() {
return getRuleContext(Trigger_nameContext.class,0);
}
public TerminalNode K_IF() { return getToken(SqliteParser.K_IF, 0); }
public TerminalNode K_EXISTS() { return getToken(SqliteParser.K_EXISTS, 0); }
public Drop_trigger_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_drop_trigger_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterDrop_trigger_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitDrop_trigger_stmt(this);
}
}
public final Drop_trigger_stmtContext drop_trigger_stmt() throws RecognitionException {
Drop_trigger_stmtContext _localctx = new Drop_trigger_stmtContext(_ctx, getState());
enterRule(_localctx, 28, RULE_drop_trigger_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(402);
match(K_DROP);
setState(403);
match(K_TRIGGER);
setState(406);
_la = _input.LA(1);
if (_la==K_IF) {
{
setState(404);
match(K_IF);
setState(405);
match(K_EXISTS);
}
}
setState(408);
trigger_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Drop_view_stmtContext extends ParserRuleContext {
public TerminalNode K_DROP() { return getToken(SqliteParser.K_DROP, 0); }
public TerminalNode K_VIEW() { return getToken(SqliteParser.K_VIEW, 0); }
public View_nameContext view_name() {
return getRuleContext(View_nameContext.class,0);
}
public TerminalNode K_IF() { return getToken(SqliteParser.K_IF, 0); }
public TerminalNode K_EXISTS() { return getToken(SqliteParser.K_EXISTS, 0); }
public Drop_view_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_drop_view_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterDrop_view_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitDrop_view_stmt(this);
}
}
public final Drop_view_stmtContext drop_view_stmt() throws RecognitionException {
Drop_view_stmtContext _localctx = new Drop_view_stmtContext(_ctx, getState());
enterRule(_localctx, 30, RULE_drop_view_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(410);
match(K_DROP);
setState(411);
match(K_VIEW);
setState(414);
_la = _input.LA(1);
if (_la==K_IF) {
{
setState(412);
match(K_IF);
setState(413);
match(K_EXISTS);
}
}
setState(416);
view_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Insert_stmtContext extends ParserRuleContext {
public TerminalNode K_INTO() { return getToken(SqliteParser.K_INTO, 0); }
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public TerminalNode K_INSERT() { return getToken(SqliteParser.K_INSERT, 0); }
public TerminalNode K_REPLACE() { return getToken(SqliteParser.K_REPLACE, 0); }
public TerminalNode K_OR() { return getToken(SqliteParser.K_OR, 0); }
public TerminalNode K_ROLLBACK() { return getToken(SqliteParser.K_ROLLBACK, 0); }
public TerminalNode K_ABORT() { return getToken(SqliteParser.K_ABORT, 0); }
public TerminalNode K_FAIL() { return getToken(SqliteParser.K_FAIL, 0); }
public TerminalNode K_IGNORE() { return getToken(SqliteParser.K_IGNORE, 0); }
public TerminalNode K_VALUES() { return getToken(SqliteParser.K_VALUES, 0); }
public ValuesContext values() {
return getRuleContext(ValuesContext.class,0);
}
public Select_stmtContext select_stmt() {
return getRuleContext(Select_stmtContext.class,0);
}
public TerminalNode K_DEFAULT() { return getToken(SqliteParser.K_DEFAULT, 0); }
public With_clauseContext with_clause() {
return getRuleContext(With_clauseContext.class,0);
}
public List column_name() {
return getRuleContexts(Column_nameContext.class);
}
public Column_nameContext column_name(int i) {
return getRuleContext(Column_nameContext.class,i);
}
public Insert_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_insert_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterInsert_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitInsert_stmt(this);
}
}
public final Insert_stmtContext insert_stmt() throws RecognitionException {
Insert_stmtContext _localctx = new Insert_stmtContext(_ctx, getState());
enterRule(_localctx, 32, RULE_insert_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(419);
_la = _input.LA(1);
if (_la==K_WITH) {
{
setState(418);
with_clause();
}
}
setState(438);
switch ( getInterpreter().adaptivePredict(_input,43,_ctx) ) {
case 1:
{
setState(421);
match(K_INSERT);
}
break;
case 2:
{
setState(422);
match(K_REPLACE);
}
break;
case 3:
{
setState(423);
match(K_INSERT);
setState(424);
match(K_OR);
setState(425);
match(K_REPLACE);
}
break;
case 4:
{
setState(426);
match(K_INSERT);
setState(427);
match(K_OR);
setState(428);
match(K_ROLLBACK);
}
break;
case 5:
{
setState(429);
match(K_INSERT);
setState(430);
match(K_OR);
setState(431);
match(K_ABORT);
}
break;
case 6:
{
setState(432);
match(K_INSERT);
setState(433);
match(K_OR);
setState(434);
match(K_FAIL);
}
break;
case 7:
{
setState(435);
match(K_INSERT);
setState(436);
match(K_OR);
setState(437);
match(K_IGNORE);
}
break;
}
setState(440);
match(K_INTO);
setState(441);
table_name();
setState(453);
_la = _input.LA(1);
if (_la==OPEN_PAR) {
{
setState(442);
match(OPEN_PAR);
setState(443);
column_name();
setState(448);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(444);
match(COMMA);
setState(445);
column_name();
}
}
setState(450);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(451);
match(CLOSE_PAR);
}
}
setState(460);
switch ( getInterpreter().adaptivePredict(_input,46,_ctx) ) {
case 1:
{
setState(455);
match(K_VALUES);
setState(456);
values();
}
break;
case 2:
{
setState(457);
select_stmt();
}
break;
case 3:
{
setState(458);
match(K_DEFAULT);
setState(459);
match(K_VALUES);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Pragma_stmtContext extends ParserRuleContext {
public TerminalNode K_PRAGMA() { return getToken(SqliteParser.K_PRAGMA, 0); }
public Pragma_nameContext pragma_name() {
return getRuleContext(Pragma_nameContext.class,0);
}
public Pragma_valueContext pragma_value() {
return getRuleContext(Pragma_valueContext.class,0);
}
public Pragma_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pragma_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterPragma_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitPragma_stmt(this);
}
}
public final Pragma_stmtContext pragma_stmt() throws RecognitionException {
Pragma_stmtContext _localctx = new Pragma_stmtContext(_ctx, getState());
enterRule(_localctx, 34, RULE_pragma_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(462);
match(K_PRAGMA);
setState(463);
pragma_name();
setState(470);
switch (_input.LA(1)) {
case ASSIGN:
{
setState(464);
match(ASSIGN);
setState(465);
pragma_value();
}
break;
case OPEN_PAR:
{
setState(466);
match(OPEN_PAR);
setState(467);
pragma_value();
setState(468);
match(CLOSE_PAR);
}
break;
case SCOL:
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 Reindex_stmtContext extends ParserRuleContext {
public TerminalNode K_REINDEX() { return getToken(SqliteParser.K_REINDEX, 0); }
public Collation_nameContext collation_name() {
return getRuleContext(Collation_nameContext.class,0);
}
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public Index_nameContext index_name() {
return getRuleContext(Index_nameContext.class,0);
}
public Reindex_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_reindex_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterReindex_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitReindex_stmt(this);
}
}
public final Reindex_stmtContext reindex_stmt() throws RecognitionException {
Reindex_stmtContext _localctx = new Reindex_stmtContext(_ctx, getState());
enterRule(_localctx, 36, RULE_reindex_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(472);
match(K_REINDEX);
setState(478);
switch ( getInterpreter().adaptivePredict(_input,49,_ctx) ) {
case 1:
{
setState(473);
collation_name();
}
break;
case 2:
{
setState(476);
switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) {
case 1:
{
setState(474);
table_name();
}
break;
case 2:
{
setState(475);
index_name();
}
break;
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Release_stmtContext extends ParserRuleContext {
public TerminalNode K_RELEASE() { return getToken(SqliteParser.K_RELEASE, 0); }
public Savepoint_nameContext savepoint_name() {
return getRuleContext(Savepoint_nameContext.class,0);
}
public TerminalNode K_SAVEPOINT() { return getToken(SqliteParser.K_SAVEPOINT, 0); }
public Release_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_release_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterRelease_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitRelease_stmt(this);
}
}
public final Release_stmtContext release_stmt() throws RecognitionException {
Release_stmtContext _localctx = new Release_stmtContext(_ctx, getState());
enterRule(_localctx, 38, RULE_release_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(480);
match(K_RELEASE);
setState(482);
_la = _input.LA(1);
if (_la==K_SAVEPOINT) {
{
setState(481);
match(K_SAVEPOINT);
}
}
setState(484);
savepoint_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Savepoint_stmtContext extends ParserRuleContext {
public TerminalNode K_SAVEPOINT() { return getToken(SqliteParser.K_SAVEPOINT, 0); }
public Savepoint_nameContext savepoint_name() {
return getRuleContext(Savepoint_nameContext.class,0);
}
public Savepoint_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_savepoint_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterSavepoint_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitSavepoint_stmt(this);
}
}
public final Savepoint_stmtContext savepoint_stmt() throws RecognitionException {
Savepoint_stmtContext _localctx = new Savepoint_stmtContext(_ctx, getState());
enterRule(_localctx, 40, RULE_savepoint_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(486);
match(K_SAVEPOINT);
setState(487);
savepoint_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Select_stmtContext extends ParserRuleContext {
public List select_or_values() {
return getRuleContexts(Select_or_valuesContext.class);
}
public Select_or_valuesContext select_or_values(int i) {
return getRuleContext(Select_or_valuesContext.class,i);
}
public With_clauseContext with_clause() {
return getRuleContext(With_clauseContext.class,0);
}
public List compound_operator() {
return getRuleContexts(Compound_operatorContext.class);
}
public Compound_operatorContext compound_operator(int i) {
return getRuleContext(Compound_operatorContext.class,i);
}
public TerminalNode K_ORDER() { return getToken(SqliteParser.K_ORDER, 0); }
public TerminalNode K_BY() { return getToken(SqliteParser.K_BY, 0); }
public List ordering_term() {
return getRuleContexts(Ordering_termContext.class);
}
public Ordering_termContext ordering_term(int i) {
return getRuleContext(Ordering_termContext.class,i);
}
public TerminalNode K_LIMIT() { return getToken(SqliteParser.K_LIMIT, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode K_OFFSET() { return getToken(SqliteParser.K_OFFSET, 0); }
public Select_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_select_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterSelect_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitSelect_stmt(this);
}
}
public final Select_stmtContext select_stmt() throws RecognitionException {
Select_stmtContext _localctx = new Select_stmtContext(_ctx, getState());
enterRule(_localctx, 42, RULE_select_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(490);
_la = _input.LA(1);
if (_la==K_WITH) {
{
setState(489);
with_clause();
}
}
setState(492);
select_or_values();
setState(498);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==K_EXCEPT || _la==K_INTERSECT || _la==K_UNION) {
{
{
setState(493);
compound_operator();
setState(494);
select_or_values();
}
}
setState(500);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(511);
_la = _input.LA(1);
if (_la==K_ORDER) {
{
setState(501);
match(K_ORDER);
setState(502);
match(K_BY);
setState(503);
ordering_term();
setState(508);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(504);
match(COMMA);
setState(505);
ordering_term();
}
}
setState(510);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(519);
_la = _input.LA(1);
if (_la==K_LIMIT) {
{
setState(513);
match(K_LIMIT);
setState(514);
expr(0);
setState(517);
_la = _input.LA(1);
if (_la==COMMA || _la==K_OFFSET) {
{
setState(515);
_la = _input.LA(1);
if ( !(_la==COMMA || _la==K_OFFSET) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(516);
expr(0);
}
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Select_or_valuesContext extends ParserRuleContext {
public TerminalNode K_SELECT() { return getToken(SqliteParser.K_SELECT, 0); }
public List result_column() {
return getRuleContexts(Result_columnContext.class);
}
public Result_columnContext result_column(int i) {
return getRuleContext(Result_columnContext.class,i);
}
public TerminalNode K_FROM() { return getToken(SqliteParser.K_FROM, 0); }
public TerminalNode K_WHERE() { return getToken(SqliteParser.K_WHERE, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode K_GROUP() { return getToken(SqliteParser.K_GROUP, 0); }
public TerminalNode K_BY() { return getToken(SqliteParser.K_BY, 0); }
public TerminalNode K_DISTINCT() { return getToken(SqliteParser.K_DISTINCT, 0); }
public TerminalNode K_ALL() { return getToken(SqliteParser.K_ALL, 0); }
public List table_or_subquery() {
return getRuleContexts(Table_or_subqueryContext.class);
}
public Table_or_subqueryContext table_or_subquery(int i) {
return getRuleContext(Table_or_subqueryContext.class,i);
}
public Join_clauseContext join_clause() {
return getRuleContext(Join_clauseContext.class,0);
}
public TerminalNode K_HAVING() { return getToken(SqliteParser.K_HAVING, 0); }
public TerminalNode K_VALUES() { return getToken(SqliteParser.K_VALUES, 0); }
public ValuesContext values() {
return getRuleContext(ValuesContext.class,0);
}
public Select_or_valuesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_select_or_values; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterSelect_or_values(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitSelect_or_values(this);
}
}
public final Select_or_valuesContext select_or_values() throws RecognitionException {
Select_or_valuesContext _localctx = new Select_or_valuesContext(_ctx, getState());
enterRule(_localctx, 44, RULE_select_or_values);
int _la;
try {
setState(569);
switch (_input.LA(1)) {
case K_SELECT:
enterOuterAlt(_localctx, 1);
{
setState(521);
match(K_SELECT);
setState(523);
_la = _input.LA(1);
if (_la==K_ALL || _la==K_DISTINCT) {
{
setState(522);
_la = _input.LA(1);
if ( !(_la==K_ALL || _la==K_DISTINCT) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
setState(525);
result_column();
setState(530);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(526);
match(COMMA);
setState(527);
result_column();
}
}
setState(532);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(545);
_la = _input.LA(1);
if (_la==K_FROM) {
{
setState(533);
match(K_FROM);
setState(543);
switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) {
case 1:
{
setState(534);
table_or_subquery();
setState(539);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(535);
match(COMMA);
setState(536);
table_or_subquery();
}
}
setState(541);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case 2:
{
setState(542);
join_clause();
}
break;
}
}
}
setState(549);
_la = _input.LA(1);
if (_la==K_WHERE) {
{
setState(547);
match(K_WHERE);
setState(548);
expr(0);
}
}
setState(565);
_la = _input.LA(1);
if (_la==K_GROUP) {
{
setState(551);
match(K_GROUP);
setState(552);
match(K_BY);
setState(553);
expr(0);
setState(558);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(554);
match(COMMA);
setState(555);
expr(0);
}
}
setState(560);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(563);
_la = _input.LA(1);
if (_la==K_HAVING) {
{
setState(561);
match(K_HAVING);
setState(562);
expr(0);
}
}
}
}
}
break;
case K_VALUES:
enterOuterAlt(_localctx, 2);
{
setState(567);
match(K_VALUES);
setState(568);
values();
}
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 ValuesContext extends ParserRuleContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public ValuesContext values() {
return getRuleContext(ValuesContext.class,0);
}
public ValuesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_values; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterValues(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitValues(this);
}
}
public final ValuesContext values() throws RecognitionException {
ValuesContext _localctx = new ValuesContext(_ctx, getState());
enterRule(_localctx, 46, RULE_values);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(571);
match(OPEN_PAR);
setState(572);
expr(0);
setState(577);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(573);
match(COMMA);
setState(574);
expr(0);
}
}
setState(579);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(580);
match(CLOSE_PAR);
setState(583);
_la = _input.LA(1);
if (_la==COMMA) {
{
setState(581);
match(COMMA);
setState(582);
values();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Update_stmtContext extends ParserRuleContext {
public TerminalNode K_UPDATE() { return getToken(SqliteParser.K_UPDATE, 0); }
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public TerminalNode K_SET() { return getToken(SqliteParser.K_SET, 0); }
public List column_name() {
return getRuleContexts(Column_nameContext.class);
}
public Column_nameContext column_name(int i) {
return getRuleContext(Column_nameContext.class,i);
}
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public With_clauseContext with_clause() {
return getRuleContext(With_clauseContext.class,0);
}
public TerminalNode K_OR() { return getToken(SqliteParser.K_OR, 0); }
public TerminalNode K_ROLLBACK() { return getToken(SqliteParser.K_ROLLBACK, 0); }
public TerminalNode K_ABORT() { return getToken(SqliteParser.K_ABORT, 0); }
public TerminalNode K_REPLACE() { return getToken(SqliteParser.K_REPLACE, 0); }
public TerminalNode K_FAIL() { return getToken(SqliteParser.K_FAIL, 0); }
public TerminalNode K_IGNORE() { return getToken(SqliteParser.K_IGNORE, 0); }
public TerminalNode K_WHERE() { return getToken(SqliteParser.K_WHERE, 0); }
public Update_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_update_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterUpdate_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitUpdate_stmt(this);
}
}
public final Update_stmtContext update_stmt() throws RecognitionException {
Update_stmtContext _localctx = new Update_stmtContext(_ctx, getState());
enterRule(_localctx, 48, RULE_update_stmt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(586);
_la = _input.LA(1);
if (_la==K_WITH) {
{
setState(585);
with_clause();
}
}
setState(588);
match(K_UPDATE);
setState(599);
switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) {
case 1:
{
setState(589);
match(K_OR);
setState(590);
match(K_ROLLBACK);
}
break;
case 2:
{
setState(591);
match(K_OR);
setState(592);
match(K_ABORT);
}
break;
case 3:
{
setState(593);
match(K_OR);
setState(594);
match(K_REPLACE);
}
break;
case 4:
{
setState(595);
match(K_OR);
setState(596);
match(K_FAIL);
}
break;
case 5:
{
setState(597);
match(K_OR);
setState(598);
match(K_IGNORE);
}
break;
}
setState(601);
table_name();
setState(602);
match(K_SET);
setState(603);
column_name();
setState(604);
match(ASSIGN);
setState(605);
expr(0);
setState(613);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(606);
match(COMMA);
setState(607);
column_name();
setState(608);
match(ASSIGN);
setState(609);
expr(0);
}
}
setState(615);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(618);
_la = _input.LA(1);
if (_la==K_WHERE) {
{
setState(616);
match(K_WHERE);
setState(617);
expr(0);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Update_stmt_limitedContext extends ParserRuleContext {
public TerminalNode K_UPDATE() { return getToken(SqliteParser.K_UPDATE, 0); }
public Qualified_table_nameContext qualified_table_name() {
return getRuleContext(Qualified_table_nameContext.class,0);
}
public TerminalNode K_SET() { return getToken(SqliteParser.K_SET, 0); }
public List column_name() {
return getRuleContexts(Column_nameContext.class);
}
public Column_nameContext column_name(int i) {
return getRuleContext(Column_nameContext.class,i);
}
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public With_clauseContext with_clause() {
return getRuleContext(With_clauseContext.class,0);
}
public TerminalNode K_OR() { return getToken(SqliteParser.K_OR, 0); }
public TerminalNode K_ROLLBACK() { return getToken(SqliteParser.K_ROLLBACK, 0); }
public TerminalNode K_ABORT() { return getToken(SqliteParser.K_ABORT, 0); }
public TerminalNode K_REPLACE() { return getToken(SqliteParser.K_REPLACE, 0); }
public TerminalNode K_FAIL() { return getToken(SqliteParser.K_FAIL, 0); }
public TerminalNode K_IGNORE() { return getToken(SqliteParser.K_IGNORE, 0); }
public TerminalNode K_WHERE() { return getToken(SqliteParser.K_WHERE, 0); }
public TerminalNode K_LIMIT() { return getToken(SqliteParser.K_LIMIT, 0); }
public TerminalNode K_ORDER() { return getToken(SqliteParser.K_ORDER, 0); }
public TerminalNode K_BY() { return getToken(SqliteParser.K_BY, 0); }
public List ordering_term() {
return getRuleContexts(Ordering_termContext.class);
}
public Ordering_termContext ordering_term(int i) {
return getRuleContext(Ordering_termContext.class,i);
}
public TerminalNode K_OFFSET() { return getToken(SqliteParser.K_OFFSET, 0); }
public Update_stmt_limitedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_update_stmt_limited; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterUpdate_stmt_limited(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitUpdate_stmt_limited(this);
}
}
public final Update_stmt_limitedContext update_stmt_limited() throws RecognitionException {
Update_stmt_limitedContext _localctx = new Update_stmt_limitedContext(_ctx, getState());
enterRule(_localctx, 50, RULE_update_stmt_limited);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(621);
_la = _input.LA(1);
if (_la==K_WITH) {
{
setState(620);
with_clause();
}
}
setState(623);
match(K_UPDATE);
setState(634);
switch ( getInterpreter().adaptivePredict(_input,74,_ctx) ) {
case 1:
{
setState(624);
match(K_OR);
setState(625);
match(K_ROLLBACK);
}
break;
case 2:
{
setState(626);
match(K_OR);
setState(627);
match(K_ABORT);
}
break;
case 3:
{
setState(628);
match(K_OR);
setState(629);
match(K_REPLACE);
}
break;
case 4:
{
setState(630);
match(K_OR);
setState(631);
match(K_FAIL);
}
break;
case 5:
{
setState(632);
match(K_OR);
setState(633);
match(K_IGNORE);
}
break;
}
setState(636);
qualified_table_name();
setState(637);
match(K_SET);
setState(638);
column_name();
setState(639);
match(ASSIGN);
setState(640);
expr(0);
setState(648);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(641);
match(COMMA);
setState(642);
column_name();
setState(643);
match(ASSIGN);
setState(644);
expr(0);
}
}
setState(650);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(653);
_la = _input.LA(1);
if (_la==K_WHERE) {
{
setState(651);
match(K_WHERE);
setState(652);
expr(0);
}
}
setState(673);
_la = _input.LA(1);
if (_la==K_LIMIT || _la==K_ORDER) {
{
setState(665);
_la = _input.LA(1);
if (_la==K_ORDER) {
{
setState(655);
match(K_ORDER);
setState(656);
match(K_BY);
setState(657);
ordering_term();
setState(662);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(658);
match(COMMA);
setState(659);
ordering_term();
}
}
setState(664);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(667);
match(K_LIMIT);
setState(668);
expr(0);
setState(671);
_la = _input.LA(1);
if (_la==COMMA || _la==K_OFFSET) {
{
setState(669);
_la = _input.LA(1);
if ( !(_la==COMMA || _la==K_OFFSET) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(670);
expr(0);
}
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Vacuum_stmtContext extends ParserRuleContext {
public TerminalNode K_VACUUM() { return getToken(SqliteParser.K_VACUUM, 0); }
public Vacuum_stmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_vacuum_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterVacuum_stmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitVacuum_stmt(this);
}
}
public final Vacuum_stmtContext vacuum_stmt() throws RecognitionException {
Vacuum_stmtContext _localctx = new Vacuum_stmtContext(_ctx, getState());
enterRule(_localctx, 52, RULE_vacuum_stmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(675);
match(K_VACUUM);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Column_defContext extends ParserRuleContext {
public Column_nameContext column_name() {
return getRuleContext(Column_nameContext.class,0);
}
public Type_nameContext type_name() {
return getRuleContext(Type_nameContext.class,0);
}
public List column_constraint() {
return getRuleContexts(Column_constraintContext.class);
}
public Column_constraintContext column_constraint(int i) {
return getRuleContext(Column_constraintContext.class,i);
}
public Column_defContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_column_def; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterColumn_def(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitColumn_def(this);
}
}
public final Column_defContext column_def() throws RecognitionException {
Column_defContext _localctx = new Column_defContext(_ctx, getState());
enterRule(_localctx, 54, RULE_column_def);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(677);
column_name();
setState(678);
type_name();
setState(682);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 58)) & ~0x3f) == 0 && ((1L << (_la - 58)) & ((1L << (K_CHECK - 58)) | (1L << (K_COLLATE - 58)) | (1L << (K_CONSTRAINT - 58)) | (1L << (K_DEFAULT - 58)) | (1L << (K_NOT - 58)) | (1L << (K_NULL - 58)))) != 0) || ((((_la - 126)) & ~0x3f) == 0 && ((1L << (_la - 126)) & ((1L << (K_PRIMARY_KEY - 126)) | (1L << (K_REFERENCES - 126)) | (1L << (K_UNIQUE - 126)))) != 0)) {
{
{
setState(679);
column_constraint();
}
}
setState(684);
_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 Type_nameContext extends ParserRuleContext {
public Sqlite_type_nameContext sqlite_type_name() {
return getRuleContext(Sqlite_type_nameContext.class,0);
}
public List signed_number() {
return getRuleContexts(Signed_numberContext.class);
}
public Signed_numberContext signed_number(int i) {
return getRuleContext(Signed_numberContext.class,i);
}
public TerminalNode K_AS() { return getToken(SqliteParser.K_AS, 0); }
public Java_type_nameContext java_type_name() {
return getRuleContext(Java_type_nameContext.class,0);
}
public Type_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_type_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterType_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitType_name(this);
}
}
public final Type_nameContext type_name() throws RecognitionException {
Type_nameContext _localctx = new Type_nameContext(_ctx, getState());
enterRule(_localctx, 56, RULE_type_name);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(685);
sqlite_type_name();
setState(696);
switch ( getInterpreter().adaptivePredict(_input,82,_ctx) ) {
case 1:
{
setState(686);
match(OPEN_PAR);
setState(687);
signed_number();
setState(688);
match(CLOSE_PAR);
}
break;
case 2:
{
setState(690);
match(OPEN_PAR);
setState(691);
signed_number();
setState(692);
match(COMMA);
setState(693);
signed_number();
setState(694);
match(CLOSE_PAR);
}
break;
}
setState(700);
_la = _input.LA(1);
if (_la==K_AS) {
{
setState(698);
match(K_AS);
setState(699);
java_type_name();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Column_constraintContext extends ParserRuleContext {
public TerminalNode K_PRIMARY_KEY() { return getToken(SqliteParser.K_PRIMARY_KEY, 0); }
public Conflict_clauseContext conflict_clause() {
return getRuleContext(Conflict_clauseContext.class,0);
}
public TerminalNode K_NULL() { return getToken(SqliteParser.K_NULL, 0); }
public TerminalNode K_UNIQUE() { return getToken(SqliteParser.K_UNIQUE, 0); }
public TerminalNode K_CHECK() { return getToken(SqliteParser.K_CHECK, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode K_DEFAULT() { return getToken(SqliteParser.K_DEFAULT, 0); }
public TerminalNode K_COLLATE() { return getToken(SqliteParser.K_COLLATE, 0); }
public Collation_nameContext collation_name() {
return getRuleContext(Collation_nameContext.class,0);
}
public Foreign_key_clauseContext foreign_key_clause() {
return getRuleContext(Foreign_key_clauseContext.class,0);
}
public TerminalNode K_CONSTRAINT() { return getToken(SqliteParser.K_CONSTRAINT, 0); }
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public Signed_numberContext signed_number() {
return getRuleContext(Signed_numberContext.class,0);
}
public Literal_valueContext literal_value() {
return getRuleContext(Literal_valueContext.class,0);
}
public TerminalNode K_AUTOINCREMENT() { return getToken(SqliteParser.K_AUTOINCREMENT, 0); }
public TerminalNode K_NOT() { return getToken(SqliteParser.K_NOT, 0); }
public TerminalNode K_ASC() { return getToken(SqliteParser.K_ASC, 0); }
public TerminalNode K_DESC() { return getToken(SqliteParser.K_DESC, 0); }
public Column_constraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_column_constraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterColumn_constraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitColumn_constraint(this);
}
}
public final Column_constraintContext column_constraint() throws RecognitionException {
Column_constraintContext _localctx = new Column_constraintContext(_ctx, getState());
enterRule(_localctx, 58, RULE_column_constraint);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(704);
_la = _input.LA(1);
if (_la==K_CONSTRAINT) {
{
setState(702);
match(K_CONSTRAINT);
setState(703);
name();
}
}
setState(738);
switch (_input.LA(1)) {
case K_PRIMARY_KEY:
{
setState(706);
match(K_PRIMARY_KEY);
setState(708);
_la = _input.LA(1);
if (_la==K_ASC || _la==K_DESC) {
{
setState(707);
_la = _input.LA(1);
if ( !(_la==K_ASC || _la==K_DESC) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
setState(710);
conflict_clause();
setState(712);
_la = _input.LA(1);
if (_la==K_AUTOINCREMENT) {
{
setState(711);
match(K_AUTOINCREMENT);
}
}
}
break;
case K_NOT:
case K_NULL:
{
setState(715);
_la = _input.LA(1);
if (_la==K_NOT) {
{
setState(714);
match(K_NOT);
}
}
setState(717);
match(K_NULL);
setState(718);
conflict_clause();
}
break;
case K_UNIQUE:
{
setState(719);
match(K_UNIQUE);
setState(720);
conflict_clause();
}
break;
case K_CHECK:
{
setState(721);
match(K_CHECK);
setState(722);
match(OPEN_PAR);
setState(723);
expr(0);
setState(724);
match(CLOSE_PAR);
}
break;
case K_DEFAULT:
{
setState(726);
match(K_DEFAULT);
setState(733);
switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) {
case 1:
{
setState(727);
signed_number();
}
break;
case 2:
{
setState(728);
literal_value();
}
break;
case 3:
{
setState(729);
match(OPEN_PAR);
setState(730);
expr(0);
setState(731);
match(CLOSE_PAR);
}
break;
}
}
break;
case K_COLLATE:
{
setState(735);
match(K_COLLATE);
setState(736);
collation_name();
}
break;
case K_REFERENCES:
{
setState(737);
foreign_key_clause();
}
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 Conflict_clauseContext extends ParserRuleContext {
public TerminalNode K_ON() { return getToken(SqliteParser.K_ON, 0); }
public TerminalNode K_CONFLICT() { return getToken(SqliteParser.K_CONFLICT, 0); }
public TerminalNode K_ROLLBACK() { return getToken(SqliteParser.K_ROLLBACK, 0); }
public TerminalNode K_ABORT() { return getToken(SqliteParser.K_ABORT, 0); }
public TerminalNode K_FAIL() { return getToken(SqliteParser.K_FAIL, 0); }
public TerminalNode K_IGNORE() { return getToken(SqliteParser.K_IGNORE, 0); }
public TerminalNode K_REPLACE() { return getToken(SqliteParser.K_REPLACE, 0); }
public Conflict_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_conflict_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterConflict_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitConflict_clause(this);
}
}
public final Conflict_clauseContext conflict_clause() throws RecognitionException {
Conflict_clauseContext _localctx = new Conflict_clauseContext(_ctx, getState());
enterRule(_localctx, 60, RULE_conflict_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(743);
_la = _input.LA(1);
if (_la==K_ON) {
{
setState(740);
match(K_ON);
setState(741);
match(K_CONFLICT);
setState(742);
_la = _input.LA(1);
if ( !(_la==K_ABORT || ((((_la - 86)) & ~0x3f) == 0 && ((1L << (_la - 86)) & ((1L << (K_FAIL - 86)) | (1L << (K_IGNORE - 86)) | (1L << (K_REPLACE - 86)) | (1L << (K_ROLLBACK - 86)))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExprContext extends ParserRuleContext {
public Unary_operatorContext unary_operator() {
return getRuleContext(Unary_operatorContext.class,0);
}
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public Literal_valueContext literal_value() {
return getRuleContext(Literal_valueContext.class,0);
}
public TerminalNode BIND_PARAMETER() { return getToken(SqliteParser.BIND_PARAMETER, 0); }
public Column_nameContext column_name() {
return getRuleContext(Column_nameContext.class,0);
}
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public Function_nameContext function_name() {
return getRuleContext(Function_nameContext.class,0);
}
public TerminalNode K_DISTINCT() { return getToken(SqliteParser.K_DISTINCT, 0); }
public TerminalNode OPEN_PAR() { return getToken(SqliteParser.OPEN_PAR, 0); }
public TerminalNode CLOSE_PAR() { return getToken(SqliteParser.CLOSE_PAR, 0); }
public TerminalNode K_CAST() { return getToken(SqliteParser.K_CAST, 0); }
public TerminalNode K_AS() { return getToken(SqliteParser.K_AS, 0); }
public Type_nameContext type_name() {
return getRuleContext(Type_nameContext.class,0);
}
public Select_stmtContext select_stmt() {
return getRuleContext(Select_stmtContext.class,0);
}
public TerminalNode K_EXISTS() { return getToken(SqliteParser.K_EXISTS, 0); }
public TerminalNode K_NOT() { return getToken(SqliteParser.K_NOT, 0); }
public TerminalNode K_CASE() { return getToken(SqliteParser.K_CASE, 0); }
public TerminalNode K_END() { return getToken(SqliteParser.K_END, 0); }
public List K_WHEN() { return getTokens(SqliteParser.K_WHEN); }
public TerminalNode K_WHEN(int i) {
return getToken(SqliteParser.K_WHEN, i);
}
public List K_THEN() { return getTokens(SqliteParser.K_THEN); }
public TerminalNode K_THEN(int i) {
return getToken(SqliteParser.K_THEN, i);
}
public TerminalNode K_ELSE() { return getToken(SqliteParser.K_ELSE, 0); }
public Raise_functionContext raise_function() {
return getRuleContext(Raise_functionContext.class,0);
}
public TerminalNode K_AND() { return getToken(SqliteParser.K_AND, 0); }
public TerminalNode K_OR() { return getToken(SqliteParser.K_OR, 0); }
public TerminalNode K_IS() { return getToken(SqliteParser.K_IS, 0); }
public TerminalNode K_BETWEEN() { return getToken(SqliteParser.K_BETWEEN, 0); }
public TerminalNode K_COLLATE() { return getToken(SqliteParser.K_COLLATE, 0); }
public Collation_nameContext collation_name() {
return getRuleContext(Collation_nameContext.class,0);
}
public TerminalNode K_LIKE() { return getToken(SqliteParser.K_LIKE, 0); }
public TerminalNode K_GLOB() { return getToken(SqliteParser.K_GLOB, 0); }
public TerminalNode K_REGEXP() { return getToken(SqliteParser.K_REGEXP, 0); }
public TerminalNode K_MATCH() { return getToken(SqliteParser.K_MATCH, 0); }
public TerminalNode K_ESCAPE() { return getToken(SqliteParser.K_ESCAPE, 0); }
public TerminalNode K_ISNULL() { return getToken(SqliteParser.K_ISNULL, 0); }
public TerminalNode K_NOTNULL() { return getToken(SqliteParser.K_NOTNULL, 0); }
public TerminalNode K_NULL() { return getToken(SqliteParser.K_NULL, 0); }
public TerminalNode K_IN() { return getToken(SqliteParser.K_IN, 0); }
public ExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitExpr(this);
}
}
public final ExprContext expr() throws RecognitionException {
return expr(0);
}
private ExprContext expr(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ExprContext _localctx = new ExprContext(_ctx, _parentState);
ExprContext _prevctx = _localctx;
int _startState = 62;
enterRecursionRule(_localctx, 62, RULE_expr, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(816);
switch ( getInterpreter().adaptivePredict(_input,100,_ctx) ) {
case 1:
{
setState(746);
unary_operator();
setState(747);
expr(21);
}
break;
case 2:
{
setState(749);
literal_value();
}
break;
case 3:
{
setState(750);
match(BIND_PARAMETER);
}
break;
case 4:
{
setState(754);
switch ( getInterpreter().adaptivePredict(_input,91,_ctx) ) {
case 1:
{
setState(751);
table_name();
setState(752);
match(DOT);
}
break;
}
setState(756);
column_name();
}
break;
case 5:
{
setState(757);
function_name();
setState(758);
match(OPEN_PAR);
setState(771);
switch (_input.LA(1)) {
case T__1:
case OPEN_PAR:
case PLUS:
case MINUS:
case TILDE:
case K_CASE:
case K_CAST:
case K_CURRENT_DATE:
case K_CURRENT_TIME:
case K_CURRENT_TIMESTAMP:
case K_DISTINCT:
case K_EXISTS:
case K_NOT:
case K_NULL:
case K_RAISE:
case IDENTIFIER:
case NUMERIC_LITERAL:
case BIND_PARAMETER:
case STRING_LITERAL:
case BLOB_LITERAL:
{
setState(760);
_la = _input.LA(1);
if (_la==K_DISTINCT) {
{
setState(759);
match(K_DISTINCT);
}
}
setState(762);
expr(0);
setState(767);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(763);
match(COMMA);
setState(764);
expr(0);
}
}
setState(769);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case STAR:
{
setState(770);
match(STAR);
}
break;
case CLOSE_PAR:
break;
default:
throw new NoViableAltException(this);
}
setState(773);
match(CLOSE_PAR);
}
break;
case 6:
{
setState(775);
match(OPEN_PAR);
setState(776);
expr(0);
setState(777);
match(CLOSE_PAR);
}
break;
case 7:
{
setState(779);
match(K_CAST);
setState(780);
match(OPEN_PAR);
setState(781);
expr(0);
setState(782);
match(K_AS);
setState(783);
type_name();
setState(784);
match(CLOSE_PAR);
}
break;
case 8:
{
setState(790);
_la = _input.LA(1);
if (_la==K_EXISTS || _la==K_NOT) {
{
setState(787);
_la = _input.LA(1);
if (_la==K_NOT) {
{
setState(786);
match(K_NOT);
}
}
setState(789);
match(K_EXISTS);
}
}
setState(792);
match(OPEN_PAR);
setState(793);
select_stmt();
setState(794);
match(CLOSE_PAR);
}
break;
case 9:
{
setState(796);
match(K_CASE);
setState(798);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__1) | (1L << OPEN_PAR) | (1L << PLUS) | (1L << MINUS) | (1L << TILDE) | (1L << K_CASE) | (1L << K_CAST))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (K_CURRENT_DATE - 66)) | (1L << (K_CURRENT_TIME - 66)) | (1L << (K_CURRENT_TIMESTAMP - 66)) | (1L << (K_EXISTS - 66)) | (1L << (K_NOT - 66)) | (1L << (K_NULL - 66)) | (1L << (K_RAISE - 66)))) != 0) || ((((_la - 161)) & ~0x3f) == 0 && ((1L << (_la - 161)) & ((1L << (IDENTIFIER - 161)) | (1L << (NUMERIC_LITERAL - 161)) | (1L << (BIND_PARAMETER - 161)) | (1L << (STRING_LITERAL - 161)) | (1L << (BLOB_LITERAL - 161)))) != 0)) {
{
setState(797);
expr(0);
}
}
setState(805);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(800);
match(K_WHEN);
setState(801);
expr(0);
setState(802);
match(K_THEN);
setState(803);
expr(0);
}
}
setState(807);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==K_WHEN );
setState(811);
_la = _input.LA(1);
if (_la==K_ELSE) {
{
setState(809);
match(K_ELSE);
setState(810);
expr(0);
}
}
setState(813);
match(K_END);
}
break;
case 10:
{
setState(815);
raise_function();
}
break;
}
_ctx.stop = _input.LT(-1);
setState(900);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,111,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(898);
switch ( getInterpreter().adaptivePredict(_input,110,_ctx) ) {
case 1:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(818);
if (!(precpred(_ctx, 20))) throw new FailedPredicateException(this, "precpred(_ctx, 20)");
setState(819);
match(PIPE2);
setState(820);
expr(21);
}
break;
case 2:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(821);
if (!(precpred(_ctx, 19))) throw new FailedPredicateException(this, "precpred(_ctx, 19)");
setState(822);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STAR) | (1L << DIV) | (1L << MOD))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(823);
expr(20);
}
break;
case 3:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(824);
if (!(precpred(_ctx, 18))) throw new FailedPredicateException(this, "precpred(_ctx, 18)");
setState(825);
_la = _input.LA(1);
if ( !(_la==PLUS || _la==MINUS) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(826);
expr(19);
}
break;
case 4:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(827);
if (!(precpred(_ctx, 17))) throw new FailedPredicateException(this, "precpred(_ctx, 17)");
setState(828);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LT2) | (1L << GT2) | (1L << AMP) | (1L << PIPE))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(829);
expr(18);
}
break;
case 5:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(830);
if (!(precpred(_ctx, 16))) throw new FailedPredicateException(this, "precpred(_ctx, 16)");
setState(831);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LT) | (1L << LT_EQ) | (1L << GT) | (1L << GT_EQ))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(832);
expr(17);
}
break;
case 6:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(833);
if (!(precpred(_ctx, 15))) throw new FailedPredicateException(this, "precpred(_ctx, 15)");
setState(834);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ASSIGN) | (1L << EQ) | (1L << NOT_EQ1) | (1L << NOT_EQ2))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(835);
expr(16);
}
break;
case 7:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(836);
if (!(precpred(_ctx, 14))) throw new FailedPredicateException(this, "precpred(_ctx, 14)");
setState(837);
match(K_AND);
setState(838);
expr(15);
}
break;
case 8:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(839);
if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)");
setState(840);
match(K_OR);
setState(841);
expr(14);
}
break;
case 9:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(842);
if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
setState(843);
match(K_IS);
setState(845);
switch ( getInterpreter().adaptivePredict(_input,101,_ctx) ) {
case 1:
{
setState(844);
match(K_NOT);
}
break;
}
setState(847);
expr(7);
}
break;
case 10:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(848);
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
setState(850);
_la = _input.LA(1);
if (_la==K_NOT) {
{
setState(849);
match(K_NOT);
}
}
setState(852);
match(K_BETWEEN);
setState(853);
expr(0);
setState(854);
match(K_AND);
setState(855);
expr(6);
}
break;
case 11:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(857);
if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)");
setState(858);
match(K_COLLATE);
setState(859);
collation_name();
}
break;
case 12:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(860);
if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)");
setState(862);
_la = _input.LA(1);
if (_la==K_NOT) {
{
setState(861);
match(K_NOT);
}
}
setState(864);
_la = _input.LA(1);
if ( !(((((_la - 91)) & ~0x3f) == 0 && ((1L << (_la - 91)) & ((1L << (K_GLOB - 91)) | (1L << (K_LIKE - 91)) | (1L << (K_MATCH - 91)) | (1L << (K_REGEXP - 91)))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(865);
expr(0);
setState(868);
switch ( getInterpreter().adaptivePredict(_input,104,_ctx) ) {
case 1:
{
setState(866);
match(K_ESCAPE);
setState(867);
expr(0);
}
break;
}
}
break;
case 13:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(870);
if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
setState(875);
switch (_input.LA(1)) {
case K_ISNULL:
{
setState(871);
match(K_ISNULL);
}
break;
case K_NOTNULL:
{
setState(872);
match(K_NOTNULL);
}
break;
case K_NOT:
{
setState(873);
match(K_NOT);
setState(874);
match(K_NULL);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 14:
{
_localctx = new ExprContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(877);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(879);
_la = _input.LA(1);
if (_la==K_NOT) {
{
setState(878);
match(K_NOT);
}
}
setState(881);
match(K_IN);
setState(896);
switch (_input.LA(1)) {
case OPEN_PAR:
{
setState(882);
match(OPEN_PAR);
setState(892);
switch (_input.LA(1)) {
case K_SELECT:
case K_VALUES:
case K_WITH:
{
setState(883);
select_stmt();
}
break;
case T__1:
case OPEN_PAR:
case PLUS:
case MINUS:
case TILDE:
case K_CASE:
case K_CAST:
case K_CURRENT_DATE:
case K_CURRENT_TIME:
case K_CURRENT_TIMESTAMP:
case K_EXISTS:
case K_NOT:
case K_NULL:
case K_RAISE:
case IDENTIFIER:
case NUMERIC_LITERAL:
case BIND_PARAMETER:
case STRING_LITERAL:
case BLOB_LITERAL:
{
setState(884);
expr(0);
setState(889);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(885);
match(COMMA);
setState(886);
expr(0);
}
}
setState(891);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case CLOSE_PAR:
break;
default:
throw new NoViableAltException(this);
}
setState(894);
match(CLOSE_PAR);
}
break;
case IDENTIFIER:
{
setState(895);
table_name();
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
}
}
}
setState(902);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,111,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class Foreign_key_clauseContext extends ParserRuleContext {
public TerminalNode K_REFERENCES() { return getToken(SqliteParser.K_REFERENCES, 0); }
public Foreign_tableContext foreign_table() {
return getRuleContext(Foreign_tableContext.class,0);
}
public List column_name() {
return getRuleContexts(Column_nameContext.class);
}
public Column_nameContext column_name(int i) {
return getRuleContext(Column_nameContext.class,i);
}
public TerminalNode K_DEFERRABLE() { return getToken(SqliteParser.K_DEFERRABLE, 0); }
public List K_ON() { return getTokens(SqliteParser.K_ON); }
public TerminalNode K_ON(int i) {
return getToken(SqliteParser.K_ON, i);
}
public List K_MATCH() { return getTokens(SqliteParser.K_MATCH); }
public TerminalNode K_MATCH(int i) {
return getToken(SqliteParser.K_MATCH, i);
}
public List name() {
return getRuleContexts(NameContext.class);
}
public NameContext name(int i) {
return getRuleContext(NameContext.class,i);
}
public List K_DELETE() { return getTokens(SqliteParser.K_DELETE); }
public TerminalNode K_DELETE(int i) {
return getToken(SqliteParser.K_DELETE, i);
}
public List K_UPDATE() { return getTokens(SqliteParser.K_UPDATE); }
public TerminalNode K_UPDATE(int i) {
return getToken(SqliteParser.K_UPDATE, i);
}
public TerminalNode K_NOT() { return getToken(SqliteParser.K_NOT, 0); }
public TerminalNode K_INITIALLY() { return getToken(SqliteParser.K_INITIALLY, 0); }
public TerminalNode K_DEFERRED() { return getToken(SqliteParser.K_DEFERRED, 0); }
public TerminalNode K_IMMEDIATE() { return getToken(SqliteParser.K_IMMEDIATE, 0); }
public List K_SET() { return getTokens(SqliteParser.K_SET); }
public TerminalNode K_SET(int i) {
return getToken(SqliteParser.K_SET, i);
}
public List K_NULL() { return getTokens(SqliteParser.K_NULL); }
public TerminalNode K_NULL(int i) {
return getToken(SqliteParser.K_NULL, i);
}
public List K_DEFAULT() { return getTokens(SqliteParser.K_DEFAULT); }
public TerminalNode K_DEFAULT(int i) {
return getToken(SqliteParser.K_DEFAULT, i);
}
public List K_CASCADE() { return getTokens(SqliteParser.K_CASCADE); }
public TerminalNode K_CASCADE(int i) {
return getToken(SqliteParser.K_CASCADE, i);
}
public List K_RESTRICT() { return getTokens(SqliteParser.K_RESTRICT); }
public TerminalNode K_RESTRICT(int i) {
return getToken(SqliteParser.K_RESTRICT, i);
}
public List K_NO() { return getTokens(SqliteParser.K_NO); }
public TerminalNode K_NO(int i) {
return getToken(SqliteParser.K_NO, i);
}
public List K_ACTION() { return getTokens(SqliteParser.K_ACTION); }
public TerminalNode K_ACTION(int i) {
return getToken(SqliteParser.K_ACTION, i);
}
public Foreign_key_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_foreign_key_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterForeign_key_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitForeign_key_clause(this);
}
}
public final Foreign_key_clauseContext foreign_key_clause() throws RecognitionException {
Foreign_key_clauseContext _localctx = new Foreign_key_clauseContext(_ctx, getState());
enterRule(_localctx, 64, RULE_foreign_key_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(903);
match(K_REFERENCES);
setState(904);
foreign_table();
setState(916);
_la = _input.LA(1);
if (_la==OPEN_PAR) {
{
setState(905);
match(OPEN_PAR);
setState(906);
column_name();
setState(911);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(907);
match(COMMA);
setState(908);
column_name();
}
}
setState(913);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(914);
match(CLOSE_PAR);
}
}
setState(936);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==K_MATCH || _la==K_ON) {
{
{
setState(932);
switch (_input.LA(1)) {
case K_ON:
{
setState(918);
match(K_ON);
setState(919);
_la = _input.LA(1);
if ( !(_la==K_DELETE || _la==K_UPDATE) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(928);
switch ( getInterpreter().adaptivePredict(_input,114,_ctx) ) {
case 1:
{
setState(920);
match(K_SET);
setState(921);
match(K_NULL);
}
break;
case 2:
{
setState(922);
match(K_SET);
setState(923);
match(K_DEFAULT);
}
break;
case 3:
{
setState(924);
match(K_CASCADE);
}
break;
case 4:
{
setState(925);
match(K_RESTRICT);
}
break;
case 5:
{
setState(926);
match(K_NO);
setState(927);
match(K_ACTION);
}
break;
}
}
break;
case K_MATCH:
{
setState(930);
match(K_MATCH);
setState(931);
name();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
setState(938);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(949);
switch ( getInterpreter().adaptivePredict(_input,119,_ctx) ) {
case 1:
{
setState(940);
_la = _input.LA(1);
if (_la==K_NOT) {
{
setState(939);
match(K_NOT);
}
}
setState(942);
match(K_DEFERRABLE);
setState(947);
switch ( getInterpreter().adaptivePredict(_input,118,_ctx) ) {
case 1:
{
setState(943);
match(K_INITIALLY);
setState(944);
match(K_DEFERRED);
}
break;
case 2:
{
setState(945);
match(K_INITIALLY);
setState(946);
match(K_IMMEDIATE);
}
break;
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Raise_functionContext extends ParserRuleContext {
public TerminalNode K_RAISE() { return getToken(SqliteParser.K_RAISE, 0); }
public TerminalNode K_IGNORE() { return getToken(SqliteParser.K_IGNORE, 0); }
public Error_messageContext error_message() {
return getRuleContext(Error_messageContext.class,0);
}
public TerminalNode K_ROLLBACK() { return getToken(SqliteParser.K_ROLLBACK, 0); }
public TerminalNode K_ABORT() { return getToken(SqliteParser.K_ABORT, 0); }
public TerminalNode K_FAIL() { return getToken(SqliteParser.K_FAIL, 0); }
public Raise_functionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_raise_function; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterRaise_function(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitRaise_function(this);
}
}
public final Raise_functionContext raise_function() throws RecognitionException {
Raise_functionContext _localctx = new Raise_functionContext(_ctx, getState());
enterRule(_localctx, 66, RULE_raise_function);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(951);
match(K_RAISE);
setState(952);
match(OPEN_PAR);
setState(957);
switch (_input.LA(1)) {
case K_IGNORE:
{
setState(953);
match(K_IGNORE);
}
break;
case K_ABORT:
case K_FAIL:
case K_ROLLBACK:
{
setState(954);
_la = _input.LA(1);
if ( !(_la==K_ABORT || _la==K_FAIL || _la==K_ROLLBACK) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(955);
match(COMMA);
setState(956);
error_message();
}
break;
default:
throw new NoViableAltException(this);
}
setState(959);
match(CLOSE_PAR);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Indexed_columnContext extends ParserRuleContext {
public Column_nameContext column_name() {
return getRuleContext(Column_nameContext.class,0);
}
public TerminalNode K_COLLATE() { return getToken(SqliteParser.K_COLLATE, 0); }
public Collation_nameContext collation_name() {
return getRuleContext(Collation_nameContext.class,0);
}
public TerminalNode K_ASC() { return getToken(SqliteParser.K_ASC, 0); }
public TerminalNode K_DESC() { return getToken(SqliteParser.K_DESC, 0); }
public Indexed_columnContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_indexed_column; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterIndexed_column(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitIndexed_column(this);
}
}
public final Indexed_columnContext indexed_column() throws RecognitionException {
Indexed_columnContext _localctx = new Indexed_columnContext(_ctx, getState());
enterRule(_localctx, 68, RULE_indexed_column);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(961);
column_name();
setState(964);
_la = _input.LA(1);
if (_la==K_COLLATE) {
{
setState(962);
match(K_COLLATE);
setState(963);
collation_name();
}
}
setState(967);
_la = _input.LA(1);
if (_la==K_ASC || _la==K_DESC) {
{
setState(966);
_la = _input.LA(1);
if ( !(_la==K_ASC || _la==K_DESC) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Table_constraintContext extends ParserRuleContext {
public List indexed_column() {
return getRuleContexts(Indexed_columnContext.class);
}
public Indexed_columnContext indexed_column(int i) {
return getRuleContext(Indexed_columnContext.class,i);
}
public Conflict_clauseContext conflict_clause() {
return getRuleContext(Conflict_clauseContext.class,0);
}
public TerminalNode K_CHECK() { return getToken(SqliteParser.K_CHECK, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode K_FOREIGN_KEY() { return getToken(SqliteParser.K_FOREIGN_KEY, 0); }
public List column_name() {
return getRuleContexts(Column_nameContext.class);
}
public Column_nameContext column_name(int i) {
return getRuleContext(Column_nameContext.class,i);
}
public Foreign_key_clauseContext foreign_key_clause() {
return getRuleContext(Foreign_key_clauseContext.class,0);
}
public TerminalNode K_CONSTRAINT() { return getToken(SqliteParser.K_CONSTRAINT, 0); }
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public TerminalNode K_PRIMARY_KEY() { return getToken(SqliteParser.K_PRIMARY_KEY, 0); }
public TerminalNode K_UNIQUE() { return getToken(SqliteParser.K_UNIQUE, 0); }
public Table_constraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_table_constraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterTable_constraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitTable_constraint(this);
}
}
public final Table_constraintContext table_constraint() throws RecognitionException {
Table_constraintContext _localctx = new Table_constraintContext(_ctx, getState());
enterRule(_localctx, 70, RULE_table_constraint);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(971);
_la = _input.LA(1);
if (_la==K_CONSTRAINT) {
{
setState(969);
match(K_CONSTRAINT);
setState(970);
name();
}
}
setState(1004);
switch (_input.LA(1)) {
case K_PRIMARY_KEY:
case K_UNIQUE:
{
setState(973);
_la = _input.LA(1);
if ( !(_la==K_PRIMARY_KEY || _la==K_UNIQUE) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
setState(974);
match(OPEN_PAR);
setState(975);
indexed_column();
setState(980);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(976);
match(COMMA);
setState(977);
indexed_column();
}
}
setState(982);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(983);
match(CLOSE_PAR);
setState(984);
conflict_clause();
}
break;
case K_CHECK:
{
setState(986);
match(K_CHECK);
setState(987);
match(OPEN_PAR);
setState(988);
expr(0);
setState(989);
match(CLOSE_PAR);
}
break;
case K_FOREIGN_KEY:
{
setState(991);
match(K_FOREIGN_KEY);
setState(992);
match(OPEN_PAR);
setState(993);
column_name();
setState(998);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(994);
match(COMMA);
setState(995);
column_name();
}
}
setState(1000);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1001);
match(CLOSE_PAR);
setState(1002);
foreign_key_clause();
}
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 With_clauseContext extends ParserRuleContext {
public TerminalNode K_WITH() { return getToken(SqliteParser.K_WITH, 0); }
public List common_table_expression() {
return getRuleContexts(Common_table_expressionContext.class);
}
public Common_table_expressionContext common_table_expression(int i) {
return getRuleContext(Common_table_expressionContext.class,i);
}
public TerminalNode K_RECURSIVE() { return getToken(SqliteParser.K_RECURSIVE, 0); }
public With_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_with_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterWith_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitWith_clause(this);
}
}
public final With_clauseContext with_clause() throws RecognitionException {
With_clauseContext _localctx = new With_clauseContext(_ctx, getState());
enterRule(_localctx, 72, RULE_with_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1006);
match(K_WITH);
setState(1008);
_la = _input.LA(1);
if (_la==K_RECURSIVE) {
{
setState(1007);
match(K_RECURSIVE);
}
}
setState(1010);
common_table_expression();
setState(1015);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1011);
match(COMMA);
setState(1012);
common_table_expression();
}
}
setState(1017);
_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 Qualified_table_nameContext extends ParserRuleContext {
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public TerminalNode K_INDEXED() { return getToken(SqliteParser.K_INDEXED, 0); }
public TerminalNode K_BY() { return getToken(SqliteParser.K_BY, 0); }
public Index_nameContext index_name() {
return getRuleContext(Index_nameContext.class,0);
}
public TerminalNode K_NOT() { return getToken(SqliteParser.K_NOT, 0); }
public Qualified_table_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qualified_table_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterQualified_table_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitQualified_table_name(this);
}
}
public final Qualified_table_nameContext qualified_table_name() throws RecognitionException {
Qualified_table_nameContext _localctx = new Qualified_table_nameContext(_ctx, getState());
enterRule(_localctx, 74, RULE_qualified_table_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1018);
table_name();
setState(1024);
switch (_input.LA(1)) {
case K_INDEXED:
{
setState(1019);
match(K_INDEXED);
setState(1020);
match(K_BY);
setState(1021);
index_name();
}
break;
case K_NOT:
{
setState(1022);
match(K_NOT);
setState(1023);
match(K_INDEXED);
}
break;
case SCOL:
case K_LIMIT:
case K_ORDER:
case K_SET:
case K_WHERE:
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 Ordering_termContext extends ParserRuleContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode K_COLLATE() { return getToken(SqliteParser.K_COLLATE, 0); }
public Collation_nameContext collation_name() {
return getRuleContext(Collation_nameContext.class,0);
}
public TerminalNode K_ASC() { return getToken(SqliteParser.K_ASC, 0); }
public TerminalNode K_DESC() { return getToken(SqliteParser.K_DESC, 0); }
public Ordering_termContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ordering_term; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterOrdering_term(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitOrdering_term(this);
}
}
public final Ordering_termContext ordering_term() throws RecognitionException {
Ordering_termContext _localctx = new Ordering_termContext(_ctx, getState());
enterRule(_localctx, 76, RULE_ordering_term);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1026);
expr(0);
setState(1029);
_la = _input.LA(1);
if (_la==K_COLLATE) {
{
setState(1027);
match(K_COLLATE);
setState(1028);
collation_name();
}
}
setState(1032);
_la = _input.LA(1);
if (_la==K_ASC || _la==K_DESC) {
{
setState(1031);
_la = _input.LA(1);
if ( !(_la==K_ASC || _la==K_DESC) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Pragma_valueContext extends ParserRuleContext {
public Signed_numberContext signed_number() {
return getRuleContext(Signed_numberContext.class,0);
}
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public TerminalNode STRING_LITERAL() { return getToken(SqliteParser.STRING_LITERAL, 0); }
public Pragma_valueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pragma_value; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterPragma_value(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitPragma_value(this);
}
}
public final Pragma_valueContext pragma_value() throws RecognitionException {
Pragma_valueContext _localctx = new Pragma_valueContext(_ctx, getState());
enterRule(_localctx, 78, RULE_pragma_value);
try {
setState(1037);
switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1034);
signed_number();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1035);
name();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1036);
match(STRING_LITERAL);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Common_table_expressionContext extends ParserRuleContext {
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public TerminalNode K_AS() { return getToken(SqliteParser.K_AS, 0); }
public Select_stmtContext select_stmt() {
return getRuleContext(Select_stmtContext.class,0);
}
public List column_name() {
return getRuleContexts(Column_nameContext.class);
}
public Column_nameContext column_name(int i) {
return getRuleContext(Column_nameContext.class,i);
}
public Common_table_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_common_table_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterCommon_table_expression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitCommon_table_expression(this);
}
}
public final Common_table_expressionContext common_table_expression() throws RecognitionException {
Common_table_expressionContext _localctx = new Common_table_expressionContext(_ctx, getState());
enterRule(_localctx, 80, RULE_common_table_expression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1039);
table_name();
setState(1051);
_la = _input.LA(1);
if (_la==OPEN_PAR) {
{
setState(1040);
match(OPEN_PAR);
setState(1041);
column_name();
setState(1046);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1042);
match(COMMA);
setState(1043);
column_name();
}
}
setState(1048);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1049);
match(CLOSE_PAR);
}
}
setState(1053);
match(K_AS);
setState(1054);
match(OPEN_PAR);
setState(1055);
select_stmt();
setState(1056);
match(CLOSE_PAR);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Result_columnContext extends ParserRuleContext {
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public Column_aliasContext column_alias() {
return getRuleContext(Column_aliasContext.class,0);
}
public TerminalNode K_AS() { return getToken(SqliteParser.K_AS, 0); }
public Result_columnContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_result_column; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterResult_column(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitResult_column(this);
}
}
public final Result_columnContext result_column() throws RecognitionException {
Result_columnContext _localctx = new Result_columnContext(_ctx, getState());
enterRule(_localctx, 82, RULE_result_column);
int _la;
try {
setState(1070);
switch ( getInterpreter().adaptivePredict(_input,137,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1058);
match(STAR);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1059);
table_name();
setState(1060);
match(DOT);
setState(1061);
match(STAR);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1063);
expr(0);
setState(1068);
_la = _input.LA(1);
if (_la==K_AS || _la==IDENTIFIER) {
{
setState(1065);
_la = _input.LA(1);
if (_la==K_AS) {
{
setState(1064);
match(K_AS);
}
}
setState(1067);
column_alias();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Table_or_subqueryContext extends ParserRuleContext {
public Table_nameContext table_name() {
return getRuleContext(Table_nameContext.class,0);
}
public Table_aliasContext table_alias() {
return getRuleContext(Table_aliasContext.class,0);
}
public TerminalNode K_INDEXED() { return getToken(SqliteParser.K_INDEXED, 0); }
public TerminalNode K_BY() { return getToken(SqliteParser.K_BY, 0); }
public Index_nameContext index_name() {
return getRuleContext(Index_nameContext.class,0);
}
public TerminalNode K_NOT() { return getToken(SqliteParser.K_NOT, 0); }
public TerminalNode K_AS() { return getToken(SqliteParser.K_AS, 0); }
public List table_or_subquery() {
return getRuleContexts(Table_or_subqueryContext.class);
}
public Table_or_subqueryContext table_or_subquery(int i) {
return getRuleContext(Table_or_subqueryContext.class,i);
}
public Join_clauseContext join_clause() {
return getRuleContext(Join_clauseContext.class,0);
}
public Select_stmtContext select_stmt() {
return getRuleContext(Select_stmtContext.class,0);
}
public Table_or_subqueryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_table_or_subquery; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterTable_or_subquery(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitTable_or_subquery(this);
}
}
public final Table_or_subqueryContext table_or_subquery() throws RecognitionException {
Table_or_subqueryContext _localctx = new Table_or_subqueryContext(_ctx, getState());
enterRule(_localctx, 84, RULE_table_or_subquery);
int _la;
try {
setState(1109);
switch ( getInterpreter().adaptivePredict(_input,145,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1072);
table_name();
setState(1077);
_la = _input.LA(1);
if (_la==K_AS || _la==IDENTIFIER) {
{
setState(1074);
_la = _input.LA(1);
if (_la==K_AS) {
{
setState(1073);
match(K_AS);
}
}
setState(1076);
table_alias();
}
}
setState(1084);
switch (_input.LA(1)) {
case K_INDEXED:
{
setState(1079);
match(K_INDEXED);
setState(1080);
match(K_BY);
setState(1081);
index_name();
}
break;
case K_NOT:
{
setState(1082);
match(K_NOT);
setState(1083);
match(K_INDEXED);
}
break;
case SCOL:
case CLOSE_PAR:
case COMMA:
case K_CROSS:
case K_EXCEPT:
case K_GROUP:
case K_INNER:
case K_INTERSECT:
case K_JOIN:
case K_LEFT:
case K_LIMIT:
case K_NATURAL:
case K_ON:
case K_ORDER:
case K_UNION:
case K_USING:
case K_WHERE:
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1086);
match(OPEN_PAR);
setState(1096);
switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) {
case 1:
{
setState(1087);
table_or_subquery();
setState(1092);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1088);
match(COMMA);
setState(1089);
table_or_subquery();
}
}
setState(1094);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case 2:
{
setState(1095);
join_clause();
}
break;
}
setState(1098);
match(CLOSE_PAR);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1100);
match(OPEN_PAR);
setState(1101);
select_stmt();
setState(1102);
match(CLOSE_PAR);
setState(1107);
_la = _input.LA(1);
if (_la==K_AS || _la==IDENTIFIER) {
{
setState(1104);
_la = _input.LA(1);
if (_la==K_AS) {
{
setState(1103);
match(K_AS);
}
}
setState(1106);
table_alias();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Join_clauseContext extends ParserRuleContext {
public List table_or_subquery() {
return getRuleContexts(Table_or_subqueryContext.class);
}
public Table_or_subqueryContext table_or_subquery(int i) {
return getRuleContext(Table_or_subqueryContext.class,i);
}
public List join_operator() {
return getRuleContexts(Join_operatorContext.class);
}
public Join_operatorContext join_operator(int i) {
return getRuleContext(Join_operatorContext.class,i);
}
public List join_constraint() {
return getRuleContexts(Join_constraintContext.class);
}
public Join_constraintContext join_constraint(int i) {
return getRuleContext(Join_constraintContext.class,i);
}
public Join_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_join_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterJoin_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitJoin_clause(this);
}
}
public final Join_clauseContext join_clause() throws RecognitionException {
Join_clauseContext _localctx = new Join_clauseContext(_ctx, getState());
enterRule(_localctx, 86, RULE_join_clause);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1111);
table_or_subquery();
setState(1118);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (K_CROSS - 65)) | (1L << (K_INNER - 65)) | (1L << (K_JOIN - 65)) | (1L << (K_LEFT - 65)) | (1L << (K_NATURAL - 65)))) != 0)) {
{
{
setState(1112);
join_operator();
setState(1113);
table_or_subquery();
setState(1114);
join_constraint();
}
}
setState(1120);
_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 Join_operatorContext extends ParserRuleContext {
public TerminalNode K_JOIN() { return getToken(SqliteParser.K_JOIN, 0); }
public TerminalNode K_NATURAL() { return getToken(SqliteParser.K_NATURAL, 0); }
public TerminalNode K_LEFT() { return getToken(SqliteParser.K_LEFT, 0); }
public TerminalNode K_INNER() { return getToken(SqliteParser.K_INNER, 0); }
public TerminalNode K_CROSS() { return getToken(SqliteParser.K_CROSS, 0); }
public TerminalNode K_OUTER() { return getToken(SqliteParser.K_OUTER, 0); }
public Join_operatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_join_operator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterJoin_operator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitJoin_operator(this);
}
}
public final Join_operatorContext join_operator() throws RecognitionException {
Join_operatorContext _localctx = new Join_operatorContext(_ctx, getState());
enterRule(_localctx, 88, RULE_join_operator);
int _la;
try {
setState(1134);
switch (_input.LA(1)) {
case COMMA:
enterOuterAlt(_localctx, 1);
{
setState(1121);
match(COMMA);
}
break;
case K_CROSS:
case K_INNER:
case K_JOIN:
case K_LEFT:
case K_NATURAL:
enterOuterAlt(_localctx, 2);
{
setState(1123);
_la = _input.LA(1);
if (_la==K_NATURAL) {
{
setState(1122);
match(K_NATURAL);
}
}
setState(1131);
switch (_input.LA(1)) {
case K_LEFT:
{
setState(1125);
match(K_LEFT);
setState(1127);
_la = _input.LA(1);
if (_la==K_OUTER) {
{
setState(1126);
match(K_OUTER);
}
}
}
break;
case K_INNER:
{
setState(1129);
match(K_INNER);
}
break;
case K_CROSS:
{
setState(1130);
match(K_CROSS);
}
break;
case K_JOIN:
break;
default:
throw new NoViableAltException(this);
}
setState(1133);
match(K_JOIN);
}
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 Join_constraintContext extends ParserRuleContext {
public TerminalNode K_ON() { return getToken(SqliteParser.K_ON, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode K_USING() { return getToken(SqliteParser.K_USING, 0); }
public List column_name() {
return getRuleContexts(Column_nameContext.class);
}
public Column_nameContext column_name(int i) {
return getRuleContext(Column_nameContext.class,i);
}
public Join_constraintContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_join_constraint; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterJoin_constraint(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitJoin_constraint(this);
}
}
public final Join_constraintContext join_constraint() throws RecognitionException {
Join_constraintContext _localctx = new Join_constraintContext(_ctx, getState());
enterRule(_localctx, 90, RULE_join_constraint);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1150);
switch (_input.LA(1)) {
case K_ON:
{
setState(1136);
match(K_ON);
setState(1137);
expr(0);
}
break;
case K_USING:
{
setState(1138);
match(K_USING);
setState(1139);
match(OPEN_PAR);
setState(1140);
column_name();
setState(1145);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(1141);
match(COMMA);
setState(1142);
column_name();
}
}
setState(1147);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(1148);
match(CLOSE_PAR);
}
break;
case SCOL:
case CLOSE_PAR:
case COMMA:
case K_CROSS:
case K_EXCEPT:
case K_GROUP:
case K_INNER:
case K_INTERSECT:
case K_JOIN:
case K_LEFT:
case K_LIMIT:
case K_NATURAL:
case K_ORDER:
case K_UNION:
case K_WHERE:
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 Compound_operatorContext extends ParserRuleContext {
public TerminalNode K_UNION() { return getToken(SqliteParser.K_UNION, 0); }
public TerminalNode K_ALL() { return getToken(SqliteParser.K_ALL, 0); }
public TerminalNode K_INTERSECT() { return getToken(SqliteParser.K_INTERSECT, 0); }
public TerminalNode K_EXCEPT() { return getToken(SqliteParser.K_EXCEPT, 0); }
public Compound_operatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_compound_operator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterCompound_operator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitCompound_operator(this);
}
}
public final Compound_operatorContext compound_operator() throws RecognitionException {
Compound_operatorContext _localctx = new Compound_operatorContext(_ctx, getState());
enterRule(_localctx, 92, RULE_compound_operator);
try {
setState(1157);
switch ( getInterpreter().adaptivePredict(_input,153,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1152);
match(K_UNION);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1153);
match(K_UNION);
setState(1154);
match(K_ALL);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1155);
match(K_INTERSECT);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1156);
match(K_EXCEPT);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Signed_numberContext extends ParserRuleContext {
public TerminalNode NUMERIC_LITERAL() { return getToken(SqliteParser.NUMERIC_LITERAL, 0); }
public Signed_numberContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_signed_number; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterSigned_number(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitSigned_number(this);
}
}
public final Signed_numberContext signed_number() throws RecognitionException {
Signed_numberContext _localctx = new Signed_numberContext(_ctx, getState());
enterRule(_localctx, 94, RULE_signed_number);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1160);
_la = _input.LA(1);
if (_la==PLUS || _la==MINUS) {
{
setState(1159);
_la = _input.LA(1);
if ( !(_la==PLUS || _la==MINUS) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
setState(1162);
match(NUMERIC_LITERAL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Literal_valueContext extends ParserRuleContext {
public TerminalNode NUMERIC_LITERAL() { return getToken(SqliteParser.NUMERIC_LITERAL, 0); }
public TerminalNode STRING_LITERAL() { return getToken(SqliteParser.STRING_LITERAL, 0); }
public TerminalNode BLOB_LITERAL() { return getToken(SqliteParser.BLOB_LITERAL, 0); }
public TerminalNode K_NULL() { return getToken(SqliteParser.K_NULL, 0); }
public TerminalNode K_CURRENT_TIME() { return getToken(SqliteParser.K_CURRENT_TIME, 0); }
public TerminalNode K_CURRENT_DATE() { return getToken(SqliteParser.K_CURRENT_DATE, 0); }
public TerminalNode K_CURRENT_TIMESTAMP() { return getToken(SqliteParser.K_CURRENT_TIMESTAMP, 0); }
public Literal_valueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_literal_value; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterLiteral_value(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitLiteral_value(this);
}
}
public final Literal_valueContext literal_value() throws RecognitionException {
Literal_valueContext _localctx = new Literal_valueContext(_ctx, getState());
enterRule(_localctx, 96, RULE_literal_value);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1164);
_la = _input.LA(1);
if ( !(_la==T__1 || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (K_CURRENT_DATE - 66)) | (1L << (K_CURRENT_TIME - 66)) | (1L << (K_CURRENT_TIMESTAMP - 66)) | (1L << (K_NULL - 66)))) != 0) || ((((_la - 162)) & ~0x3f) == 0 && ((1L << (_la - 162)) & ((1L << (NUMERIC_LITERAL - 162)) | (1L << (STRING_LITERAL - 162)) | (1L << (BLOB_LITERAL - 162)))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Unary_operatorContext extends ParserRuleContext {
public TerminalNode K_NOT() { return getToken(SqliteParser.K_NOT, 0); }
public Unary_operatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unary_operator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterUnary_operator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitUnary_operator(this);
}
}
public final Unary_operatorContext unary_operator() throws RecognitionException {
Unary_operatorContext _localctx = new Unary_operatorContext(_ctx, getState());
enterRule(_localctx, 98, RULE_unary_operator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1166);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PLUS) | (1L << MINUS) | (1L << TILDE))) != 0) || _la==K_NOT) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Error_messageContext extends ParserRuleContext {
public TerminalNode STRING_LITERAL() { return getToken(SqliteParser.STRING_LITERAL, 0); }
public Error_messageContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_error_message; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterError_message(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitError_message(this);
}
}
public final Error_messageContext error_message() throws RecognitionException {
Error_messageContext _localctx = new Error_messageContext(_ctx, getState());
enterRule(_localctx, 100, RULE_error_message);
try {
enterOuterAlt(_localctx, 1);
{
setState(1168);
match(STRING_LITERAL);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Column_aliasContext extends ParserRuleContext {
public TerminalNode IDENTIFIER() { return getToken(SqliteParser.IDENTIFIER, 0); }
public Column_aliasContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_column_alias; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterColumn_alias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitColumn_alias(this);
}
}
public final Column_aliasContext column_alias() throws RecognitionException {
Column_aliasContext _localctx = new Column_aliasContext(_ctx, getState());
enterRule(_localctx, 102, RULE_column_alias);
try {
enterOuterAlt(_localctx, 1);
{
setState(1170);
match(IDENTIFIER);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class KeywordContext extends ParserRuleContext {
public TerminalNode K_ABORT() { return getToken(SqliteParser.K_ABORT, 0); }
public TerminalNode K_ACTION() { return getToken(SqliteParser.K_ACTION, 0); }
public TerminalNode K_ADD() { return getToken(SqliteParser.K_ADD, 0); }
public TerminalNode K_AFTER() { return getToken(SqliteParser.K_AFTER, 0); }
public TerminalNode K_ALL() { return getToken(SqliteParser.K_ALL, 0); }
public TerminalNode K_ALTER() { return getToken(SqliteParser.K_ALTER, 0); }
public TerminalNode K_ANALYZE() { return getToken(SqliteParser.K_ANALYZE, 0); }
public TerminalNode K_AND() { return getToken(SqliteParser.K_AND, 0); }
public TerminalNode K_AS() { return getToken(SqliteParser.K_AS, 0); }
public TerminalNode K_ASC() { return getToken(SqliteParser.K_ASC, 0); }
public TerminalNode K_ATTACH() { return getToken(SqliteParser.K_ATTACH, 0); }
public TerminalNode K_AUTOINCREMENT() { return getToken(SqliteParser.K_AUTOINCREMENT, 0); }
public TerminalNode K_BEFORE() { return getToken(SqliteParser.K_BEFORE, 0); }
public TerminalNode K_BEGIN() { return getToken(SqliteParser.K_BEGIN, 0); }
public TerminalNode K_BETWEEN() { return getToken(SqliteParser.K_BETWEEN, 0); }
public TerminalNode K_BY() { return getToken(SqliteParser.K_BY, 0); }
public TerminalNode K_CASCADE() { return getToken(SqliteParser.K_CASCADE, 0); }
public TerminalNode K_CASE() { return getToken(SqliteParser.K_CASE, 0); }
public TerminalNode K_CAST() { return getToken(SqliteParser.K_CAST, 0); }
public TerminalNode K_CHECK() { return getToken(SqliteParser.K_CHECK, 0); }
public TerminalNode K_COLLATE() { return getToken(SqliteParser.K_COLLATE, 0); }
public TerminalNode K_COLUMN() { return getToken(SqliteParser.K_COLUMN, 0); }
public TerminalNode K_COMMIT() { return getToken(SqliteParser.K_COMMIT, 0); }
public TerminalNode K_CONFLICT() { return getToken(SqliteParser.K_CONFLICT, 0); }
public TerminalNode K_CONSTRAINT() { return getToken(SqliteParser.K_CONSTRAINT, 0); }
public TerminalNode K_CREATE() { return getToken(SqliteParser.K_CREATE, 0); }
public TerminalNode K_CROSS() { return getToken(SqliteParser.K_CROSS, 0); }
public TerminalNode K_CURRENT_DATE() { return getToken(SqliteParser.K_CURRENT_DATE, 0); }
public TerminalNode K_CURRENT_TIME() { return getToken(SqliteParser.K_CURRENT_TIME, 0); }
public TerminalNode K_CURRENT_TIMESTAMP() { return getToken(SqliteParser.K_CURRENT_TIMESTAMP, 0); }
public TerminalNode K_DATABASE() { return getToken(SqliteParser.K_DATABASE, 0); }
public TerminalNode K_DEFAULT() { return getToken(SqliteParser.K_DEFAULT, 0); }
public TerminalNode K_DEFERRABLE() { return getToken(SqliteParser.K_DEFERRABLE, 0); }
public TerminalNode K_DEFERRED() { return getToken(SqliteParser.K_DEFERRED, 0); }
public TerminalNode K_DELETE() { return getToken(SqliteParser.K_DELETE, 0); }
public TerminalNode K_DESC() { return getToken(SqliteParser.K_DESC, 0); }
public TerminalNode K_DETACH() { return getToken(SqliteParser.K_DETACH, 0); }
public TerminalNode K_DISTINCT() { return getToken(SqliteParser.K_DISTINCT, 0); }
public TerminalNode K_DROP() { return getToken(SqliteParser.K_DROP, 0); }
public TerminalNode K_EACH() { return getToken(SqliteParser.K_EACH, 0); }
public TerminalNode K_ELSE() { return getToken(SqliteParser.K_ELSE, 0); }
public TerminalNode K_END() { return getToken(SqliteParser.K_END, 0); }
public TerminalNode K_ESCAPE() { return getToken(SqliteParser.K_ESCAPE, 0); }
public TerminalNode K_EXCEPT() { return getToken(SqliteParser.K_EXCEPT, 0); }
public TerminalNode K_EXCLUSIVE() { return getToken(SqliteParser.K_EXCLUSIVE, 0); }
public TerminalNode K_EXISTS() { return getToken(SqliteParser.K_EXISTS, 0); }
public TerminalNode K_EXPLAIN() { return getToken(SqliteParser.K_EXPLAIN, 0); }
public TerminalNode K_FAIL() { return getToken(SqliteParser.K_FAIL, 0); }
public TerminalNode K_FOR() { return getToken(SqliteParser.K_FOR, 0); }
public TerminalNode K_FOREIGN_KEY() { return getToken(SqliteParser.K_FOREIGN_KEY, 0); }
public TerminalNode K_FROM() { return getToken(SqliteParser.K_FROM, 0); }
public TerminalNode K_FULL() { return getToken(SqliteParser.K_FULL, 0); }
public TerminalNode K_GLOB() { return getToken(SqliteParser.K_GLOB, 0); }
public TerminalNode K_GROUP() { return getToken(SqliteParser.K_GROUP, 0); }
public TerminalNode K_HAVING() { return getToken(SqliteParser.K_HAVING, 0); }
public TerminalNode K_IF() { return getToken(SqliteParser.K_IF, 0); }
public TerminalNode K_IGNORE() { return getToken(SqliteParser.K_IGNORE, 0); }
public TerminalNode K_IMMEDIATE() { return getToken(SqliteParser.K_IMMEDIATE, 0); }
public TerminalNode K_IN() { return getToken(SqliteParser.K_IN, 0); }
public TerminalNode K_INDEX() { return getToken(SqliteParser.K_INDEX, 0); }
public TerminalNode K_INDEXED() { return getToken(SqliteParser.K_INDEXED, 0); }
public TerminalNode K_INITIALLY() { return getToken(SqliteParser.K_INITIALLY, 0); }
public TerminalNode K_INNER() { return getToken(SqliteParser.K_INNER, 0); }
public TerminalNode K_INSERT() { return getToken(SqliteParser.K_INSERT, 0); }
public TerminalNode K_INSTEAD() { return getToken(SqliteParser.K_INSTEAD, 0); }
public TerminalNode K_INTERSECT() { return getToken(SqliteParser.K_INTERSECT, 0); }
public TerminalNode K_INTO() { return getToken(SqliteParser.K_INTO, 0); }
public TerminalNode K_IS() { return getToken(SqliteParser.K_IS, 0); }
public TerminalNode K_ISNULL() { return getToken(SqliteParser.K_ISNULL, 0); }
public TerminalNode K_JOIN() { return getToken(SqliteParser.K_JOIN, 0); }
public TerminalNode K_LEFT() { return getToken(SqliteParser.K_LEFT, 0); }
public TerminalNode K_LIKE() { return getToken(SqliteParser.K_LIKE, 0); }
public TerminalNode K_LIMIT() { return getToken(SqliteParser.K_LIMIT, 0); }
public TerminalNode K_MATCH() { return getToken(SqliteParser.K_MATCH, 0); }
public TerminalNode K_NATURAL() { return getToken(SqliteParser.K_NATURAL, 0); }
public TerminalNode K_NO() { return getToken(SqliteParser.K_NO, 0); }
public TerminalNode K_NOT() { return getToken(SqliteParser.K_NOT, 0); }
public TerminalNode K_NOTNULL() { return getToken(SqliteParser.K_NOTNULL, 0); }
public TerminalNode K_NULL() { return getToken(SqliteParser.K_NULL, 0); }
public TerminalNode K_OF() { return getToken(SqliteParser.K_OF, 0); }
public TerminalNode K_OFFSET() { return getToken(SqliteParser.K_OFFSET, 0); }
public TerminalNode K_ON() { return getToken(SqliteParser.K_ON, 0); }
public TerminalNode K_OR() { return getToken(SqliteParser.K_OR, 0); }
public TerminalNode K_ORDER() { return getToken(SqliteParser.K_ORDER, 0); }
public TerminalNode K_OUTER() { return getToken(SqliteParser.K_OUTER, 0); }
public TerminalNode K_PLAN() { return getToken(SqliteParser.K_PLAN, 0); }
public TerminalNode K_PRAGMA() { return getToken(SqliteParser.K_PRAGMA, 0); }
public TerminalNode K_PRIMARY_KEY() { return getToken(SqliteParser.K_PRIMARY_KEY, 0); }
public TerminalNode K_QUERY() { return getToken(SqliteParser.K_QUERY, 0); }
public TerminalNode K_RAISE() { return getToken(SqliteParser.K_RAISE, 0); }
public TerminalNode K_RECURSIVE() { return getToken(SqliteParser.K_RECURSIVE, 0); }
public TerminalNode K_REFERENCES() { return getToken(SqliteParser.K_REFERENCES, 0); }
public TerminalNode K_REGEXP() { return getToken(SqliteParser.K_REGEXP, 0); }
public TerminalNode K_REINDEX() { return getToken(SqliteParser.K_REINDEX, 0); }
public TerminalNode K_RELEASE() { return getToken(SqliteParser.K_RELEASE, 0); }
public TerminalNode K_RENAME() { return getToken(SqliteParser.K_RENAME, 0); }
public TerminalNode K_REPLACE() { return getToken(SqliteParser.K_REPLACE, 0); }
public TerminalNode K_RESTRICT() { return getToken(SqliteParser.K_RESTRICT, 0); }
public TerminalNode K_RIGHT() { return getToken(SqliteParser.K_RIGHT, 0); }
public TerminalNode K_ROLLBACK() { return getToken(SqliteParser.K_ROLLBACK, 0); }
public TerminalNode K_ROW() { return getToken(SqliteParser.K_ROW, 0); }
public TerminalNode K_SAVEPOINT() { return getToken(SqliteParser.K_SAVEPOINT, 0); }
public TerminalNode K_SELECT() { return getToken(SqliteParser.K_SELECT, 0); }
public TerminalNode K_SET() { return getToken(SqliteParser.K_SET, 0); }
public TerminalNode K_TABLE() { return getToken(SqliteParser.K_TABLE, 0); }
public TerminalNode K_TEMP() { return getToken(SqliteParser.K_TEMP, 0); }
public TerminalNode K_TEMPORARY() { return getToken(SqliteParser.K_TEMPORARY, 0); }
public TerminalNode K_THEN() { return getToken(SqliteParser.K_THEN, 0); }
public TerminalNode K_TO() { return getToken(SqliteParser.K_TO, 0); }
public TerminalNode K_TRANSACTION() { return getToken(SqliteParser.K_TRANSACTION, 0); }
public TerminalNode K_TRIGGER() { return getToken(SqliteParser.K_TRIGGER, 0); }
public TerminalNode K_UNION() { return getToken(SqliteParser.K_UNION, 0); }
public TerminalNode K_UNIQUE() { return getToken(SqliteParser.K_UNIQUE, 0); }
public TerminalNode K_UPDATE() { return getToken(SqliteParser.K_UPDATE, 0); }
public TerminalNode K_USING() { return getToken(SqliteParser.K_USING, 0); }
public TerminalNode K_VACUUM() { return getToken(SqliteParser.K_VACUUM, 0); }
public TerminalNode K_VALUES() { return getToken(SqliteParser.K_VALUES, 0); }
public TerminalNode K_VIEW() { return getToken(SqliteParser.K_VIEW, 0); }
public TerminalNode K_WHEN() { return getToken(SqliteParser.K_WHEN, 0); }
public TerminalNode K_WHERE() { return getToken(SqliteParser.K_WHERE, 0); }
public TerminalNode K_WITH() { return getToken(SqliteParser.K_WITH, 0); }
public TerminalNode K_WITHOUT() { return getToken(SqliteParser.K_WITHOUT, 0); }
public TerminalNode K_INTEGER() { return getToken(SqliteParser.K_INTEGER, 0); }
public TerminalNode K_REAL() { return getToken(SqliteParser.K_REAL, 0); }
public TerminalNode K_TEXT() { return getToken(SqliteParser.K_TEXT, 0); }
public TerminalNode K_BLOB() { return getToken(SqliteParser.K_BLOB, 0); }
public TerminalNode K_JAVA_BOOLEAN() { return getToken(SqliteParser.K_JAVA_BOOLEAN, 0); }
public TerminalNode K_JAVA_INTEGER() { return getToken(SqliteParser.K_JAVA_INTEGER, 0); }
public TerminalNode K_JAVA_LONG() { return getToken(SqliteParser.K_JAVA_LONG, 0); }
public TerminalNode K_JAVA_FLOAT() { return getToken(SqliteParser.K_JAVA_FLOAT, 0); }
public TerminalNode K_JAVA_DOUBLE() { return getToken(SqliteParser.K_JAVA_DOUBLE, 0); }
public TerminalNode K_JAVA_STRING() { return getToken(SqliteParser.K_JAVA_STRING, 0); }
public TerminalNode K_JAVA_BYTE_ARRAY() { return getToken(SqliteParser.K_JAVA_BYTE_ARRAY, 0); }
public KeywordContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_keyword; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterKeyword(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitKeyword(this);
}
}
public final KeywordContext keyword() throws RecognitionException {
KeywordContext _localctx = new KeywordContext(_ctx, getState());
enterRule(_localctx, 104, RULE_keyword);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1172);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << K_JAVA_BOOLEAN) | (1L << K_JAVA_INTEGER) | (1L << K_JAVA_LONG) | (1L << K_JAVA_FLOAT) | (1L << K_JAVA_DOUBLE) | (1L << K_JAVA_STRING) | (1L << K_JAVA_BYTE_ARRAY) | (1L << K_INTEGER) | (1L << K_REAL) | (1L << K_TEXT) | (1L << K_BLOB) | (1L << K_ABORT) | (1L << K_ACTION) | (1L << K_ADD) | (1L << K_AFTER) | (1L << K_ALL) | (1L << K_ALTER) | (1L << K_ANALYZE) | (1L << K_AND) | (1L << K_AS) | (1L << K_ASC) | (1L << K_ATTACH) | (1L << K_AUTOINCREMENT) | (1L << K_BEFORE) | (1L << K_BEGIN) | (1L << K_BETWEEN) | (1L << K_BY) | (1L << K_CASCADE) | (1L << K_CASE) | (1L << K_CAST) | (1L << K_CHECK) | (1L << K_COLLATE) | (1L << K_COLUMN) | (1L << K_COMMIT) | (1L << K_CONFLICT) | (1L << K_CONSTRAINT))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (K_CREATE - 64)) | (1L << (K_CROSS - 64)) | (1L << (K_CURRENT_DATE - 64)) | (1L << (K_CURRENT_TIME - 64)) | (1L << (K_CURRENT_TIMESTAMP - 64)) | (1L << (K_DATABASE - 64)) | (1L << (K_DEFAULT - 64)) | (1L << (K_DEFERRABLE - 64)) | (1L << (K_DEFERRED - 64)) | (1L << (K_DELETE - 64)) | (1L << (K_DESC - 64)) | (1L << (K_DETACH - 64)) | (1L << (K_DISTINCT - 64)) | (1L << (K_DROP - 64)) | (1L << (K_EACH - 64)) | (1L << (K_ELSE - 64)) | (1L << (K_END - 64)) | (1L << (K_ESCAPE - 64)) | (1L << (K_EXCEPT - 64)) | (1L << (K_EXCLUSIVE - 64)) | (1L << (K_EXISTS - 64)) | (1L << (K_EXPLAIN - 64)) | (1L << (K_FAIL - 64)) | (1L << (K_FOR - 64)) | (1L << (K_FOREIGN_KEY - 64)) | (1L << (K_FROM - 64)) | (1L << (K_FULL - 64)) | (1L << (K_GLOB - 64)) | (1L << (K_GROUP - 64)) | (1L << (K_HAVING - 64)) | (1L << (K_IF - 64)) | (1L << (K_IGNORE - 64)) | (1L << (K_IMMEDIATE - 64)) | (1L << (K_IN - 64)) | (1L << (K_INDEX - 64)) | (1L << (K_INDEXED - 64)) | (1L << (K_INITIALLY - 64)) | (1L << (K_INNER - 64)) | (1L << (K_INSERT - 64)) | (1L << (K_INSTEAD - 64)) | (1L << (K_INTERSECT - 64)) | (1L << (K_INTO - 64)) | (1L << (K_IS - 64)) | (1L << (K_ISNULL - 64)) | (1L << (K_JOIN - 64)) | (1L << (K_LEFT - 64)) | (1L << (K_LIKE - 64)) | (1L << (K_LIMIT - 64)) | (1L << (K_MATCH - 64)) | (1L << (K_NATURAL - 64)) | (1L << (K_NO - 64)) | (1L << (K_NOT - 64)) | (1L << (K_NOTNULL - 64)) | (1L << (K_NULL - 64)) | (1L << (K_OF - 64)) | (1L << (K_OFFSET - 64)) | (1L << (K_ON - 64)) | (1L << (K_OR - 64)) | (1L << (K_ORDER - 64)) | (1L << (K_OUTER - 64)) | (1L << (K_PLAN - 64)) | (1L << (K_PRAGMA - 64)) | (1L << (K_PRIMARY_KEY - 64)) | (1L << (K_QUERY - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (K_RAISE - 128)) | (1L << (K_RECURSIVE - 128)) | (1L << (K_REFERENCES - 128)) | (1L << (K_REGEXP - 128)) | (1L << (K_REINDEX - 128)) | (1L << (K_RELEASE - 128)) | (1L << (K_RENAME - 128)) | (1L << (K_REPLACE - 128)) | (1L << (K_RESTRICT - 128)) | (1L << (K_RIGHT - 128)) | (1L << (K_ROLLBACK - 128)) | (1L << (K_ROW - 128)) | (1L << (K_SAVEPOINT - 128)) | (1L << (K_SELECT - 128)) | (1L << (K_SET - 128)) | (1L << (K_TABLE - 128)) | (1L << (K_TEMP - 128)) | (1L << (K_TEMPORARY - 128)) | (1L << (K_THEN - 128)) | (1L << (K_TO - 128)) | (1L << (K_TRANSACTION - 128)) | (1L << (K_TRIGGER - 128)) | (1L << (K_UNION - 128)) | (1L << (K_UNIQUE - 128)) | (1L << (K_UPDATE - 128)) | (1L << (K_USING - 128)) | (1L << (K_VACUUM - 128)) | (1L << (K_VALUES - 128)) | (1L << (K_VIEW - 128)) | (1L << (K_WHEN - 128)) | (1L << (K_WHERE - 128)) | (1L << (K_WITH - 128)) | (1L << (K_WITHOUT - 128)))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NameContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public NameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitName(this);
}
}
public final NameContext name() throws RecognitionException {
NameContext _localctx = new NameContext(_ctx, getState());
enterRule(_localctx, 106, RULE_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1174);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Function_nameContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public Function_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_function_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterFunction_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitFunction_name(this);
}
}
public final Function_nameContext function_name() throws RecognitionException {
Function_nameContext _localctx = new Function_nameContext(_ctx, getState());
enterRule(_localctx, 108, RULE_function_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1176);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Table_nameContext extends ParserRuleContext {
public TerminalNode IDENTIFIER() { return getToken(SqliteParser.IDENTIFIER, 0); }
public Table_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_table_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterTable_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitTable_name(this);
}
}
public final Table_nameContext table_name() throws RecognitionException {
Table_nameContext _localctx = new Table_nameContext(_ctx, getState());
enterRule(_localctx, 110, RULE_table_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1178);
match(IDENTIFIER);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Table_or_index_nameContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public Table_or_index_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_table_or_index_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterTable_or_index_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitTable_or_index_name(this);
}
}
public final Table_or_index_nameContext table_or_index_name() throws RecognitionException {
Table_or_index_nameContext _localctx = new Table_or_index_nameContext(_ctx, getState());
enterRule(_localctx, 112, RULE_table_or_index_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1180);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class New_table_nameContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public New_table_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_new_table_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterNew_table_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitNew_table_name(this);
}
}
public final New_table_nameContext new_table_name() throws RecognitionException {
New_table_nameContext _localctx = new New_table_nameContext(_ctx, getState());
enterRule(_localctx, 114, RULE_new_table_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1182);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Column_nameContext extends ParserRuleContext {
public TerminalNode IDENTIFIER() { return getToken(SqliteParser.IDENTIFIER, 0); }
public Column_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_column_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterColumn_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitColumn_name(this);
}
}
public final Column_nameContext column_name() throws RecognitionException {
Column_nameContext _localctx = new Column_nameContext(_ctx, getState());
enterRule(_localctx, 116, RULE_column_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1184);
match(IDENTIFIER);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Sql_stmt_nameContext extends ParserRuleContext {
public TerminalNode IDENTIFIER() { return getToken(SqliteParser.IDENTIFIER, 0); }
public Sql_stmt_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sql_stmt_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterSql_stmt_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitSql_stmt_name(this);
}
}
public final Sql_stmt_nameContext sql_stmt_name() throws RecognitionException {
Sql_stmt_nameContext _localctx = new Sql_stmt_nameContext(_ctx, getState());
enterRule(_localctx, 118, RULE_sql_stmt_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1186);
match(IDENTIFIER);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Collation_nameContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public Collation_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_collation_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterCollation_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitCollation_name(this);
}
}
public final Collation_nameContext collation_name() throws RecognitionException {
Collation_nameContext _localctx = new Collation_nameContext(_ctx, getState());
enterRule(_localctx, 120, RULE_collation_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1188);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Foreign_tableContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public Foreign_tableContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_foreign_table; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterForeign_table(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitForeign_table(this);
}
}
public final Foreign_tableContext foreign_table() throws RecognitionException {
Foreign_tableContext _localctx = new Foreign_tableContext(_ctx, getState());
enterRule(_localctx, 122, RULE_foreign_table);
try {
enterOuterAlt(_localctx, 1);
{
setState(1190);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Index_nameContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public Index_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_index_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterIndex_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitIndex_name(this);
}
}
public final Index_nameContext index_name() throws RecognitionException {
Index_nameContext _localctx = new Index_nameContext(_ctx, getState());
enterRule(_localctx, 124, RULE_index_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1192);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Trigger_nameContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public Trigger_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_trigger_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterTrigger_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitTrigger_name(this);
}
}
public final Trigger_nameContext trigger_name() throws RecognitionException {
Trigger_nameContext _localctx = new Trigger_nameContext(_ctx, getState());
enterRule(_localctx, 126, RULE_trigger_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1194);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class View_nameContext extends ParserRuleContext {
public TerminalNode IDENTIFIER() { return getToken(SqliteParser.IDENTIFIER, 0); }
public View_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_view_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterView_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitView_name(this);
}
}
public final View_nameContext view_name() throws RecognitionException {
View_nameContext _localctx = new View_nameContext(_ctx, getState());
enterRule(_localctx, 128, RULE_view_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1196);
match(IDENTIFIER);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Pragma_nameContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public Pragma_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pragma_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterPragma_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitPragma_name(this);
}
}
public final Pragma_nameContext pragma_name() throws RecognitionException {
Pragma_nameContext _localctx = new Pragma_nameContext(_ctx, getState());
enterRule(_localctx, 130, RULE_pragma_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1198);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Savepoint_nameContext extends ParserRuleContext {
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public Savepoint_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_savepoint_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterSavepoint_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitSavepoint_name(this);
}
}
public final Savepoint_nameContext savepoint_name() throws RecognitionException {
Savepoint_nameContext _localctx = new Savepoint_nameContext(_ctx, getState());
enterRule(_localctx, 132, RULE_savepoint_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(1200);
any_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Table_aliasContext extends ParserRuleContext {
public TerminalNode IDENTIFIER() { return getToken(SqliteParser.IDENTIFIER, 0); }
public Table_aliasContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_table_alias; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterTable_alias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitTable_alias(this);
}
}
public final Table_aliasContext table_alias() throws RecognitionException {
Table_aliasContext _localctx = new Table_aliasContext(_ctx, getState());
enterRule(_localctx, 134, RULE_table_alias);
try {
enterOuterAlt(_localctx, 1);
{
setState(1202);
match(IDENTIFIER);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Sqlite_type_nameContext extends ParserRuleContext {
public TerminalNode K_INTEGER() { return getToken(SqliteParser.K_INTEGER, 0); }
public TerminalNode K_REAL() { return getToken(SqliteParser.K_REAL, 0); }
public TerminalNode K_TEXT() { return getToken(SqliteParser.K_TEXT, 0); }
public TerminalNode K_BLOB() { return getToken(SqliteParser.K_BLOB, 0); }
public Sqlite_type_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sqlite_type_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterSqlite_type_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitSqlite_type_name(this);
}
}
public final Sqlite_type_nameContext sqlite_type_name() throws RecognitionException {
Sqlite_type_nameContext _localctx = new Sqlite_type_nameContext(_ctx, getState());
enterRule(_localctx, 136, RULE_sqlite_type_name);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1204);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << K_INTEGER) | (1L << K_REAL) | (1L << K_TEXT) | (1L << K_BLOB))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Java_type_nameContext extends ParserRuleContext {
public TerminalNode K_JAVA_BOOLEAN() { return getToken(SqliteParser.K_JAVA_BOOLEAN, 0); }
public TerminalNode K_JAVA_INTEGER() { return getToken(SqliteParser.K_JAVA_INTEGER, 0); }
public TerminalNode K_JAVA_LONG() { return getToken(SqliteParser.K_JAVA_LONG, 0); }
public TerminalNode K_JAVA_FLOAT() { return getToken(SqliteParser.K_JAVA_FLOAT, 0); }
public TerminalNode K_JAVA_DOUBLE() { return getToken(SqliteParser.K_JAVA_DOUBLE, 0); }
public TerminalNode K_JAVA_STRING() { return getToken(SqliteParser.K_JAVA_STRING, 0); }
public TerminalNode K_JAVA_BYTE_ARRAY() { return getToken(SqliteParser.K_JAVA_BYTE_ARRAY, 0); }
public TerminalNode STRING_LITERAL() { return getToken(SqliteParser.STRING_LITERAL, 0); }
public Java_type_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_java_type_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterJava_type_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitJava_type_name(this);
}
}
public final Java_type_nameContext java_type_name() throws RecognitionException {
Java_type_nameContext _localctx = new Java_type_nameContext(_ctx, getState());
enterRule(_localctx, 138, RULE_java_type_name);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1206);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << K_JAVA_BOOLEAN) | (1L << K_JAVA_INTEGER) | (1L << K_JAVA_LONG) | (1L << K_JAVA_FLOAT) | (1L << K_JAVA_DOUBLE) | (1L << K_JAVA_STRING) | (1L << K_JAVA_BYTE_ARRAY))) != 0) || _la==STRING_LITERAL) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Any_nameContext extends ParserRuleContext {
public TerminalNode IDENTIFIER() { return getToken(SqliteParser.IDENTIFIER, 0); }
public TerminalNode STRING_LITERAL() { return getToken(SqliteParser.STRING_LITERAL, 0); }
public Any_nameContext any_name() {
return getRuleContext(Any_nameContext.class,0);
}
public Any_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_any_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).enterAny_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SqliteListener ) ((SqliteListener)listener).exitAny_name(this);
}
}
public final Any_nameContext any_name() throws RecognitionException {
Any_nameContext _localctx = new Any_nameContext(_ctx, getState());
enterRule(_localctx, 140, RULE_any_name);
try {
setState(1214);
switch (_input.LA(1)) {
case IDENTIFIER:
enterOuterAlt(_localctx, 1);
{
setState(1208);
match(IDENTIFIER);
}
break;
case STRING_LITERAL:
enterOuterAlt(_localctx, 2);
{
setState(1209);
match(STRING_LITERAL);
}
break;
case OPEN_PAR:
enterOuterAlt(_localctx, 3);
{
setState(1210);
match(OPEN_PAR);
setState(1211);
any_name();
setState(1212);
match(CLOSE_PAR);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
switch (ruleIndex) {
case 31:
return expr_sempred((ExprContext)_localctx, predIndex);
}
return true;
}
private boolean expr_sempred(ExprContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return precpred(_ctx, 20);
case 1:
return precpred(_ctx, 19);
case 2:
return precpred(_ctx, 18);
case 3:
return precpred(_ctx, 17);
case 4:
return precpred(_ctx, 16);
case 5:
return precpred(_ctx, 15);
case 6:
return precpred(_ctx, 14);
case 7:
return precpred(_ctx, 13);
case 8:
return precpred(_ctx, 6);
case 9:
return precpred(_ctx, 5);
case 10:
return precpred(_ctx, 9);
case 11:
return precpred(_ctx, 8);
case 12:
return precpred(_ctx, 7);
case 13:
return precpred(_ctx, 4);
}
return true;
}
public static final String _serializedATN =
"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\u00ab\u04c3\4\2\t"+
"\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+
"\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
"\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
"\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\3\2"+
"\3\2\5\2\u0093\n\2\3\2\3\2\3\3\3\3\3\4\3\4\3\4\5\4\u009c\n\4\3\4\3\4\3"+
"\4\7\4\u00a1\n\4\f\4\16\4\u00a4\13\4\3\5\3\5\3\5\3\5\3\5\5\5\u00ab\n\5"+
"\5\5\u00ad\n\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5"+
"\3\5\3\5\3\5\3\5\3\5\3\5\5\5\u00c3\n\5\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6"+
"\5\6\u00cd\n\6\3\6\5\6\u00d0\n\6\3\7\3\7\3\7\3\b\3\b\5\b\u00d7\n\b\3\b"+
"\3\b\3\b\3\b\5\b\u00dd\n\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\7\b\u00e6\n\b\f"+
"\b\16\b\u00e9\13\b\3\b\3\b\3\b\5\b\u00ee\n\b\3\t\3\t\5\t\u00f2\n\t\3\t"+
"\3\t\3\t\3\t\5\t\u00f8\n\t\3\t\3\t\3\t\3\t\3\t\7\t\u00ff\n\t\f\t\16\t"+
"\u0102\13\t\3\t\3\t\7\t\u0106\n\t\f\t\16\t\u0109\13\t\3\t\3\t\3\t\5\t"+
"\u010e\n\t\3\t\3\t\5\t\u0112\n\t\3\n\3\n\5\n\u0116\n\n\3\n\3\n\3\n\3\n"+
"\5\n\u011c\n\n\3\n\3\n\3\n\3\n\3\n\5\n\u0123\n\n\3\n\3\n\3\n\3\n\3\n\3"+
"\n\3\n\7\n\u012c\n\n\f\n\16\n\u012f\13\n\5\n\u0131\n\n\5\n\u0133\n\n\3"+
"\n\3\n\3\n\3\n\3\n\5\n\u013a\n\n\3\n\3\n\5\n\u013e\n\n\3\n\3\n\3\n\3\n"+
"\3\n\5\n\u0145\n\n\3\n\3\n\6\n\u0149\n\n\r\n\16\n\u014a\3\n\3\n\3\13\3"+
"\13\5\13\u0151\n\13\3\13\3\13\3\13\3\13\5\13\u0157\n\13\3\13\3\13\3\13"+
"\3\13\3\f\5\f\u015e\n\f\3\f\3\f\3\f\3\f\3\f\5\f\u0165\n\f\3\r\5\r\u0168"+
"\n\r\3\r\3\r\3\r\3\r\3\r\5\r\u016f\n\r\3\r\3\r\3\r\3\r\3\r\7\r\u0176\n"+
"\r\f\r\16\r\u0179\13\r\5\r\u017b\n\r\3\r\3\r\3\r\3\r\5\r\u0181\n\r\5\r"+
"\u0183\n\r\3\16\3\16\3\16\3\16\5\16\u0189\n\16\3\16\3\16\3\17\3\17\3\17"+
"\3\17\5\17\u0191\n\17\3\17\3\17\3\20\3\20\3\20\3\20\5\20\u0199\n\20\3"+
"\20\3\20\3\21\3\21\3\21\3\21\5\21\u01a1\n\21\3\21\3\21\3\22\5\22\u01a6"+
"\n\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22"+
"\3\22\3\22\3\22\3\22\5\22\u01b9\n\22\3\22\3\22\3\22\3\22\3\22\3\22\7\22"+
"\u01c1\n\22\f\22\16\22\u01c4\13\22\3\22\3\22\5\22\u01c8\n\22\3\22\3\22"+
"\3\22\3\22\3\22\5\22\u01cf\n\22\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23"+
"\5\23\u01d9\n\23\3\24\3\24\3\24\3\24\5\24\u01df\n\24\5\24\u01e1\n\24\3"+
"\25\3\25\5\25\u01e5\n\25\3\25\3\25\3\26\3\26\3\26\3\27\5\27\u01ed\n\27"+
"\3\27\3\27\3\27\3\27\7\27\u01f3\n\27\f\27\16\27\u01f6\13\27\3\27\3\27"+
"\3\27\3\27\3\27\7\27\u01fd\n\27\f\27\16\27\u0200\13\27\5\27\u0202\n\27"+
"\3\27\3\27\3\27\3\27\5\27\u0208\n\27\5\27\u020a\n\27\3\30\3\30\5\30\u020e"+
"\n\30\3\30\3\30\3\30\7\30\u0213\n\30\f\30\16\30\u0216\13\30\3\30\3\30"+
"\3\30\3\30\7\30\u021c\n\30\f\30\16\30\u021f\13\30\3\30\5\30\u0222\n\30"+
"\5\30\u0224\n\30\3\30\3\30\5\30\u0228\n\30\3\30\3\30\3\30\3\30\3\30\7"+
"\30\u022f\n\30\f\30\16\30\u0232\13\30\3\30\3\30\5\30\u0236\n\30\5\30\u0238"+
"\n\30\3\30\3\30\5\30\u023c\n\30\3\31\3\31\3\31\3\31\7\31\u0242\n\31\f"+
"\31\16\31\u0245\13\31\3\31\3\31\3\31\5\31\u024a\n\31\3\32\5\32\u024d\n"+
"\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\5\32\u025a"+
"\n\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\7\32\u0266\n\32"+
"\f\32\16\32\u0269\13\32\3\32\3\32\5\32\u026d\n\32\3\33\5\33\u0270\n\33"+
"\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\5\33\u027d\n\33"+
"\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\7\33\u0289\n\33\f\33"+
"\16\33\u028c\13\33\3\33\3\33\5\33\u0290\n\33\3\33\3\33\3\33\3\33\3\33"+
"\7\33\u0297\n\33\f\33\16\33\u029a\13\33\5\33\u029c\n\33\3\33\3\33\3\33"+
"\3\33\5\33\u02a2\n\33\5\33\u02a4\n\33\3\34\3\34\3\35\3\35\3\35\7\35\u02ab"+
"\n\35\f\35\16\35\u02ae\13\35\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3"+
"\36\3\36\3\36\5\36\u02bb\n\36\3\36\3\36\5\36\u02bf\n\36\3\37\3\37\5\37"+
"\u02c3\n\37\3\37\3\37\5\37\u02c7\n\37\3\37\3\37\5\37\u02cb\n\37\3\37\5"+
"\37\u02ce\n\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37"+
"\3\37\3\37\3\37\3\37\3\37\5\37\u02e0\n\37\3\37\3\37\3\37\5\37\u02e5\n"+
"\37\3 \3 \3 \5 \u02ea\n \3!\3!\3!\3!\3!\3!\3!\3!\3!\5!\u02f5\n!\3!\3!"+
"\3!\3!\5!\u02fb\n!\3!\3!\3!\7!\u0300\n!\f!\16!\u0303\13!\3!\5!\u0306\n"+
"!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\5!\u0316\n!\3!\5!\u0319\n"+
"!\3!\3!\3!\3!\3!\3!\5!\u0321\n!\3!\3!\3!\3!\3!\6!\u0328\n!\r!\16!\u0329"+
"\3!\3!\5!\u032e\n!\3!\3!\3!\5!\u0333\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!\5!\u0350\n!\3!\3!"+
"\3!\5!\u0355\n!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\5!\u0361\n!\3!\3!\3!\3!"+
"\5!\u0367\n!\3!\3!\3!\3!\3!\5!\u036e\n!\3!\3!\5!\u0372\n!\3!\3!\3!\3!"+
"\3!\3!\7!\u037a\n!\f!\16!\u037d\13!\5!\u037f\n!\3!\3!\5!\u0383\n!\7!\u0385"+
"\n!\f!\16!\u0388\13!\3\"\3\"\3\"\3\"\3\"\3\"\7\"\u0390\n\"\f\"\16\"\u0393"+
"\13\"\3\"\3\"\5\"\u0397\n\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\5"+
"\"\u03a3\n\"\3\"\3\"\5\"\u03a7\n\"\7\"\u03a9\n\"\f\"\16\"\u03ac\13\"\3"+
"\"\5\"\u03af\n\"\3\"\3\"\3\"\3\"\3\"\5\"\u03b6\n\"\5\"\u03b8\n\"\3#\3"+
"#\3#\3#\3#\3#\5#\u03c0\n#\3#\3#\3$\3$\3$\5$\u03c7\n$\3$\5$\u03ca\n$\3"+
"%\3%\5%\u03ce\n%\3%\3%\3%\3%\3%\7%\u03d5\n%\f%\16%\u03d8\13%\3%\3%\3%"+
"\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\7%\u03e7\n%\f%\16%\u03ea\13%\3%\3%\3%\5"+
"%\u03ef\n%\3&\3&\5&\u03f3\n&\3&\3&\3&\7&\u03f8\n&\f&\16&\u03fb\13&\3\'"+
"\3\'\3\'\3\'\3\'\3\'\5\'\u0403\n\'\3(\3(\3(\5(\u0408\n(\3(\5(\u040b\n"+
"(\3)\3)\3)\5)\u0410\n)\3*\3*\3*\3*\3*\7*\u0417\n*\f*\16*\u041a\13*\3*"+
"\3*\5*\u041e\n*\3*\3*\3*\3*\3*\3+\3+\3+\3+\3+\3+\3+\5+\u042c\n+\3+\5+"+
"\u042f\n+\5+\u0431\n+\3,\3,\5,\u0435\n,\3,\5,\u0438\n,\3,\3,\3,\3,\3,"+
"\5,\u043f\n,\3,\3,\3,\3,\7,\u0445\n,\f,\16,\u0448\13,\3,\5,\u044b\n,\3"+
",\3,\3,\3,\3,\3,\5,\u0453\n,\3,\5,\u0456\n,\5,\u0458\n,\3-\3-\3-\3-\3"+
"-\7-\u045f\n-\f-\16-\u0462\13-\3.\3.\5.\u0466\n.\3.\3.\5.\u046a\n.\3."+
"\3.\5.\u046e\n.\3.\5.\u0471\n.\3/\3/\3/\3/\3/\3/\3/\7/\u047a\n/\f/\16"+
"/\u047d\13/\3/\3/\5/\u0481\n/\3\60\3\60\3\60\3\60\3\60\5\60\u0488\n\60"+
"\3\61\5\61\u048b\n\61\3\61\3\61\3\62\3\62\3\63\3\63\3\64\3\64\3\65\3\65"+
"\3\66\3\66\3\67\3\67\38\38\39\39\3:\3:\3;\3;\3<\3<\3=\3=\3>\3>\3?\3?\3"+
"@\3@\3A\3A\3B\3B\3C\3C\3D\3D\3E\3E\3F\3F\3G\3G\3H\3H\3H\3H\3H\3H\5H\u04c1"+
"\nH\3H\2\3@I\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64"+
"\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088"+
"\u008a\u008c\u008e\2\25\3\2\u0092\u0093\4\2\24\24yy\4\2--NN\4\2\62\62"+
"LL\7\2))XXaa\u0089\u0089\u008c\u008c\4\2\26\26\33\34\3\2\27\30\3\2\35"+
" \3\2!$\4\2\25\25%\'\6\2]]pprr\u0085\u0085\4\2KK\u009a\u009a\5\2))XX\u008c"+
"\u008c\4\2\u0080\u0080\u0099\u0099\7\2\4\4DFww\u00a4\u00a4\u00a6\u00a7"+
"\4\2\27\31uu\4\2\5\17)\u00a2\3\2\f\17\4\2\5\13\u00a6\u00a6\u056c\2\u0092"+
"\3\2\2\2\4\u0096\3\2\2\2\6\u009b\3\2\2\2\b\u00a5\3\2\2\2\n\u00c4\3\2\2"+
"\2\f\u00d1\3\2\2\2\16\u00d4\3\2\2\2\20\u00ef\3\2\2\2\22\u0113\3\2\2\2"+
"\24\u014e\3\2\2\2\26\u015d\3\2\2\2\30\u0167\3\2\2\2\32\u0184\3\2\2\2\34"+
"\u018c\3\2\2\2\36\u0194\3\2\2\2 \u019c\3\2\2\2\"\u01a5\3\2\2\2$\u01d0"+
"\3\2\2\2&\u01da\3\2\2\2(\u01e2\3\2\2\2*\u01e8\3\2\2\2,\u01ec\3\2\2\2."+
"\u023b\3\2\2\2\60\u023d\3\2\2\2\62\u024c\3\2\2\2\64\u026f\3\2\2\2\66\u02a5"+
"\3\2\2\28\u02a7\3\2\2\2:\u02af\3\2\2\2<\u02c2\3\2\2\2>\u02e9\3\2\2\2@"+
"\u0332\3\2\2\2B\u0389\3\2\2\2D\u03b9\3\2\2\2F\u03c3\3\2\2\2H\u03cd\3\2"+
"\2\2J\u03f0\3\2\2\2L\u03fc\3\2\2\2N\u0404\3\2\2\2P\u040f\3\2\2\2R\u0411"+
"\3\2\2\2T\u0430\3\2\2\2V\u0457\3\2\2\2X\u0459\3\2\2\2Z\u0470\3\2\2\2\\"+
"\u0480\3\2\2\2^\u0487\3\2\2\2`\u048a\3\2\2\2b\u048e\3\2\2\2d\u0490\3\2"+
"\2\2f\u0492\3\2\2\2h\u0494\3\2\2\2j\u0496\3\2\2\2l\u0498\3\2\2\2n\u049a"+
"\3\2\2\2p\u049c\3\2\2\2r\u049e\3\2\2\2t\u04a0\3\2\2\2v\u04a2\3\2\2\2x"+
"\u04a4\3\2\2\2z\u04a6\3\2\2\2|\u04a8\3\2\2\2~\u04aa\3\2\2\2\u0080\u04ac"+
"\3\2\2\2\u0082\u04ae\3\2\2\2\u0084\u04b0\3\2\2\2\u0086\u04b2\3\2\2\2\u0088"+
"\u04b4\3\2\2\2\u008a\u04b6\3\2\2\2\u008c\u04b8\3\2\2\2\u008e\u04c0\3\2"+
"\2\2\u0090\u0093\5\6\4\2\u0091\u0093\5\4\3\2\u0092\u0090\3\2\2\2\u0092"+
"\u0091\3\2\2\2\u0093\u0094\3\2\2\2\u0094\u0095\7\2\2\3\u0095\3\3\2\2\2"+
"\u0096\u0097\7\u00ab\2\2\u0097\5\3\2\2\2\u0098\u0099\5\20\t\2\u0099\u009a"+
"\7\20\2\2\u009a\u009c\3\2\2\2\u009b\u0098\3\2\2\2\u009b\u009c\3\2\2\2"+
"\u009c\u00a2\3\2\2\2\u009d\u009e\5\b\5\2\u009e\u009f\7\20\2\2\u009f\u00a1"+
"\3\2\2\2\u00a0\u009d\3\2\2\2\u00a1\u00a4\3\2\2\2\u00a2\u00a0\3\2\2\2\u00a2"+
"\u00a3\3\2\2\2\u00a3\7\3\2\2\2\u00a4\u00a2\3\2\2\2\u00a5\u00a6\5x=\2\u00a6"+
"\u00ac\7\3\2\2\u00a7\u00aa\7W\2\2\u00a8\u00a9\7\u0081\2\2\u00a9\u00ab"+
"\7~\2\2\u00aa\u00a8\3\2\2\2\u00aa\u00ab\3\2\2\2\u00ab\u00ad\3\2\2\2\u00ac"+
"\u00a7\3\2\2\2\u00ac\u00ad\3\2\2\2\u00ad\u00c2\3\2\2\2\u00ae\u00c3\5\n"+
"\6\2\u00af\u00c3\5\f\7\2\u00b0\u00c3\5\16\b\2\u00b1\u00c3\5\22\n\2\u00b2"+
"\u00c3\5\24\13\2\u00b3\u00c3\5\26\f\2\u00b4\u00c3\5\30\r\2\u00b5\u00c3"+
"\5\32\16\2\u00b6\u00c3\5\34\17\2\u00b7\u00c3\5\36\20\2\u00b8\u00c3\5 "+
"\21\2\u00b9\u00c3\5\"\22\2\u00ba\u00c3\5$\23\2\u00bb\u00c3\5&\24\2\u00bc"+
"\u00c3\5(\25\2\u00bd\u00c3\5*\26\2\u00be\u00c3\5,\27\2\u00bf\u00c3\5\62"+
"\32\2\u00c0\u00c3\5\64\33\2\u00c1\u00c3\5\66\34\2\u00c2\u00ae\3\2\2\2"+
"\u00c2\u00af\3\2\2\2\u00c2\u00b0\3\2\2\2\u00c2\u00b1\3\2\2\2\u00c2\u00b2"+
"\3\2\2\2\u00c2\u00b3\3\2\2\2\u00c2\u00b4\3\2\2\2\u00c2\u00b5\3\2\2\2\u00c2"+
"\u00b6\3\2\2\2\u00c2\u00b7\3\2\2\2\u00c2\u00b8\3\2\2\2\u00c2\u00b9\3\2"+
"\2\2\u00c2\u00ba\3\2\2\2\u00c2\u00bb\3\2\2\2\u00c2\u00bc\3\2\2\2\u00c2"+
"\u00bd\3\2\2\2\u00c2\u00be\3\2\2\2\u00c2\u00bf\3\2\2\2\u00c2\u00c0\3\2"+
"\2\2\u00c2\u00c1\3\2\2\2\u00c3\t\3\2\2\2\u00c4\u00c5\7.\2\2\u00c5\u00c6"+
"\7\u0091\2\2\u00c6\u00cf\5p9\2\u00c7\u00c8\7\u0088\2\2\u00c8\u00c9\7\u0095"+
"\2\2\u00c9\u00d0\5t;\2\u00ca\u00cc\7+\2\2\u00cb\u00cd\7>\2\2\u00cc\u00cb"+
"\3\2\2\2\u00cc\u00cd\3\2\2\2\u00cd\u00ce\3\2\2\2\u00ce\u00d0\58\35\2\u00cf"+
"\u00c7\3\2\2\2\u00cf\u00ca\3\2\2\2\u00d0\13\3\2\2\2\u00d1\u00d2\7/\2\2"+
"\u00d2\u00d3\5r:\2\u00d3\r\3\2\2\2\u00d4\u00d6\7B\2\2\u00d5\u00d7\7\u0099"+
"\2\2\u00d6\u00d5\3\2\2\2\u00d6\u00d7\3\2\2\2\u00d7\u00d8\3\2\2\2\u00d8"+
"\u00dc\7d\2\2\u00d9\u00da\7`\2\2\u00da\u00db\7u\2\2\u00db\u00dd\7V\2\2"+
"\u00dc\u00d9\3\2\2\2\u00dc\u00dd\3\2\2\2\u00dd\u00de\3\2\2\2\u00de\u00df"+
"\5~@\2\u00df\u00e0\7z\2\2\u00e0\u00e1\5p9\2\u00e1\u00e2\7\22\2\2\u00e2"+
"\u00e7\5F$\2\u00e3\u00e4\7\24\2\2\u00e4\u00e6\5F$\2\u00e5\u00e3\3\2\2"+
"\2\u00e6\u00e9\3\2\2\2\u00e7\u00e5\3\2\2\2\u00e7\u00e8\3\2\2\2\u00e8\u00ea"+
"\3\2\2\2\u00e9\u00e7\3\2\2\2\u00ea\u00ed\7\23\2\2\u00eb\u00ec\7\u00a0"+
"\2\2\u00ec\u00ee\5@!\2\u00ed\u00eb\3\2\2\2\u00ed\u00ee\3\2\2\2\u00ee\17"+
"\3\2\2\2\u00ef\u00f1\7B\2\2\u00f0\u00f2\t\2\2\2\u00f1\u00f0\3\2\2\2\u00f1"+
"\u00f2\3\2\2\2\u00f2\u00f3\3\2\2\2\u00f3\u00f7\7\u0091\2\2\u00f4\u00f5"+
"\7`\2\2\u00f5\u00f6\7u\2\2\u00f6\u00f8\7V\2\2\u00f7\u00f4\3\2\2\2\u00f7"+
"\u00f8\3\2\2\2\u00f8\u00f9\3\2\2\2\u00f9\u0111\5p9\2\u00fa\u00fb\7\22"+
"\2\2\u00fb\u0100\58\35\2\u00fc\u00fd\7\24\2\2\u00fd\u00ff\58\35\2\u00fe"+
"\u00fc\3\2\2\2\u00ff\u0102\3\2\2\2\u0100\u00fe\3\2\2\2\u0100\u0101\3\2"+
"\2\2\u0101\u0107\3\2\2\2\u0102\u0100\3\2\2\2\u0103\u0104\7\24\2\2\u0104"+
"\u0106\5H%\2\u0105\u0103\3\2\2\2\u0106\u0109\3\2\2\2\u0107\u0105\3\2\2"+
"\2\u0107\u0108\3\2\2\2\u0108\u010a\3\2\2\2\u0109\u0107\3\2\2\2\u010a\u010d"+
"\7\23\2\2\u010b\u010c\7\u00a2\2\2\u010c\u010e\7\u00a3\2\2\u010d\u010b"+
"\3\2\2\2\u010d\u010e\3\2\2\2\u010e\u0112\3\2\2\2\u010f\u0110\7\61\2\2"+
"\u0110\u0112\5,\27\2\u0111\u00fa\3\2\2\2\u0111\u010f\3\2\2\2\u0112\21"+
"\3\2\2\2\u0113\u0115\7B\2\2\u0114\u0116\t\2\2\2\u0115\u0114\3\2\2\2\u0115"+
"\u0116\3\2\2\2\u0116\u0117\3\2\2\2\u0117\u011b\7\u0097\2\2\u0118\u0119"+
"\7`\2\2\u0119\u011a\7u\2\2\u011a\u011c\7V\2\2\u011b\u0118\3\2\2\2\u011b"+
"\u011c\3\2\2\2\u011c\u011d\3\2\2\2\u011d\u0122\5\u0080A\2\u011e\u0123"+
"\7\65\2\2\u011f\u0123\7,\2\2\u0120\u0121\7i\2\2\u0121\u0123\7x\2\2\u0122"+
"\u011e\3\2\2\2\u0122\u011f\3\2\2\2\u0122\u0120\3\2\2\2\u0122\u0123\3\2"+
"\2\2\u0123\u0132\3\2\2\2\u0124\u0133\7K\2\2\u0125\u0133\7h\2\2\u0126\u0130"+
"\7\u009a\2\2\u0127\u0128\7x\2\2\u0128\u012d\5v<\2\u0129\u012a\7\24\2\2"+
"\u012a\u012c\5v<\2\u012b\u0129\3\2\2\2\u012c\u012f\3\2\2\2\u012d\u012b"+
"\3\2\2\2\u012d\u012e\3\2\2\2\u012e\u0131\3\2\2\2\u012f\u012d\3\2\2\2\u0130"+
"\u0127\3\2\2\2\u0130\u0131\3\2\2\2\u0131\u0133\3\2\2\2\u0132\u0124\3\2"+
"\2\2\u0132\u0125\3\2\2\2\u0132\u0126\3\2\2\2\u0133\u0134\3\2\2\2\u0134"+
"\u0135\7z\2\2\u0135\u0139\5p9\2\u0136\u0137\7Y\2\2\u0137\u0138\7P\2\2"+
"\u0138\u013a\7\u008d\2\2\u0139\u0136\3\2\2\2\u0139\u013a\3\2\2\2\u013a"+
"\u013d\3\2\2\2\u013b\u013c\7\u009f\2\2\u013c\u013e\5@!\2\u013d\u013b\3"+
"\2\2\2\u013d\u013e\3\2\2\2\u013e\u013f\3\2\2\2\u013f\u0148\7\66\2\2\u0140"+
"\u0145\5\62\32\2\u0141\u0145\5\"\22\2\u0142\u0145\5\26\f\2\u0143\u0145"+
"\5,\27\2\u0144\u0140\3\2\2\2\u0144\u0141\3\2\2\2\u0144\u0142\3\2\2\2\u0144"+
"\u0143\3\2\2\2\u0145\u0146\3\2\2\2\u0146\u0147\7\20\2\2\u0147\u0149\3"+
"\2\2\2\u0148\u0144\3\2\2\2\u0149\u014a\3\2\2\2\u014a\u0148\3\2\2\2\u014a"+
"\u014b\3\2\2\2\u014b\u014c\3\2\2\2\u014c\u014d\7R\2\2\u014d\23\3\2\2\2"+
"\u014e\u0150\7B\2\2\u014f\u0151\t\2\2\2\u0150\u014f\3\2\2\2\u0150\u0151"+
"\3\2\2\2\u0151\u0152\3\2\2\2\u0152\u0156\7\u009e\2\2\u0153\u0154\7`\2"+
"\2\u0154\u0155\7u\2\2\u0155\u0157\7V\2\2\u0156\u0153\3\2\2\2\u0156\u0157"+
"\3\2\2\2\u0157\u0158\3\2\2\2\u0158\u0159\5\u0082B\2\u0159\u015a\7\61\2"+
"\2\u015a\u015b\5,\27\2\u015b\25\3\2\2\2\u015c\u015e\5J&\2\u015d\u015c"+
"\3\2\2\2\u015d\u015e\3\2\2\2\u015e\u015f\3\2\2\2\u015f\u0160\7K\2\2\u0160"+
"\u0161\7[\2\2\u0161\u0164\5p9\2\u0162\u0163\7\u00a0\2\2\u0163\u0165\5"+
"@!\2\u0164\u0162\3\2\2\2\u0164\u0165\3\2\2\2\u0165\27\3\2\2\2\u0166\u0168"+
"\5J&\2\u0167\u0166\3\2\2\2\u0167\u0168\3\2\2\2\u0168\u0169\3\2\2\2\u0169"+
"\u016a\7K\2\2\u016a\u016b\7[\2\2\u016b\u016e\5L\'\2\u016c\u016d\7\u00a0"+
"\2\2\u016d\u016f\5@!\2\u016e\u016c\3\2\2\2\u016e\u016f\3\2\2\2\u016f\u0182"+
"\3\2\2\2\u0170\u0171\7|\2\2\u0171\u0172\78\2\2\u0172\u0177\5N(\2\u0173"+
"\u0174\7\24\2\2\u0174\u0176\5N(\2\u0175\u0173\3\2\2\2\u0176\u0179\3\2"+
"\2\2\u0177\u0175\3\2\2\2\u0177\u0178\3\2\2\2\u0178\u017b\3\2\2\2\u0179"+
"\u0177\3\2\2\2\u017a\u0170\3\2\2\2\u017a\u017b\3\2\2\2\u017b\u017c\3\2"+
"\2\2\u017c\u017d\7q\2\2\u017d\u0180\5@!\2\u017e\u017f\t\3\2\2\u017f\u0181"+
"\5@!\2\u0180\u017e\3\2\2\2\u0180\u0181\3\2\2\2\u0181\u0183\3\2\2\2\u0182"+
"\u017a\3\2\2\2\u0182\u0183\3\2\2\2\u0183\31\3\2\2\2\u0184\u0185\7O\2\2"+
"\u0185\u0188\7d\2\2\u0186\u0187\7`\2\2\u0187\u0189\7V\2\2\u0188\u0186"+
"\3\2\2\2\u0188\u0189\3\2\2\2\u0189\u018a\3\2\2\2\u018a\u018b\5~@\2\u018b"+
"\33\3\2\2\2\u018c\u018d\7O\2\2\u018d\u0190\7\u0091\2\2\u018e\u018f\7`"+
"\2\2\u018f\u0191\7V\2\2\u0190\u018e\3\2\2\2\u0190\u0191\3\2\2\2\u0191"+
"\u0192\3\2\2\2\u0192\u0193\5p9\2\u0193\35\3\2\2\2\u0194\u0195\7O\2\2\u0195"+
"\u0198\7\u0097\2\2\u0196\u0197\7`\2\2\u0197\u0199\7V\2\2\u0198\u0196\3"+
"\2\2\2\u0198\u0199\3\2\2\2\u0199\u019a\3\2\2\2\u019a\u019b\5\u0080A\2"+
"\u019b\37\3\2\2\2\u019c\u019d\7O\2\2\u019d\u01a0\7\u009e\2\2\u019e\u019f"+
"\7`\2\2\u019f\u01a1\7V\2\2\u01a0\u019e\3\2\2\2\u01a0\u01a1\3\2\2\2\u01a1"+
"\u01a2\3\2\2\2\u01a2\u01a3\5\u0082B\2\u01a3!\3\2\2\2\u01a4\u01a6\5J&\2"+
"\u01a5\u01a4\3\2\2\2\u01a5\u01a6\3\2\2\2\u01a6\u01b8\3\2\2\2\u01a7\u01b9"+
"\7h\2\2\u01a8\u01b9\7\u0089\2\2\u01a9\u01aa\7h\2\2\u01aa\u01ab\7{\2\2"+
"\u01ab\u01b9\7\u0089\2\2\u01ac\u01ad\7h\2\2\u01ad\u01ae\7{\2\2\u01ae\u01b9"+
"\7\u008c\2\2\u01af\u01b0\7h\2\2\u01b0\u01b1\7{\2\2\u01b1\u01b9\7)\2\2"+
"\u01b2\u01b3\7h\2\2\u01b3\u01b4\7{\2\2\u01b4\u01b9\7X\2\2\u01b5\u01b6"+
"\7h\2\2\u01b6\u01b7\7{\2\2\u01b7\u01b9\7a\2\2\u01b8\u01a7\3\2\2\2\u01b8"+
"\u01a8\3\2\2\2\u01b8\u01a9\3\2\2\2\u01b8\u01ac\3\2\2\2\u01b8\u01af\3\2"+
"\2\2\u01b8\u01b2\3\2\2\2\u01b8\u01b5\3\2\2\2\u01b9\u01ba\3\2\2\2\u01ba"+
"\u01bb\7k\2\2\u01bb\u01c7\5p9\2\u01bc\u01bd\7\22\2\2\u01bd\u01c2\5v<\2"+
"\u01be\u01bf\7\24\2\2\u01bf\u01c1\5v<\2\u01c0\u01be\3\2\2\2\u01c1\u01c4"+
"\3\2\2\2\u01c2\u01c0\3\2\2\2\u01c2\u01c3\3\2\2\2\u01c3\u01c5\3\2\2\2\u01c4"+
"\u01c2\3\2\2\2\u01c5\u01c6\7\23\2\2\u01c6\u01c8\3\2\2\2\u01c7\u01bc\3"+
"\2\2\2\u01c7\u01c8\3\2\2\2\u01c8\u01ce\3\2\2\2\u01c9\u01ca\7\u009d\2\2"+
"\u01ca\u01cf\5\60\31\2\u01cb\u01cf\5,\27\2\u01cc\u01cd\7H\2\2\u01cd\u01cf"+
"\7\u009d\2\2\u01ce\u01c9\3\2\2\2\u01ce\u01cb\3\2\2\2\u01ce\u01cc\3\2\2"+
"\2\u01cf#\3\2\2\2\u01d0\u01d1\7\177\2\2\u01d1\u01d8\5\u0084C\2\u01d2\u01d3"+
"\7\25\2\2\u01d3\u01d9\5P)\2\u01d4\u01d5\7\22\2\2\u01d5\u01d6\5P)\2\u01d6"+
"\u01d7\7\23\2\2\u01d7\u01d9\3\2\2\2\u01d8\u01d2\3\2\2\2\u01d8\u01d4\3"+
"\2\2\2\u01d8\u01d9\3\2\2\2\u01d9%\3\2\2\2\u01da\u01e0\7\u0086\2\2\u01db"+
"\u01e1\5z>\2\u01dc\u01df\5p9\2\u01dd\u01df\5~@\2\u01de\u01dc\3\2\2\2\u01de"+
"\u01dd\3\2\2\2\u01df\u01e1\3\2\2\2\u01e0\u01db\3\2\2\2\u01e0\u01de\3\2"+
"\2\2\u01e0\u01e1\3\2\2\2\u01e1\'\3\2\2\2\u01e2\u01e4\7\u0087\2\2\u01e3"+
"\u01e5\7\u008e\2\2\u01e4\u01e3\3\2\2\2\u01e4\u01e5\3\2\2\2\u01e5\u01e6"+
"\3\2\2\2\u01e6\u01e7\5\u0086D\2\u01e7)\3\2\2\2\u01e8\u01e9\7\u008e\2\2"+
"\u01e9\u01ea\5\u0086D\2\u01ea+\3\2\2\2\u01eb\u01ed\5J&\2\u01ec\u01eb\3"+
"\2\2\2\u01ec\u01ed\3\2\2\2\u01ed\u01ee\3\2\2\2\u01ee\u01f4\5.\30\2\u01ef"+
"\u01f0\5^\60\2\u01f0\u01f1\5.\30\2\u01f1\u01f3\3\2\2\2\u01f2\u01ef\3\2"+
"\2\2\u01f3\u01f6\3\2\2\2\u01f4\u01f2\3\2\2\2\u01f4\u01f5\3\2\2\2\u01f5"+
"\u0201\3\2\2\2\u01f6\u01f4\3\2\2\2\u01f7\u01f8\7|\2\2\u01f8\u01f9\78\2"+
"\2\u01f9\u01fe\5N(\2\u01fa\u01fb\7\24\2\2\u01fb\u01fd\5N(\2\u01fc\u01fa"+
"\3\2\2\2\u01fd\u0200\3\2\2\2\u01fe\u01fc\3\2\2\2\u01fe\u01ff\3\2\2\2\u01ff"+
"\u0202\3\2\2\2\u0200\u01fe\3\2\2\2\u0201\u01f7\3\2\2\2\u0201\u0202\3\2"+
"\2\2\u0202\u0209\3\2\2\2\u0203\u0204\7q\2\2\u0204\u0207\5@!\2\u0205\u0206"+
"\t\3\2\2\u0206\u0208\5@!\2\u0207\u0205\3\2\2\2\u0207\u0208\3\2\2\2\u0208"+
"\u020a\3\2\2\2\u0209\u0203\3\2\2\2\u0209\u020a\3\2\2\2\u020a-\3\2\2\2"+
"\u020b\u020d\7\u008f\2\2\u020c\u020e\t\4\2\2\u020d\u020c\3\2\2\2\u020d"+
"\u020e\3\2\2\2\u020e\u020f\3\2\2\2\u020f\u0214\5T+\2\u0210\u0211\7\24"+
"\2\2\u0211\u0213\5T+\2\u0212\u0210\3\2\2\2\u0213\u0216\3\2\2\2\u0214\u0212"+
"\3\2\2\2\u0214\u0215\3\2\2\2\u0215\u0223\3\2\2\2\u0216\u0214\3\2\2\2\u0217"+
"\u0221\7[\2\2\u0218\u021d\5V,\2\u0219\u021a\7\24\2\2\u021a\u021c\5V,\2"+
"\u021b\u0219\3\2\2\2\u021c\u021f\3\2\2\2\u021d\u021b\3\2\2\2\u021d\u021e"+
"\3\2\2\2\u021e\u0222\3\2\2\2\u021f\u021d\3\2\2\2\u0220\u0222\5X-\2\u0221"+
"\u0218\3\2\2\2\u0221\u0220\3\2\2\2\u0222\u0224\3\2\2\2\u0223\u0217\3\2"+
"\2\2\u0223\u0224\3\2\2\2\u0224\u0227\3\2\2\2\u0225\u0226\7\u00a0\2\2\u0226"+
"\u0228\5@!\2\u0227\u0225\3\2\2\2\u0227\u0228\3\2\2\2\u0228\u0237\3\2\2"+
"\2\u0229\u022a\7^\2\2\u022a\u022b\78\2\2\u022b\u0230\5@!\2\u022c\u022d"+
"\7\24\2\2\u022d\u022f\5@!\2\u022e\u022c\3\2\2\2\u022f\u0232\3\2\2\2\u0230"+
"\u022e\3\2\2\2\u0230\u0231\3\2\2\2\u0231\u0235\3\2\2\2\u0232\u0230\3\2"+
"\2\2\u0233\u0234\7_\2\2\u0234\u0236\5@!\2\u0235\u0233\3\2\2\2\u0235\u0236"+
"\3\2\2\2\u0236\u0238\3\2\2\2\u0237\u0229\3\2\2\2\u0237\u0238\3\2\2\2\u0238"+
"\u023c\3\2\2\2\u0239\u023a\7\u009d\2\2\u023a\u023c\5\60\31\2\u023b\u020b"+
"\3\2\2\2\u023b\u0239\3\2\2\2\u023c/\3\2\2\2\u023d\u023e\7\22\2\2\u023e"+
"\u0243\5@!\2\u023f\u0240\7\24\2\2\u0240\u0242\5@!\2\u0241\u023f\3\2\2"+
"\2\u0242\u0245\3\2\2\2\u0243\u0241\3\2\2\2\u0243\u0244\3\2\2\2\u0244\u0246"+
"\3\2\2\2\u0245\u0243\3\2\2\2\u0246\u0249\7\23\2\2\u0247\u0248\7\24\2\2"+
"\u0248\u024a\5\60\31\2\u0249\u0247\3\2\2\2\u0249\u024a\3\2\2\2\u024a\61"+
"\3\2\2\2\u024b\u024d\5J&\2\u024c\u024b\3\2\2\2\u024c\u024d\3\2\2\2\u024d"+
"\u024e\3\2\2\2\u024e\u0259\7\u009a\2\2\u024f\u0250\7{\2\2\u0250\u025a"+
"\7\u008c\2\2\u0251\u0252\7{\2\2\u0252\u025a\7)\2\2\u0253\u0254\7{\2\2"+
"\u0254\u025a\7\u0089\2\2\u0255\u0256\7{\2\2\u0256\u025a\7X\2\2\u0257\u0258"+
"\7{\2\2\u0258\u025a\7a\2\2\u0259\u024f\3\2\2\2\u0259\u0251\3\2\2\2\u0259"+
"\u0253\3\2\2\2\u0259\u0255\3\2\2\2\u0259\u0257\3\2\2\2\u0259\u025a\3\2"+
"\2\2\u025a\u025b\3\2\2\2\u025b\u025c\5p9\2\u025c\u025d\7\u0090\2\2\u025d"+
"\u025e\5v<\2\u025e\u025f\7\25\2\2\u025f\u0267\5@!\2\u0260\u0261\7\24\2"+
"\2\u0261\u0262\5v<\2\u0262\u0263\7\25\2\2\u0263\u0264\5@!\2\u0264\u0266"+
"\3\2\2\2\u0265\u0260\3\2\2\2\u0266\u0269\3\2\2\2\u0267\u0265\3\2\2\2\u0267"+
"\u0268\3\2\2\2\u0268\u026c\3\2\2\2\u0269\u0267\3\2\2\2\u026a\u026b\7\u00a0"+
"\2\2\u026b\u026d\5@!\2\u026c\u026a\3\2\2\2\u026c\u026d\3\2\2\2\u026d\63"+
"\3\2\2\2\u026e\u0270\5J&\2\u026f\u026e\3\2\2\2\u026f\u0270\3\2\2\2\u0270"+
"\u0271\3\2\2\2\u0271\u027c\7\u009a\2\2\u0272\u0273\7{\2\2\u0273\u027d"+
"\7\u008c\2\2\u0274\u0275\7{\2\2\u0275\u027d\7)\2\2\u0276\u0277\7{\2\2"+
"\u0277\u027d\7\u0089\2\2\u0278\u0279\7{\2\2\u0279\u027d\7X\2\2\u027a\u027b"+
"\7{\2\2\u027b\u027d\7a\2\2\u027c\u0272\3\2\2\2\u027c\u0274\3\2\2\2\u027c"+
"\u0276\3\2\2\2\u027c\u0278\3\2\2\2\u027c\u027a\3\2\2\2\u027c\u027d\3\2"+
"\2\2\u027d\u027e\3\2\2\2\u027e\u027f\5L\'\2\u027f\u0280\7\u0090\2\2\u0280"+
"\u0281\5v<\2\u0281\u0282\7\25\2\2\u0282\u028a\5@!\2\u0283\u0284\7\24\2"+
"\2\u0284\u0285\5v<\2\u0285\u0286\7\25\2\2\u0286\u0287\5@!\2\u0287\u0289"+
"\3\2\2\2\u0288\u0283\3\2\2\2\u0289\u028c\3\2\2\2\u028a\u0288\3\2\2\2\u028a"+
"\u028b\3\2\2\2\u028b\u028f\3\2\2\2\u028c\u028a\3\2\2\2\u028d\u028e\7\u00a0"+
"\2\2\u028e\u0290\5@!\2\u028f\u028d\3\2\2\2\u028f\u0290\3\2\2\2\u0290\u02a3"+
"\3\2\2\2\u0291\u0292\7|\2\2\u0292\u0293\78\2\2\u0293\u0298\5N(\2\u0294"+
"\u0295\7\24\2\2\u0295\u0297\5N(\2\u0296\u0294\3\2\2\2\u0297\u029a\3\2"+
"\2\2\u0298\u0296\3\2\2\2\u0298\u0299\3\2\2\2\u0299\u029c\3\2\2\2\u029a"+
"\u0298\3\2\2\2\u029b\u0291\3\2\2\2\u029b\u029c\3\2\2\2\u029c\u029d\3\2"+
"\2\2\u029d\u029e\7q\2\2\u029e\u02a1\5@!\2\u029f\u02a0\t\3\2\2\u02a0\u02a2"+
"\5@!\2\u02a1\u029f\3\2\2\2\u02a1\u02a2\3\2\2\2\u02a2\u02a4\3\2\2\2\u02a3"+
"\u029b\3\2\2\2\u02a3\u02a4\3\2\2\2\u02a4\65\3\2\2\2\u02a5\u02a6\7\u009c"+
"\2\2\u02a6\67\3\2\2\2\u02a7\u02a8\5v<\2\u02a8\u02ac\5:\36\2\u02a9\u02ab"+
"\5<\37\2\u02aa\u02a9\3\2\2\2\u02ab\u02ae\3\2\2\2\u02ac\u02aa\3\2\2\2\u02ac"+
"\u02ad\3\2\2\2\u02ad9\3\2\2\2\u02ae\u02ac\3\2\2\2\u02af\u02ba\5\u008a"+
"F\2\u02b0\u02b1\7\22\2\2\u02b1\u02b2\5`\61\2\u02b2\u02b3\7\23\2\2\u02b3"+
"\u02bb\3\2\2\2\u02b4\u02b5\7\22\2\2\u02b5\u02b6\5`\61\2\u02b6\u02b7\7"+
"\24\2\2\u02b7\u02b8\5`\61\2\u02b8\u02b9\7\23\2\2\u02b9\u02bb\3\2\2\2\u02ba"+
"\u02b0\3\2\2\2\u02ba\u02b4\3\2\2\2\u02ba\u02bb\3\2\2\2\u02bb\u02be\3\2"+
"\2\2\u02bc\u02bd\7\61\2\2\u02bd\u02bf\5\u008cG\2\u02be\u02bc\3\2\2\2\u02be"+
"\u02bf\3\2\2\2\u02bf;\3\2\2\2\u02c0\u02c1\7A\2\2\u02c1\u02c3\5l\67\2\u02c2"+
"\u02c0\3\2\2\2\u02c2\u02c3\3\2\2\2\u02c3\u02e4\3\2\2\2\u02c4\u02c6\7\u0080"+
"\2\2\u02c5\u02c7\t\5\2\2\u02c6\u02c5\3\2\2\2\u02c6\u02c7\3\2\2\2\u02c7"+
"\u02c8\3\2\2\2\u02c8\u02ca\5> \2\u02c9\u02cb\7\64\2\2\u02ca\u02c9\3\2"+
"\2\2\u02ca\u02cb\3\2\2\2\u02cb\u02e5\3\2\2\2\u02cc\u02ce\7u\2\2\u02cd"+
"\u02cc\3\2\2\2\u02cd\u02ce\3\2\2\2\u02ce\u02cf\3\2\2\2\u02cf\u02d0\7w"+
"\2\2\u02d0\u02e5\5> \2\u02d1\u02d2\7\u0099\2\2\u02d2\u02e5\5> \2\u02d3"+
"\u02d4\7<\2\2\u02d4\u02d5\7\22\2\2\u02d5\u02d6\5@!\2\u02d6\u02d7\7\23"+
"\2\2\u02d7\u02e5\3\2\2\2\u02d8\u02df\7H\2\2\u02d9\u02e0\5`\61\2\u02da"+
"\u02e0\5b\62\2\u02db\u02dc\7\22\2\2\u02dc\u02dd\5@!\2\u02dd\u02de\7\23"+
"\2\2\u02de\u02e0\3\2\2\2\u02df\u02d9\3\2\2\2\u02df\u02da\3\2\2\2\u02df"+
"\u02db\3\2\2\2\u02e0\u02e5\3\2\2\2\u02e1\u02e2\7=\2\2\u02e2\u02e5\5z>"+
"\2\u02e3\u02e5\5B\"\2\u02e4\u02c4\3\2\2\2\u02e4\u02cd\3\2\2\2\u02e4\u02d1"+
"\3\2\2\2\u02e4\u02d3\3\2\2\2\u02e4\u02d8\3\2\2\2\u02e4\u02e1\3\2\2\2\u02e4"+
"\u02e3\3\2\2\2\u02e5=\3\2\2\2\u02e6\u02e7\7z\2\2\u02e7\u02e8\7@\2\2\u02e8"+
"\u02ea\t\6\2\2\u02e9\u02e6\3\2\2\2\u02e9\u02ea\3\2\2\2\u02ea?\3\2\2\2"+
"\u02eb\u02ec\b!\1\2\u02ec\u02ed\5d\63\2\u02ed\u02ee\5@!\27\u02ee\u0333"+
"\3\2\2\2\u02ef\u0333\5b\62\2\u02f0\u0333\7\u00a5\2\2\u02f1\u02f2\5p9\2"+
"\u02f2\u02f3\7\21\2\2\u02f3\u02f5\3\2\2\2\u02f4\u02f1\3\2\2\2\u02f4\u02f5"+
"\3\2\2\2\u02f5\u02f6\3\2\2\2\u02f6\u0333\5v<\2\u02f7\u02f8\5n8\2\u02f8"+
"\u0305\7\22\2\2\u02f9\u02fb\7N\2\2\u02fa\u02f9\3\2\2\2\u02fa\u02fb\3\2"+
"\2\2\u02fb\u02fc\3\2\2\2\u02fc\u0301\5@!\2\u02fd\u02fe\7\24\2\2\u02fe"+
"\u0300\5@!\2\u02ff\u02fd\3\2\2\2\u0300\u0303\3\2\2\2\u0301\u02ff\3\2\2"+
"\2\u0301\u0302\3\2\2\2\u0302\u0306\3\2\2\2\u0303\u0301\3\2\2\2\u0304\u0306"+
"\7\26\2\2\u0305\u02fa\3\2\2\2\u0305\u0304\3\2\2\2\u0305\u0306\3\2\2\2"+
"\u0306\u0307\3\2\2\2\u0307\u0308\7\23\2\2\u0308\u0333\3\2\2\2\u0309\u030a"+
"\7\22\2\2\u030a\u030b\5@!\2\u030b\u030c\7\23\2\2\u030c\u0333\3\2\2\2\u030d"+
"\u030e\7;\2\2\u030e\u030f\7\22\2\2\u030f\u0310\5@!\2\u0310\u0311\7\61"+
"\2\2\u0311\u0312\5:\36\2\u0312\u0313\7\23\2\2\u0313\u0333\3\2\2\2\u0314"+
"\u0316\7u\2\2\u0315\u0314\3\2\2\2\u0315\u0316\3\2\2\2\u0316\u0317\3\2"+
"\2\2\u0317\u0319\7V\2\2\u0318\u0315\3\2\2\2\u0318\u0319\3\2\2\2\u0319"+
"\u031a\3\2\2\2\u031a\u031b\7\22\2\2\u031b\u031c\5,\27\2\u031c\u031d\7"+
"\23\2\2\u031d\u0333\3\2\2\2\u031e\u0320\7:\2\2\u031f\u0321\5@!\2\u0320"+
"\u031f\3\2\2\2\u0320\u0321\3\2\2\2\u0321\u0327\3\2\2\2\u0322\u0323\7\u009f"+
"\2\2\u0323\u0324\5@!\2\u0324\u0325\7\u0094\2\2\u0325\u0326\5@!\2\u0326"+
"\u0328\3\2\2\2\u0327\u0322\3\2\2\2\u0328\u0329\3\2\2\2\u0329\u0327\3\2"+
"\2\2\u0329\u032a\3\2\2\2\u032a\u032d\3\2\2\2\u032b\u032c\7Q\2\2\u032c"+
"\u032e\5@!\2\u032d\u032b\3\2\2\2\u032d\u032e\3\2\2\2\u032e\u032f\3\2\2"+
"\2\u032f\u0330\7R\2\2\u0330\u0333\3\2\2\2\u0331\u0333\5D#\2\u0332\u02eb"+
"\3\2\2\2\u0332\u02ef\3\2\2\2\u0332\u02f0\3\2\2\2\u0332\u02f4\3\2\2\2\u0332"+
"\u02f7\3\2\2\2\u0332\u0309\3\2\2\2\u0332\u030d\3\2\2\2\u0332\u0318\3\2"+
"\2\2\u0332\u031e\3\2\2\2\u0332\u0331\3\2\2\2\u0333\u0386\3\2\2\2\u0334"+
"\u0335\f\26\2\2\u0335\u0336\7\32\2\2\u0336\u0385\5@!\27\u0337\u0338\f"+
"\25\2\2\u0338\u0339\t\7\2\2\u0339\u0385\5@!\26\u033a\u033b\f\24\2\2\u033b"+
"\u033c\t\b\2\2\u033c\u0385\5@!\25\u033d\u033e\f\23\2\2\u033e\u033f\t\t"+
"\2\2\u033f\u0385\5@!\24\u0340\u0341\f\22\2\2\u0341\u0342\t\n\2\2\u0342"+
"\u0385\5@!\23\u0343\u0344\f\21\2\2\u0344\u0345\t\13\2\2\u0345\u0385\5"+
"@!\22\u0346\u0347\f\20\2\2\u0347\u0348\7\60\2\2\u0348\u0385\5@!\21\u0349"+
"\u034a\f\17\2\2\u034a\u034b\7{\2\2\u034b\u0385\5@!\20\u034c\u034d\f\b"+
"\2\2\u034d\u034f\7l\2\2\u034e\u0350\7u\2\2\u034f\u034e\3\2\2\2\u034f\u0350"+
"\3\2\2\2\u0350\u0351\3\2\2\2\u0351\u0385\5@!\t\u0352\u0354\f\7\2\2\u0353"+
"\u0355\7u\2\2\u0354\u0353\3\2\2\2\u0354\u0355\3\2\2\2\u0355\u0356\3\2"+
"\2\2\u0356\u0357\7\67\2\2\u0357\u0358\5@!\2\u0358\u0359\7\60\2\2\u0359"+
"\u035a\5@!\b\u035a\u0385\3\2\2\2\u035b\u035c\f\13\2\2\u035c\u035d\7=\2"+
"\2\u035d\u0385\5z>\2\u035e\u0360\f\n\2\2\u035f\u0361\7u\2\2\u0360\u035f"+
"\3\2\2\2\u0360\u0361\3\2\2\2\u0361\u0362\3\2\2\2\u0362\u0363\t\f\2\2\u0363"+
"\u0366\5@!\2\u0364\u0365\7S\2\2\u0365\u0367\5@!\2\u0366\u0364\3\2\2\2"+
"\u0366\u0367\3\2\2\2\u0367\u0385\3\2\2\2\u0368\u036d\f\t\2\2\u0369\u036e"+
"\7m\2\2\u036a\u036e\7v\2\2\u036b\u036c\7u\2\2\u036c\u036e\7w\2\2\u036d"+
"\u0369\3\2\2\2\u036d\u036a\3\2\2\2\u036d\u036b\3\2\2\2\u036e\u0385\3\2"+
"\2\2\u036f\u0371\f\6\2\2\u0370\u0372\7u\2\2\u0371\u0370\3\2\2\2\u0371"+
"\u0372\3\2\2\2\u0372\u0373\3\2\2\2\u0373\u0382\7c\2\2\u0374\u037e\7\22"+
"\2\2\u0375\u037f\5,\27\2\u0376\u037b\5@!\2\u0377\u0378\7\24\2\2\u0378"+
"\u037a\5@!\2\u0379\u0377\3\2\2\2\u037a\u037d\3\2\2\2\u037b\u0379\3\2\2"+
"\2\u037b\u037c\3\2\2\2\u037c\u037f\3\2\2\2\u037d\u037b\3\2\2\2\u037e\u0375"+
"\3\2\2\2\u037e\u0376\3\2\2\2\u037e\u037f\3\2\2\2\u037f\u0380\3\2\2\2\u0380"+
"\u0383\7\23\2\2\u0381\u0383\5p9\2\u0382\u0374\3\2\2\2\u0382\u0381\3\2"+
"\2\2\u0383\u0385\3\2\2\2\u0384\u0334\3\2\2\2\u0384\u0337\3\2\2\2\u0384"+
"\u033a\3\2\2\2\u0384\u033d\3\2\2\2\u0384\u0340\3\2\2\2\u0384\u0343\3\2"+
"\2\2\u0384\u0346\3\2\2\2\u0384\u0349\3\2\2\2\u0384\u034c\3\2\2\2\u0384"+
"\u0352\3\2\2\2\u0384\u035b\3\2\2\2\u0384\u035e\3\2\2\2\u0384\u0368\3\2"+
"\2\2\u0384\u036f\3\2\2\2\u0385\u0388\3\2\2\2\u0386\u0384\3\2\2\2\u0386"+
"\u0387\3\2\2\2\u0387A\3\2\2\2\u0388\u0386\3\2\2\2\u0389\u038a\7\u0084"+
"\2\2\u038a\u0396\5|?\2\u038b\u038c\7\22\2\2\u038c\u0391\5v<\2\u038d\u038e"+
"\7\24\2\2\u038e\u0390\5v<\2\u038f\u038d\3\2\2\2\u0390\u0393\3\2\2\2\u0391"+
"\u038f\3\2\2\2\u0391\u0392\3\2\2\2\u0392\u0394\3\2\2\2\u0393\u0391\3\2"+
"\2\2\u0394\u0395\7\23\2\2\u0395\u0397\3\2\2\2\u0396\u038b\3\2\2\2\u0396"+
"\u0397\3\2\2\2\u0397\u03aa\3\2\2\2\u0398\u0399\7z\2\2\u0399\u03a2\t\r"+
"\2\2\u039a\u039b\7\u0090\2\2\u039b\u03a3\7w\2\2\u039c\u039d\7\u0090\2"+
"\2\u039d\u03a3\7H\2\2\u039e\u03a3\79\2\2\u039f\u03a3\7\u008a\2\2\u03a0"+
"\u03a1\7t\2\2\u03a1\u03a3\7*\2\2\u03a2\u039a\3\2\2\2\u03a2\u039c\3\2\2"+
"\2\u03a2\u039e\3\2\2\2\u03a2\u039f\3\2\2\2\u03a2\u03a0\3\2\2\2\u03a3\u03a7"+
"\3\2\2\2\u03a4\u03a5\7r\2\2\u03a5\u03a7\5l\67\2\u03a6\u0398\3\2\2\2\u03a6"+
"\u03a4\3\2\2\2\u03a7\u03a9\3\2\2\2\u03a8\u03a6\3\2\2\2\u03a9\u03ac\3\2"+
"\2\2\u03aa\u03a8\3\2\2\2\u03aa\u03ab\3\2\2\2\u03ab\u03b7\3\2\2\2\u03ac"+
"\u03aa\3\2\2\2\u03ad\u03af\7u\2\2\u03ae\u03ad\3\2\2\2\u03ae\u03af\3\2"+
"\2\2\u03af\u03b0\3\2\2\2\u03b0\u03b5\7I\2\2\u03b1\u03b2\7f\2\2\u03b2\u03b6"+
"\7J\2\2\u03b3\u03b4\7f\2\2\u03b4\u03b6\7b\2\2\u03b5\u03b1\3\2\2\2\u03b5"+
"\u03b3\3\2\2\2\u03b5\u03b6\3\2\2\2\u03b6\u03b8\3\2\2\2\u03b7\u03ae\3\2"+
"\2\2\u03b7\u03b8\3\2\2\2\u03b8C\3\2\2\2\u03b9\u03ba\7\u0082\2\2\u03ba"+
"\u03bf\7\22\2\2\u03bb\u03c0\7a\2\2\u03bc\u03bd\t\16\2\2\u03bd\u03be\7"+
"\24\2\2\u03be\u03c0\5f\64\2\u03bf\u03bb\3\2\2\2\u03bf\u03bc\3\2\2\2\u03c0"+
"\u03c1\3\2\2\2\u03c1\u03c2\7\23\2\2\u03c2E\3\2\2\2\u03c3\u03c6\5v<\2\u03c4"+
"\u03c5\7=\2\2\u03c5\u03c7\5z>\2\u03c6\u03c4\3\2\2\2\u03c6\u03c7\3\2\2"+
"\2\u03c7\u03c9\3\2\2\2\u03c8\u03ca\t\5\2\2\u03c9\u03c8\3\2\2\2\u03c9\u03ca"+
"\3\2\2\2\u03caG\3\2\2\2\u03cb\u03cc\7A\2\2\u03cc\u03ce\5l\67\2\u03cd\u03cb"+
"\3\2\2\2\u03cd\u03ce\3\2\2\2\u03ce\u03ee\3\2\2\2\u03cf\u03d0\t\17\2\2"+
"\u03d0\u03d1\7\22\2\2\u03d1\u03d6\5F$\2\u03d2\u03d3\7\24\2\2\u03d3\u03d5"+
"\5F$\2\u03d4\u03d2\3\2\2\2\u03d5\u03d8\3\2\2\2\u03d6\u03d4\3\2\2\2\u03d6"+
"\u03d7\3\2\2\2\u03d7\u03d9\3\2\2\2\u03d8\u03d6\3\2\2\2\u03d9\u03da\7\23"+
"\2\2\u03da\u03db\5> \2\u03db\u03ef\3\2\2\2\u03dc\u03dd\7<\2\2\u03dd\u03de"+
"\7\22\2\2\u03de\u03df\5@!\2\u03df\u03e0\7\23\2\2\u03e0\u03ef\3\2\2\2\u03e1"+
"\u03e2\7Z\2\2\u03e2\u03e3\7\22\2\2\u03e3\u03e8\5v<\2\u03e4\u03e5\7\24"+
"\2\2\u03e5\u03e7\5v<\2\u03e6\u03e4\3\2\2\2\u03e7\u03ea\3\2\2\2\u03e8\u03e6"+
"\3\2\2\2\u03e8\u03e9\3\2\2\2\u03e9\u03eb\3\2\2\2\u03ea\u03e8\3\2\2\2\u03eb"+
"\u03ec\7\23\2\2\u03ec\u03ed\5B\"\2\u03ed\u03ef\3\2\2\2\u03ee\u03cf\3\2"+
"\2\2\u03ee\u03dc\3\2\2\2\u03ee\u03e1\3\2\2\2\u03efI\3\2\2\2\u03f0\u03f2"+
"\7\u00a1\2\2\u03f1\u03f3\7\u0083\2\2\u03f2\u03f1\3\2\2\2\u03f2\u03f3\3"+
"\2\2\2\u03f3\u03f4\3\2\2\2\u03f4\u03f9\5R*\2\u03f5\u03f6\7\24\2\2\u03f6"+
"\u03f8\5R*\2\u03f7\u03f5\3\2\2\2\u03f8\u03fb\3\2\2\2\u03f9\u03f7\3\2\2"+
"\2\u03f9\u03fa\3\2\2\2\u03faK\3\2\2\2\u03fb\u03f9\3\2\2\2\u03fc\u0402"+
"\5p9\2\u03fd\u03fe\7e\2\2\u03fe\u03ff\78\2\2\u03ff\u0403\5~@\2\u0400\u0401"+
"\7u\2\2\u0401\u0403\7e\2\2\u0402\u03fd\3\2\2\2\u0402\u0400\3\2\2\2\u0402"+
"\u0403\3\2\2\2\u0403M\3\2\2\2\u0404\u0407\5@!\2\u0405\u0406\7=\2\2\u0406"+
"\u0408\5z>\2\u0407\u0405\3\2\2\2\u0407\u0408\3\2\2\2\u0408\u040a\3\2\2"+
"\2\u0409\u040b\t\5\2\2\u040a\u0409\3\2\2\2\u040a\u040b\3\2\2\2\u040bO"+
"\3\2\2\2\u040c\u0410\5`\61\2\u040d\u0410\5l\67\2\u040e\u0410\7\u00a6\2"+
"\2\u040f\u040c\3\2\2\2\u040f\u040d\3\2\2\2\u040f\u040e\3\2\2\2\u0410Q"+
"\3\2\2\2\u0411\u041d\5p9\2\u0412\u0413\7\22\2\2\u0413\u0418\5v<\2\u0414"+
"\u0415\7\24\2\2\u0415\u0417\5v<\2\u0416\u0414\3\2\2\2\u0417\u041a\3\2"+
"\2\2\u0418\u0416\3\2\2\2\u0418\u0419\3\2\2\2\u0419\u041b\3\2\2\2\u041a"+
"\u0418\3\2\2\2\u041b\u041c\7\23\2\2\u041c\u041e\3\2\2\2\u041d\u0412\3"+
"\2\2\2\u041d\u041e\3\2\2\2\u041e\u041f\3\2\2\2\u041f\u0420\7\61\2\2\u0420"+
"\u0421\7\22\2\2\u0421\u0422\5,\27\2\u0422\u0423\7\23\2\2\u0423S\3\2\2"+
"\2\u0424\u0431\7\26\2\2\u0425\u0426\5p9\2\u0426\u0427\7\21\2\2\u0427\u0428"+
"\7\26\2\2\u0428\u0431\3\2\2\2\u0429\u042e\5@!\2\u042a\u042c\7\61\2\2\u042b"+
"\u042a\3\2\2\2\u042b\u042c\3\2\2\2\u042c\u042d\3\2\2\2\u042d\u042f\5h"+
"\65\2\u042e\u042b\3\2\2\2\u042e\u042f\3\2\2\2\u042f\u0431\3\2\2\2\u0430"+
"\u0424\3\2\2\2\u0430\u0425\3\2\2\2\u0430\u0429\3\2\2\2\u0431U\3\2\2\2"+
"\u0432\u0437\5p9\2\u0433\u0435\7\61\2\2\u0434\u0433\3\2\2\2\u0434\u0435"+
"\3\2\2\2\u0435\u0436\3\2\2\2\u0436\u0438\5\u0088E\2\u0437\u0434\3\2\2"+
"\2\u0437\u0438\3\2\2\2\u0438\u043e\3\2\2\2\u0439\u043a\7e\2\2\u043a\u043b"+
"\78\2\2\u043b\u043f\5~@\2\u043c\u043d\7u\2\2\u043d\u043f\7e\2\2\u043e"+
"\u0439\3\2\2\2\u043e\u043c\3\2\2\2\u043e\u043f\3\2\2\2\u043f\u0458\3\2"+
"\2\2\u0440\u044a\7\22\2\2\u0441\u0446\5V,\2\u0442\u0443\7\24\2\2\u0443"+
"\u0445\5V,\2\u0444\u0442\3\2\2\2\u0445\u0448\3\2\2\2\u0446\u0444\3\2\2"+
"\2\u0446\u0447\3\2\2\2\u0447\u044b\3\2\2\2\u0448\u0446\3\2\2\2\u0449\u044b"+
"\5X-\2\u044a\u0441\3\2\2\2\u044a\u0449\3\2\2\2\u044b\u044c\3\2\2\2\u044c"+
"\u044d\7\23\2\2\u044d\u0458\3\2\2\2\u044e\u044f\7\22\2\2\u044f\u0450\5"+
",\27\2\u0450\u0455\7\23\2\2\u0451\u0453\7\61\2\2\u0452\u0451\3\2\2\2\u0452"+
"\u0453\3\2\2\2\u0453\u0454\3\2\2\2\u0454\u0456\5\u0088E\2\u0455\u0452"+
"\3\2\2\2\u0455\u0456\3\2\2\2\u0456\u0458\3\2\2\2\u0457\u0432\3\2\2\2\u0457"+
"\u0440\3\2\2\2\u0457\u044e\3\2\2\2\u0458W\3\2\2\2\u0459\u0460\5V,\2\u045a"+
"\u045b\5Z.\2\u045b\u045c\5V,\2\u045c\u045d\5\\/\2\u045d\u045f\3\2\2\2"+
"\u045e\u045a\3\2\2\2\u045f\u0462\3\2\2\2\u0460\u045e\3\2\2\2\u0460\u0461"+
"\3\2\2\2\u0461Y\3\2\2\2\u0462\u0460\3\2\2\2\u0463\u0471\7\24\2\2\u0464"+
"\u0466\7s\2\2\u0465\u0464\3\2\2\2\u0465\u0466\3\2\2\2\u0466\u046d\3\2"+
"\2\2\u0467\u0469\7o\2\2\u0468\u046a\7}\2\2\u0469\u0468\3\2\2\2\u0469\u046a"+
"\3\2\2\2\u046a\u046e\3\2\2\2\u046b\u046e\7g\2\2\u046c\u046e\7C\2\2\u046d"+
"\u0467\3\2\2\2\u046d\u046b\3\2\2\2\u046d\u046c\3\2\2\2\u046d\u046e\3\2"+
"\2\2\u046e\u046f\3\2\2\2\u046f\u0471\7n\2\2\u0470\u0463\3\2\2\2\u0470"+
"\u0465\3\2\2\2\u0471[\3\2\2\2\u0472\u0473\7z\2\2\u0473\u0481\5@!\2\u0474"+
"\u0475\7\u009b\2\2\u0475\u0476\7\22\2\2\u0476\u047b\5v<\2\u0477\u0478"+
"\7\24\2\2\u0478\u047a\5v<\2\u0479\u0477\3\2\2\2\u047a\u047d\3\2\2\2\u047b"+
"\u0479\3\2\2\2\u047b\u047c\3\2\2\2\u047c\u047e\3\2\2\2\u047d\u047b\3\2"+
"\2\2\u047e\u047f\7\23\2\2\u047f\u0481\3\2\2\2\u0480\u0472\3\2\2\2\u0480"+
"\u0474\3\2\2\2\u0480\u0481\3\2\2\2\u0481]\3\2\2\2\u0482\u0488\7\u0098"+
"\2\2\u0483\u0484\7\u0098\2\2\u0484\u0488\7-\2\2\u0485\u0488\7j\2\2\u0486"+
"\u0488\7T\2\2\u0487\u0482\3\2\2\2\u0487\u0483\3\2\2\2\u0487\u0485\3\2"+
"\2\2\u0487\u0486\3\2\2\2\u0488_\3\2\2\2\u0489\u048b\t\b\2\2\u048a\u0489"+
"\3\2\2\2\u048a\u048b\3\2\2\2\u048b\u048c\3\2\2\2\u048c\u048d\7\u00a4\2"+
"\2\u048da\3\2\2\2\u048e\u048f\t\20\2\2\u048fc\3\2\2\2\u0490\u0491\t\21"+
"\2\2\u0491e\3\2\2\2\u0492\u0493\7\u00a6\2\2\u0493g\3\2\2\2\u0494\u0495"+
"\7\u00a3\2\2\u0495i\3\2\2\2\u0496\u0497\t\22\2\2\u0497k\3\2\2\2\u0498"+
"\u0499\5\u008eH\2\u0499m\3\2\2\2\u049a\u049b\5\u008eH\2\u049bo\3\2\2\2"+
"\u049c\u049d\7\u00a3\2\2\u049dq\3\2\2\2\u049e\u049f\5\u008eH\2\u049fs"+
"\3\2\2\2\u04a0\u04a1\5\u008eH\2\u04a1u\3\2\2\2\u04a2\u04a3\7\u00a3\2\2"+
"\u04a3w\3\2\2\2\u04a4\u04a5\7\u00a3\2\2\u04a5y\3\2\2\2\u04a6\u04a7\5\u008e"+
"H\2\u04a7{\3\2\2\2\u04a8\u04a9\5\u008eH\2\u04a9}\3\2\2\2\u04aa\u04ab\5"+
"\u008eH\2\u04ab\177\3\2\2\2\u04ac\u04ad\5\u008eH\2\u04ad\u0081\3\2\2\2"+
"\u04ae\u04af\7\u00a3\2\2\u04af\u0083\3\2\2\2\u04b0\u04b1\5\u008eH\2\u04b1"+
"\u0085\3\2\2\2\u04b2\u04b3\5\u008eH\2\u04b3\u0087\3\2\2\2\u04b4\u04b5"+
"\7\u00a3\2\2\u04b5\u0089\3\2\2\2\u04b6\u04b7\t\23\2\2\u04b7\u008b\3\2"+
"\2\2\u04b8\u04b9\t\24\2\2\u04b9\u008d\3\2\2\2\u04ba\u04c1\7\u00a3\2\2"+
"\u04bb\u04c1\7\u00a6\2\2\u04bc\u04bd\7\22\2\2\u04bd\u04be\5\u008eH\2\u04be"+
"\u04bf\7\23\2\2\u04bf\u04c1\3\2\2\2\u04c0\u04ba\3\2\2\2\u04c0\u04bb\3"+
"\2\2\2\u04c0\u04bc\3\2\2\2\u04c1\u008f\3\2\2\2\u009e\u0092\u009b\u00a2"+
"\u00aa\u00ac\u00c2\u00cc\u00cf\u00d6\u00dc\u00e7\u00ed\u00f1\u00f7\u0100"+
"\u0107\u010d\u0111\u0115\u011b\u0122\u012d\u0130\u0132\u0139\u013d\u0144"+
"\u014a\u0150\u0156\u015d\u0164\u0167\u016e\u0177\u017a\u0180\u0182\u0188"+
"\u0190\u0198\u01a0\u01a5\u01b8\u01c2\u01c7\u01ce\u01d8\u01de\u01e0\u01e4"+
"\u01ec\u01f4\u01fe\u0201\u0207\u0209\u020d\u0214\u021d\u0221\u0223\u0227"+
"\u0230\u0235\u0237\u023b\u0243\u0249\u024c\u0259\u0267\u026c\u026f\u027c"+
"\u028a\u028f\u0298\u029b\u02a1\u02a3\u02ac\u02ba\u02be\u02c2\u02c6\u02ca"+
"\u02cd\u02df\u02e4\u02e9\u02f4\u02fa\u0301\u0305\u0315\u0318\u0320\u0329"+
"\u032d\u0332\u034f\u0354\u0360\u0366\u036d\u0371\u037b\u037e\u0382\u0384"+
"\u0386\u0391\u0396\u03a2\u03a6\u03aa\u03ae\u03b5\u03b7\u03bf\u03c6\u03c9"+
"\u03cd\u03d6\u03e8\u03ee\u03f2\u03f9\u0402\u0407\u040a\u040f\u0418\u041d"+
"\u042b\u042e\u0430\u0434\u0437\u043e\u0446\u044a\u0452\u0455\u0457\u0460"+
"\u0465\u0469\u046d\u0470\u047b\u0480\u0487\u048a\u04c0";
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