org.eclipse.jnosql.query.grammar.QueryParser Maven / Gradle / Ivy
// Generated from org/eclipse/jnosql/query/grammar/Query.g4 by ANTLR 4.12.0
package org.eclipse.jnosql.query.grammar;
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast", "CheckReturnValue"})
public class QueryParser extends Parser {
static { RuntimeMetaData.checkVersion("4.12.0", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9,
T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17,
T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, T__23=24,
T__24=25, T__25=26, T__26=27, T__27=28, T__28=29, T__29=30, T__30=31,
T__31=32, T__32=33, T__33=34, T__34=35, T__35=36, T__36=37, T__37=38,
T__38=39, T__39=40, T__40=41, T__41=42, T__42=43, T__43=44, STRING=45,
INT=46, NUMBER=47, BOOLEAN=48, ANY_NAME=49, PARAMETER=50, WS=51, SL_COMMENT=52;
public static final int
RULE_select = 0, RULE_delete = 1, RULE_insert = 2, RULE_update = 3, RULE_get = 4,
RULE_del = 5, RULE_put = 6, RULE_fields = 7, RULE_deleteFields = 8, RULE_conditions = 9,
RULE_star = 10, RULE_skip = 11, RULE_limit = 12, RULE_order = 13, RULE_orderName = 14,
RULE_where = 15, RULE_condition = 16, RULE_eq = 17, RULE_gt = 18, RULE_gte = 19,
RULE_lt = 20, RULE_lte = 21, RULE_between = 22, RULE_in = 23, RULE_like = 24,
RULE_not = 25, RULE_asc = 26, RULE_desc = 27, RULE_and = 28, RULE_or = 29,
RULE_ttl = 30, RULE_unit = 31, RULE_changes = 32, RULE_change = 33, RULE_key = 34,
RULE_keys = 35, RULE_value = 36, RULE_value_string = 37, RULE_name = 38,
RULE_entity = 39, RULE_array = 40, RULE_function = 41, RULE_convert = 42,
RULE_element = 43, RULE_number = 44, RULE_string = 45, RULE_bool = 46,
RULE_json = 47, RULE_object_json = 48, RULE_pair_json = 49, RULE_value_json = 50,
RULE_array_json = 51, RULE_parameter = 52;
private static String[] makeRuleNames() {
return new String[] {
"select", "delete", "insert", "update", "get", "del", "put", "fields",
"deleteFields", "conditions", "star", "skip", "limit", "order", "orderName",
"where", "condition", "eq", "gt", "gte", "lt", "lte", "between", "in",
"like", "not", "asc", "desc", "and", "or", "ttl", "unit", "changes",
"change", "key", "keys", "value", "value_string", "name", "entity", "array",
"function", "convert", "element", "number", "string", "bool", "json",
"object_json", "pair_json", "value_json", "array_json", "parameter"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, "'select'", "'from'", "'delete'", "'insert'", "'update'", "'get'",
"'del'", "'put'", "'{'", "','", "'}'", "'('", "')'", "'*'", "'skip'",
"'limit'", "'order'", "'by'", "'where'", "'='", "'>'", "'>='", "'<'",
"'<='", "'between'", "'and'", "'in'", "'like'", "'not'", "'asc'", "'desc'",
"'or'", "'day'", "'hour'", "'minute'", "'second'", "'millisecond'", "'nanosecond'",
"'convert('", "'-'", "':'", "'null'", "'['", "']'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, "STRING", "INT",
"NUMBER", "BOOLEAN", "ANY_NAME", "PARAMETER", "WS", "SL_COMMENT"
};
}
private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
/**
* @deprecated Use {@link #VOCABULARY} instead.
*/
@Deprecated
public static final String[] tokenNames;
static {
tokenNames = new String[_SYMBOLIC_NAMES.length];
for (int i = 0; i < tokenNames.length; i++) {
tokenNames[i] = VOCABULARY.getLiteralName(i);
if (tokenNames[i] == null) {
tokenNames[i] = VOCABULARY.getSymbolicName(i);
}
if (tokenNames[i] == null) {
tokenNames[i] = "";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "Query.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public QueryParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
@SuppressWarnings("CheckReturnValue")
public static class SelectContext extends ParserRuleContext {
public FieldsContext fields() {
return getRuleContext(FieldsContext.class,0);
}
public EntityContext entity() {
return getRuleContext(EntityContext.class,0);
}
public TerminalNode EOF() { return getToken(QueryParser.EOF, 0); }
public WhereContext where() {
return getRuleContext(WhereContext.class,0);
}
public SkipContext skip() {
return getRuleContext(SkipContext.class,0);
}
public LimitContext limit() {
return getRuleContext(LimitContext.class,0);
}
public OrderContext order() {
return getRuleContext(OrderContext.class,0);
}
public SelectContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_select; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterSelect(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitSelect(this);
}
}
public final SelectContext select() throws RecognitionException {
SelectContext _localctx = new SelectContext(_ctx, getState());
enterRule(_localctx, 0, RULE_select);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(106);
match(T__0);
setState(107);
fields();
setState(108);
match(T__1);
setState(109);
entity();
setState(111);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__18) {
{
setState(110);
where();
}
}
setState(114);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__14) {
{
setState(113);
skip();
}
}
setState(117);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__15) {
{
setState(116);
limit();
}
}
setState(120);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__16) {
{
setState(119);
order();
}
}
setState(122);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DeleteContext extends ParserRuleContext {
public EntityContext entity() {
return getRuleContext(EntityContext.class,0);
}
public TerminalNode EOF() { return getToken(QueryParser.EOF, 0); }
public DeleteFieldsContext deleteFields() {
return getRuleContext(DeleteFieldsContext.class,0);
}
public WhereContext where() {
return getRuleContext(WhereContext.class,0);
}
public DeleteContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_delete; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterDelete(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitDelete(this);
}
}
public final DeleteContext delete() throws RecognitionException {
DeleteContext _localctx = new DeleteContext(_ctx, getState());
enterRule(_localctx, 2, RULE_delete);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(124);
match(T__2);
setState(126);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ANY_NAME) {
{
setState(125);
deleteFields();
}
}
setState(128);
match(T__1);
setState(129);
entity();
setState(131);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__18) {
{
setState(130);
where();
}
}
setState(133);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class InsertContext extends ParserRuleContext {
public EntityContext entity() {
return getRuleContext(EntityContext.class,0);
}
public TerminalNode EOF() { return getToken(QueryParser.EOF, 0); }
public ConditionsContext conditions() {
return getRuleContext(ConditionsContext.class,0);
}
public JsonContext json() {
return getRuleContext(JsonContext.class,0);
}
public TtlContext ttl() {
return getRuleContext(TtlContext.class,0);
}
public InsertContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_insert; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterInsert(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitInsert(this);
}
}
public final InsertContext insert() throws RecognitionException {
InsertContext _localctx = new InsertContext(_ctx, getState());
enterRule(_localctx, 4, RULE_insert);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(135);
match(T__3);
setState(136);
entity();
setState(139);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__11:
{
setState(137);
conditions();
}
break;
case T__8:
case T__42:
{
setState(138);
json();
}
break;
default:
throw new NoViableAltException(this);
}
setState(142);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==INT) {
{
setState(141);
ttl();
}
}
setState(144);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UpdateContext extends ParserRuleContext {
public EntityContext entity() {
return getRuleContext(EntityContext.class,0);
}
public TerminalNode EOF() { return getToken(QueryParser.EOF, 0); }
public ConditionsContext conditions() {
return getRuleContext(ConditionsContext.class,0);
}
public JsonContext json() {
return getRuleContext(JsonContext.class,0);
}
public UpdateContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_update; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterUpdate(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitUpdate(this);
}
}
public final UpdateContext update() throws RecognitionException {
UpdateContext _localctx = new UpdateContext(_ctx, getState());
enterRule(_localctx, 6, RULE_update);
try {
enterOuterAlt(_localctx, 1);
{
setState(146);
match(T__4);
setState(147);
entity();
setState(150);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__11:
{
setState(148);
conditions();
}
break;
case T__8:
case T__42:
{
setState(149);
json();
}
break;
default:
throw new NoViableAltException(this);
}
setState(152);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GetContext extends ParserRuleContext {
public KeysContext keys() {
return getRuleContext(KeysContext.class,0);
}
public TerminalNode EOF() { return getToken(QueryParser.EOF, 0); }
public GetContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_get; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterGet(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitGet(this);
}
}
public final GetContext get() throws RecognitionException {
GetContext _localctx = new GetContext(_ctx, getState());
enterRule(_localctx, 8, RULE_get);
try {
enterOuterAlt(_localctx, 1);
{
setState(154);
match(T__5);
setState(155);
keys();
setState(156);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DelContext extends ParserRuleContext {
public KeysContext keys() {
return getRuleContext(KeysContext.class,0);
}
public TerminalNode EOF() { return getToken(QueryParser.EOF, 0); }
public DelContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_del; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterDel(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitDel(this);
}
}
public final DelContext del() throws RecognitionException {
DelContext _localctx = new DelContext(_ctx, getState());
enterRule(_localctx, 10, RULE_del);
try {
enterOuterAlt(_localctx, 1);
{
setState(158);
match(T__6);
setState(159);
keys();
setState(160);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class PutContext extends ParserRuleContext {
public KeyContext key() {
return getRuleContext(KeyContext.class,0);
}
public ValueContext value() {
return getRuleContext(ValueContext.class,0);
}
public TerminalNode EOF() { return getToken(QueryParser.EOF, 0); }
public TtlContext ttl() {
return getRuleContext(TtlContext.class,0);
}
public PutContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_put; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterPut(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitPut(this);
}
}
public final PutContext put() throws RecognitionException {
PutContext _localctx = new PutContext(_ctx, getState());
enterRule(_localctx, 12, RULE_put);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(162);
match(T__7);
setState(163);
match(T__8);
setState(164);
key();
setState(165);
match(T__9);
setState(166);
value();
setState(169);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__9) {
{
setState(167);
match(T__9);
setState(168);
ttl();
}
}
setState(171);
match(T__10);
setState(172);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FieldsContext extends ParserRuleContext {
public StarContext star() {
return getRuleContext(StarContext.class,0);
}
public List name() {
return getRuleContexts(NameContext.class);
}
public NameContext name(int i) {
return getRuleContext(NameContext.class,i);
}
public FieldsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fields; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterFields(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitFields(this);
}
}
public final FieldsContext fields() throws RecognitionException {
FieldsContext _localctx = new FieldsContext(_ctx, getState());
enterRule(_localctx, 14, RULE_fields);
int _la;
try {
setState(183);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__13:
enterOuterAlt(_localctx, 1);
{
setState(174);
star();
}
break;
case ANY_NAME:
enterOuterAlt(_localctx, 2);
{
setState(175);
name();
setState(180);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__9) {
{
{
setState(176);
match(T__9);
setState(177);
name();
}
}
setState(182);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DeleteFieldsContext extends ParserRuleContext {
public List name() {
return getRuleContexts(NameContext.class);
}
public NameContext name(int i) {
return getRuleContext(NameContext.class,i);
}
public DeleteFieldsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_deleteFields; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterDeleteFields(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitDeleteFields(this);
}
}
public final DeleteFieldsContext deleteFields() throws RecognitionException {
DeleteFieldsContext _localctx = new DeleteFieldsContext(_ctx, getState());
enterRule(_localctx, 16, RULE_deleteFields);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(185);
name();
setState(190);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__9) {
{
{
setState(186);
match(T__9);
setState(187);
name();
}
}
setState(192);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ConditionsContext extends ParserRuleContext {
public ChangesContext changes() {
return getRuleContext(ChangesContext.class,0);
}
public ConditionsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_conditions; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterConditions(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitConditions(this);
}
}
public final ConditionsContext conditions() throws RecognitionException {
ConditionsContext _localctx = new ConditionsContext(_ctx, getState());
enterRule(_localctx, 18, RULE_conditions);
try {
enterOuterAlt(_localctx, 1);
{
setState(193);
match(T__11);
setState(194);
changes();
setState(195);
match(T__12);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StarContext extends ParserRuleContext {
public StarContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_star; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterStar(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitStar(this);
}
}
public final StarContext star() throws RecognitionException {
StarContext _localctx = new StarContext(_ctx, getState());
enterRule(_localctx, 20, RULE_star);
try {
enterOuterAlt(_localctx, 1);
{
setState(197);
match(T__13);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class SkipContext extends ParserRuleContext {
public TerminalNode INT() { return getToken(QueryParser.INT, 0); }
public SkipContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_skip; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterSkip(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitSkip(this);
}
}
public final SkipContext skip() throws RecognitionException {
SkipContext _localctx = new SkipContext(_ctx, getState());
enterRule(_localctx, 22, RULE_skip);
try {
enterOuterAlt(_localctx, 1);
{
setState(199);
match(T__14);
setState(200);
match(INT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LimitContext extends ParserRuleContext {
public TerminalNode INT() { return getToken(QueryParser.INT, 0); }
public LimitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_limit; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterLimit(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitLimit(this);
}
}
public final LimitContext limit() throws RecognitionException {
LimitContext _localctx = new LimitContext(_ctx, getState());
enterRule(_localctx, 24, RULE_limit);
try {
enterOuterAlt(_localctx, 1);
{
setState(202);
match(T__15);
setState(203);
match(INT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class OrderContext extends ParserRuleContext {
public List orderName() {
return getRuleContexts(OrderNameContext.class);
}
public OrderNameContext orderName(int i) {
return getRuleContext(OrderNameContext.class,i);
}
public OrderContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_order; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterOrder(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitOrder(this);
}
}
public final OrderContext order() throws RecognitionException {
OrderContext _localctx = new OrderContext(_ctx, getState());
enterRule(_localctx, 26, RULE_order);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(205);
match(T__16);
setState(206);
match(T__17);
setState(207);
orderName();
setState(211);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ANY_NAME) {
{
{
setState(208);
orderName();
}
}
setState(213);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class OrderNameContext extends ParserRuleContext {
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public AscContext asc() {
return getRuleContext(AscContext.class,0);
}
public DescContext desc() {
return getRuleContext(DescContext.class,0);
}
public OrderNameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_orderName; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterOrderName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitOrderName(this);
}
}
public final OrderNameContext orderName() throws RecognitionException {
OrderNameContext _localctx = new OrderNameContext(_ctx, getState());
enterRule(_localctx, 28, RULE_orderName);
try {
setState(221);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(214);
name();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(215);
name();
setState(216);
asc();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(218);
name();
setState(219);
desc();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class WhereContext extends ParserRuleContext {
public List condition() {
return getRuleContexts(ConditionContext.class);
}
public ConditionContext condition(int i) {
return getRuleContext(ConditionContext.class,i);
}
public List and() {
return getRuleContexts(AndContext.class);
}
public AndContext and(int i) {
return getRuleContext(AndContext.class,i);
}
public List or() {
return getRuleContexts(OrContext.class);
}
public OrContext or(int i) {
return getRuleContext(OrContext.class,i);
}
public WhereContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_where; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterWhere(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitWhere(this);
}
}
public final WhereContext where() throws RecognitionException {
WhereContext _localctx = new WhereContext(_ctx, getState());
enterRule(_localctx, 30, RULE_where);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(223);
match(T__18);
setState(224);
condition();
setState(233);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__25 || _la==T__31) {
{
setState(231);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__25:
{
setState(225);
and();
setState(226);
condition();
}
break;
case T__31:
{
setState(228);
or();
setState(229);
condition();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(235);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ConditionContext extends ParserRuleContext {
public EqContext eq() {
return getRuleContext(EqContext.class,0);
}
public GtContext gt() {
return getRuleContext(GtContext.class,0);
}
public GteContext gte() {
return getRuleContext(GteContext.class,0);
}
public LtContext lt() {
return getRuleContext(LtContext.class,0);
}
public LteContext lte() {
return getRuleContext(LteContext.class,0);
}
public BetweenContext between() {
return getRuleContext(BetweenContext.class,0);
}
public InContext in() {
return getRuleContext(InContext.class,0);
}
public LikeContext like() {
return getRuleContext(LikeContext.class,0);
}
public ConditionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_condition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterCondition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitCondition(this);
}
}
public final ConditionContext condition() throws RecognitionException {
ConditionContext _localctx = new ConditionContext(_ctx, getState());
enterRule(_localctx, 32, RULE_condition);
try {
setState(244);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(236);
eq();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(237);
gt();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(238);
gte();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(239);
lt();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(240);
lte();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(241);
between();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(242);
in();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(243);
like();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class EqContext extends ParserRuleContext {
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public ValueContext value() {
return getRuleContext(ValueContext.class,0);
}
public NotContext not() {
return getRuleContext(NotContext.class,0);
}
public EqContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_eq; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterEq(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitEq(this);
}
}
public final EqContext eq() throws RecognitionException {
EqContext _localctx = new EqContext(_ctx, getState());
enterRule(_localctx, 34, RULE_eq);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(247);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__28) {
{
setState(246);
not();
}
}
setState(249);
name();
setState(250);
match(T__19);
setState(251);
value();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GtContext extends ParserRuleContext {
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public ValueContext value() {
return getRuleContext(ValueContext.class,0);
}
public NotContext not() {
return getRuleContext(NotContext.class,0);
}
public GtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_gt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterGt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitGt(this);
}
}
public final GtContext gt() throws RecognitionException {
GtContext _localctx = new GtContext(_ctx, getState());
enterRule(_localctx, 36, RULE_gt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(254);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__28) {
{
setState(253);
not();
}
}
setState(256);
name();
setState(257);
match(T__20);
setState(258);
value();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class GteContext extends ParserRuleContext {
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public ValueContext value() {
return getRuleContext(ValueContext.class,0);
}
public NotContext not() {
return getRuleContext(NotContext.class,0);
}
public GteContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_gte; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterGte(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitGte(this);
}
}
public final GteContext gte() throws RecognitionException {
GteContext _localctx = new GteContext(_ctx, getState());
enterRule(_localctx, 38, RULE_gte);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(261);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__28) {
{
setState(260);
not();
}
}
setState(263);
name();
setState(264);
match(T__21);
setState(265);
value();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LtContext extends ParserRuleContext {
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public ValueContext value() {
return getRuleContext(ValueContext.class,0);
}
public NotContext not() {
return getRuleContext(NotContext.class,0);
}
public LtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterLt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitLt(this);
}
}
public final LtContext lt() throws RecognitionException {
LtContext _localctx = new LtContext(_ctx, getState());
enterRule(_localctx, 40, RULE_lt);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(268);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__28) {
{
setState(267);
not();
}
}
setState(270);
name();
setState(271);
match(T__22);
setState(272);
value();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LteContext extends ParserRuleContext {
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public ValueContext value() {
return getRuleContext(ValueContext.class,0);
}
public NotContext not() {
return getRuleContext(NotContext.class,0);
}
public LteContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lte; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterLte(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitLte(this);
}
}
public final LteContext lte() throws RecognitionException {
LteContext _localctx = new LteContext(_ctx, getState());
enterRule(_localctx, 42, RULE_lte);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(275);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__28) {
{
setState(274);
not();
}
}
setState(277);
name();
setState(278);
match(T__23);
setState(279);
value();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class BetweenContext extends ParserRuleContext {
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public List value() {
return getRuleContexts(ValueContext.class);
}
public ValueContext value(int i) {
return getRuleContext(ValueContext.class,i);
}
public NotContext not() {
return getRuleContext(NotContext.class,0);
}
public BetweenContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_between; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterBetween(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitBetween(this);
}
}
public final BetweenContext between() throws RecognitionException {
BetweenContext _localctx = new BetweenContext(_ctx, getState());
enterRule(_localctx, 44, RULE_between);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(282);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__28) {
{
setState(281);
not();
}
}
setState(284);
name();
setState(285);
match(T__24);
setState(286);
value();
setState(287);
match(T__25);
setState(288);
value();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class InContext extends ParserRuleContext {
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public List value() {
return getRuleContexts(ValueContext.class);
}
public ValueContext value(int i) {
return getRuleContext(ValueContext.class,i);
}
public NotContext not() {
return getRuleContext(NotContext.class,0);
}
public InContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_in; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterIn(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitIn(this);
}
}
public final InContext in() throws RecognitionException {
InContext _localctx = new InContext(_ctx, getState());
enterRule(_localctx, 46, RULE_in);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(290);
name();
setState(292);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__28) {
{
setState(291);
not();
}
}
setState(294);
match(T__26);
setState(295);
match(T__11);
setState(296);
value();
setState(301);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__9) {
{
{
setState(297);
match(T__9);
setState(298);
value();
}
}
setState(303);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(304);
match(T__12);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class LikeContext extends ParserRuleContext {
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public Value_stringContext value_string() {
return getRuleContext(Value_stringContext.class,0);
}
public NotContext not() {
return getRuleContext(NotContext.class,0);
}
public LikeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_like; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterLike(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitLike(this);
}
}
public final LikeContext like() throws RecognitionException {
LikeContext _localctx = new LikeContext(_ctx, getState());
enterRule(_localctx, 48, RULE_like);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(306);
name();
setState(308);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__28) {
{
setState(307);
not();
}
}
setState(310);
match(T__27);
setState(311);
value_string();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class NotContext extends ParserRuleContext {
public NotContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_not; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterNot(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitNot(this);
}
}
public final NotContext not() throws RecognitionException {
NotContext _localctx = new NotContext(_ctx, getState());
enterRule(_localctx, 50, RULE_not);
try {
enterOuterAlt(_localctx, 1);
{
setState(313);
match(T__28);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AscContext extends ParserRuleContext {
public AscContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_asc; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterAsc(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitAsc(this);
}
}
public final AscContext asc() throws RecognitionException {
AscContext _localctx = new AscContext(_ctx, getState());
enterRule(_localctx, 52, RULE_asc);
try {
enterOuterAlt(_localctx, 1);
{
setState(315);
match(T__29);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class DescContext extends ParserRuleContext {
public DescContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_desc; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterDesc(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitDesc(this);
}
}
public final DescContext desc() throws RecognitionException {
DescContext _localctx = new DescContext(_ctx, getState());
enterRule(_localctx, 54, RULE_desc);
try {
enterOuterAlt(_localctx, 1);
{
setState(317);
match(T__30);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class AndContext extends ParserRuleContext {
public AndContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_and; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterAnd(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitAnd(this);
}
}
public final AndContext and() throws RecognitionException {
AndContext _localctx = new AndContext(_ctx, getState());
enterRule(_localctx, 56, RULE_and);
try {
enterOuterAlt(_localctx, 1);
{
setState(319);
match(T__25);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class OrContext extends ParserRuleContext {
public OrContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_or; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterOr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitOr(this);
}
}
public final OrContext or() throws RecognitionException {
OrContext _localctx = new OrContext(_ctx, getState());
enterRule(_localctx, 58, RULE_or);
try {
enterOuterAlt(_localctx, 1);
{
setState(321);
match(T__31);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class TtlContext extends ParserRuleContext {
public TerminalNode INT() { return getToken(QueryParser.INT, 0); }
public UnitContext unit() {
return getRuleContext(UnitContext.class,0);
}
public TtlContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ttl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterTtl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitTtl(this);
}
}
public final TtlContext ttl() throws RecognitionException {
TtlContext _localctx = new TtlContext(_ctx, getState());
enterRule(_localctx, 60, RULE_ttl);
try {
enterOuterAlt(_localctx, 1);
{
setState(323);
match(INT);
setState(324);
unit();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class UnitContext extends ParserRuleContext {
public UnitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unit; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterUnit(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitUnit(this);
}
}
public final UnitContext unit() throws RecognitionException {
UnitContext _localctx = new UnitContext(_ctx, getState());
enterRule(_localctx, 62, RULE_unit);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(326);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & 541165879296L) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ChangesContext extends ParserRuleContext {
public List change() {
return getRuleContexts(ChangeContext.class);
}
public ChangeContext change(int i) {
return getRuleContext(ChangeContext.class,i);
}
public ChangesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_changes; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterChanges(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitChanges(this);
}
}
public final ChangesContext changes() throws RecognitionException {
ChangesContext _localctx = new ChangesContext(_ctx, getState());
enterRule(_localctx, 64, RULE_changes);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(328);
change();
setState(333);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__9) {
{
{
setState(329);
match(T__9);
setState(330);
change();
}
}
setState(335);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ChangeContext extends ParserRuleContext {
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public ValueContext value() {
return getRuleContext(ValueContext.class,0);
}
public ChangeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_change; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterChange(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitChange(this);
}
}
public final ChangeContext change() throws RecognitionException {
ChangeContext _localctx = new ChangeContext(_ctx, getState());
enterRule(_localctx, 66, RULE_change);
try {
enterOuterAlt(_localctx, 1);
{
setState(336);
name();
setState(337);
match(T__19);
setState(338);
value();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class KeyContext extends ParserRuleContext {
public ValueContext value() {
return getRuleContext(ValueContext.class,0);
}
public KeyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_key; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterKey(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitKey(this);
}
}
public final KeyContext key() throws RecognitionException {
KeyContext _localctx = new KeyContext(_ctx, getState());
enterRule(_localctx, 68, RULE_key);
try {
enterOuterAlt(_localctx, 1);
{
setState(340);
value();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class KeysContext extends ParserRuleContext {
public List value() {
return getRuleContexts(ValueContext.class);
}
public ValueContext value(int i) {
return getRuleContext(ValueContext.class,i);
}
public KeysContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_keys; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterKeys(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitKeys(this);
}
}
public final KeysContext keys() throws RecognitionException {
KeysContext _localctx = new KeysContext(_ctx, getState());
enterRule(_localctx, 70, RULE_keys);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(342);
value();
setState(347);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__9) {
{
{
setState(343);
match(T__9);
setState(344);
value();
}
}
setState(349);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ValueContext extends ParserRuleContext {
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public StringContext string() {
return getRuleContext(StringContext.class,0);
}
public BoolContext bool() {
return getRuleContext(BoolContext.class,0);
}
public ArrayContext array() {
return getRuleContext(ArrayContext.class,0);
}
public FunctionContext function() {
return getRuleContext(FunctionContext.class,0);
}
public ParameterContext parameter() {
return getRuleContext(ParameterContext.class,0);
}
public JsonContext json() {
return getRuleContext(JsonContext.class,0);
}
public ValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_value; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitValue(this);
}
}
public final ValueContext value() throws RecognitionException {
ValueContext _localctx = new ValueContext(_ctx, getState());
enterRule(_localctx, 72, RULE_value);
try {
enterOuterAlt(_localctx, 1);
{
setState(357);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,29,_ctx) ) {
case 1:
{
setState(350);
number();
}
break;
case 2:
{
setState(351);
string();
}
break;
case 3:
{
setState(352);
bool();
}
break;
case 4:
{
setState(353);
array();
}
break;
case 5:
{
setState(354);
function();
}
break;
case 6:
{
setState(355);
parameter();
}
break;
case 7:
{
setState(356);
json();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Value_stringContext extends ParserRuleContext {
public StringContext string() {
return getRuleContext(StringContext.class,0);
}
public ParameterContext parameter() {
return getRuleContext(ParameterContext.class,0);
}
public Value_stringContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_value_string; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterValue_string(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitValue_string(this);
}
}
public final Value_stringContext value_string() throws RecognitionException {
Value_stringContext _localctx = new Value_stringContext(_ctx, getState());
enterRule(_localctx, 74, RULE_value_string);
try {
setState(361);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING:
enterOuterAlt(_localctx, 1);
{
setState(359);
string();
}
break;
case PARAMETER:
enterOuterAlt(_localctx, 2);
{
setState(360);
parameter();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class NameContext extends ParserRuleContext {
public TerminalNode ANY_NAME() { return getToken(QueryParser.ANY_NAME, 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 QueryListener ) ((QueryListener)listener).enterName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitName(this);
}
}
public final NameContext name() throws RecognitionException {
NameContext _localctx = new NameContext(_ctx, getState());
enterRule(_localctx, 76, RULE_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(363);
match(ANY_NAME);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class EntityContext extends ParserRuleContext {
public TerminalNode ANY_NAME() { return getToken(QueryParser.ANY_NAME, 0); }
public EntityContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_entity; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterEntity(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitEntity(this);
}
}
public final EntityContext entity() throws RecognitionException {
EntityContext _localctx = new EntityContext(_ctx, getState());
enterRule(_localctx, 78, RULE_entity);
try {
enterOuterAlt(_localctx, 1);
{
setState(365);
match(ANY_NAME);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ArrayContext extends ParserRuleContext {
public List element() {
return getRuleContexts(ElementContext.class);
}
public ElementContext element(int i) {
return getRuleContext(ElementContext.class,i);
}
public ArrayContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_array; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterArray(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitArray(this);
}
}
public final ArrayContext array() throws RecognitionException {
ArrayContext _localctx = new ArrayContext(_ctx, getState());
enterRule(_localctx, 80, RULE_array);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(367);
match(T__8);
setState(368);
element();
setState(373);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__9) {
{
{
setState(369);
match(T__9);
setState(370);
element();
}
}
setState(375);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(376);
match(T__10);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class FunctionContext extends ParserRuleContext {
public ConvertContext convert() {
return getRuleContext(ConvertContext.class,0);
}
public FunctionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_function; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitFunction(this);
}
}
public final FunctionContext function() throws RecognitionException {
FunctionContext _localctx = new FunctionContext(_ctx, getState());
enterRule(_localctx, 82, RULE_function);
try {
enterOuterAlt(_localctx, 1);
{
setState(378);
convert();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ConvertContext extends ParserRuleContext {
public ElementContext element() {
return getRuleContext(ElementContext.class,0);
}
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public ConvertContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_convert; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterConvert(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitConvert(this);
}
}
public final ConvertContext convert() throws RecognitionException {
ConvertContext _localctx = new ConvertContext(_ctx, getState());
enterRule(_localctx, 84, RULE_convert);
try {
enterOuterAlt(_localctx, 1);
{
setState(380);
match(T__38);
setState(381);
element();
setState(382);
match(T__9);
setState(383);
name();
setState(384);
match(T__12);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ElementContext extends ParserRuleContext {
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public StringContext string() {
return getRuleContext(StringContext.class,0);
}
public ElementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_element; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterElement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitElement(this);
}
}
public final ElementContext element() throws RecognitionException {
ElementContext _localctx = new ElementContext(_ctx, getState());
enterRule(_localctx, 86, RULE_element);
try {
setState(388);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__39:
case INT:
case NUMBER:
enterOuterAlt(_localctx, 1);
{
setState(386);
number();
}
break;
case STRING:
enterOuterAlt(_localctx, 2);
{
setState(387);
string();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class NumberContext extends ParserRuleContext {
public TerminalNode NUMBER() { return getToken(QueryParser.NUMBER, 0); }
public TerminalNode INT() { return getToken(QueryParser.INT, 0); }
public NumberContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_number; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterNumber(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitNumber(this);
}
}
public final NumberContext number() throws RecognitionException {
NumberContext _localctx = new NumberContext(_ctx, getState());
enterRule(_localctx, 88, RULE_number);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(391);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__39) {
{
setState(390);
match(T__39);
}
}
setState(393);
_la = _input.LA(1);
if ( !(_la==INT || _la==NUMBER) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class StringContext extends ParserRuleContext {
public TerminalNode STRING() { return getToken(QueryParser.STRING, 0); }
public StringContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_string; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterString(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitString(this);
}
}
public final StringContext string() throws RecognitionException {
StringContext _localctx = new StringContext(_ctx, getState());
enterRule(_localctx, 90, RULE_string);
try {
enterOuterAlt(_localctx, 1);
{
setState(395);
match(STRING);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class BoolContext extends ParserRuleContext {
public TerminalNode BOOLEAN() { return getToken(QueryParser.BOOLEAN, 0); }
public BoolContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bool; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterBool(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitBool(this);
}
}
public final BoolContext bool() throws RecognitionException {
BoolContext _localctx = new BoolContext(_ctx, getState());
enterRule(_localctx, 92, RULE_bool);
try {
enterOuterAlt(_localctx, 1);
{
setState(397);
match(BOOLEAN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class JsonContext extends ParserRuleContext {
public Object_jsonContext object_json() {
return getRuleContext(Object_jsonContext.class,0);
}
public Array_jsonContext array_json() {
return getRuleContext(Array_jsonContext.class,0);
}
public JsonContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_json; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterJson(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitJson(this);
}
}
public final JsonContext json() throws RecognitionException {
JsonContext _localctx = new JsonContext(_ctx, getState());
enterRule(_localctx, 94, RULE_json);
try {
setState(401);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__8:
enterOuterAlt(_localctx, 1);
{
setState(399);
object_json();
}
break;
case T__42:
enterOuterAlt(_localctx, 2);
{
setState(400);
array_json();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Object_jsonContext extends ParserRuleContext {
public List pair_json() {
return getRuleContexts(Pair_jsonContext.class);
}
public Pair_jsonContext pair_json(int i) {
return getRuleContext(Pair_jsonContext.class,i);
}
public Object_jsonContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_object_json; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterObject_json(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitObject_json(this);
}
}
public final Object_jsonContext object_json() throws RecognitionException {
Object_jsonContext _localctx = new Object_jsonContext(_ctx, getState());
enterRule(_localctx, 96, RULE_object_json);
int _la;
try {
setState(416);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,36,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(403);
match(T__8);
setState(404);
pair_json();
setState(409);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__9) {
{
{
setState(405);
match(T__9);
setState(406);
pair_json();
}
}
setState(411);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(412);
match(T__10);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(414);
match(T__8);
setState(415);
match(T__10);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Pair_jsonContext extends ParserRuleContext {
public TerminalNode STRING() { return getToken(QueryParser.STRING, 0); }
public Value_jsonContext value_json() {
return getRuleContext(Value_jsonContext.class,0);
}
public Pair_jsonContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pair_json; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterPair_json(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitPair_json(this);
}
}
public final Pair_jsonContext pair_json() throws RecognitionException {
Pair_jsonContext _localctx = new Pair_jsonContext(_ctx, getState());
enterRule(_localctx, 98, RULE_pair_json);
try {
enterOuterAlt(_localctx, 1);
{
setState(418);
match(STRING);
setState(419);
match(T__40);
setState(420);
value_json();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Value_jsonContext extends ParserRuleContext {
public TerminalNode STRING() { return getToken(QueryParser.STRING, 0); }
public TerminalNode BOOLEAN() { return getToken(QueryParser.BOOLEAN, 0); }
public NumberContext number() {
return getRuleContext(NumberContext.class,0);
}
public Object_jsonContext object_json() {
return getRuleContext(Object_jsonContext.class,0);
}
public Array_jsonContext array_json() {
return getRuleContext(Array_jsonContext.class,0);
}
public Value_jsonContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_value_json; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterValue_json(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitValue_json(this);
}
}
public final Value_jsonContext value_json() throws RecognitionException {
Value_jsonContext _localctx = new Value_jsonContext(_ctx, getState());
enterRule(_localctx, 100, RULE_value_json);
try {
setState(428);
_errHandler.sync(this);
switch (_input.LA(1)) {
case STRING:
enterOuterAlt(_localctx, 1);
{
setState(422);
match(STRING);
}
break;
case BOOLEAN:
enterOuterAlt(_localctx, 2);
{
setState(423);
match(BOOLEAN);
}
break;
case T__39:
case INT:
case NUMBER:
enterOuterAlt(_localctx, 3);
{
setState(424);
number();
}
break;
case T__8:
enterOuterAlt(_localctx, 4);
{
setState(425);
object_json();
}
break;
case T__42:
enterOuterAlt(_localctx, 5);
{
setState(426);
array_json();
}
break;
case T__41:
enterOuterAlt(_localctx, 6);
{
setState(427);
match(T__41);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class Array_jsonContext extends ParserRuleContext {
public List value_json() {
return getRuleContexts(Value_jsonContext.class);
}
public Value_jsonContext value_json(int i) {
return getRuleContext(Value_jsonContext.class,i);
}
public Array_jsonContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_array_json; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterArray_json(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitArray_json(this);
}
}
public final Array_jsonContext array_json() throws RecognitionException {
Array_jsonContext _localctx = new Array_jsonContext(_ctx, getState());
enterRule(_localctx, 102, RULE_array_json);
int _la;
try {
setState(443);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(430);
match(T__42);
setState(431);
value_json();
setState(436);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__9) {
{
{
setState(432);
match(T__9);
setState(433);
value_json();
}
}
setState(438);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(439);
match(T__43);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(441);
match(T__42);
setState(442);
match(T__43);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
@SuppressWarnings("CheckReturnValue")
public static class ParameterContext extends ParserRuleContext {
public TerminalNode PARAMETER() { return getToken(QueryParser.PARAMETER, 0); }
public ParameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).enterParameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof QueryListener ) ((QueryListener)listener).exitParameter(this);
}
}
public final ParameterContext parameter() throws RecognitionException {
ParameterContext _localctx = new ParameterContext(_ctx, getState());
enterRule(_localctx, 104, RULE_parameter);
try {
enterOuterAlt(_localctx, 1);
{
setState(445);
match(PARAMETER);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static final String _serializedATN =
"\u0004\u00014\u01c0\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001\u0002"+
"\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004\u0002"+
"\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007\u0002"+
"\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b\u0002"+
"\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007\u000f"+
"\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007\u0012"+
"\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007\u0015"+
"\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007\u0018"+
"\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007\u001b"+
"\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002\u001e\u0007\u001e"+
"\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007!\u0002\"\u0007\"\u0002"+
"#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007&\u0002\'\u0007\'\u0002"+
"(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007+\u0002,\u0007,\u0002"+
"-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u00070\u00021\u00071\u0002"+
"2\u00072\u00023\u00073\u00024\u00074\u0001\u0000\u0001\u0000\u0001\u0000"+
"\u0001\u0000\u0001\u0000\u0003\u0000p\b\u0000\u0001\u0000\u0003\u0000"+
"s\b\u0000\u0001\u0000\u0003\u0000v\b\u0000\u0001\u0000\u0003\u0000y\b"+
"\u0000\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0003\u0001\u007f"+
"\b\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0003\u0001\u0084\b\u0001"+
"\u0001\u0001\u0001\u0001\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002"+
"\u0003\u0002\u008c\b\u0002\u0001\u0002\u0003\u0002\u008f\b\u0002\u0001"+
"\u0002\u0001\u0002\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0003"+
"\u0003\u0097\b\u0003\u0001\u0003\u0001\u0003\u0001\u0004\u0001\u0004\u0001"+
"\u0004\u0001\u0004\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001"+
"\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001"+
"\u0006\u0003\u0006\u00aa\b\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001"+
"\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0005\u0007\u00b3\b\u0007\n"+
"\u0007\f\u0007\u00b6\t\u0007\u0003\u0007\u00b8\b\u0007\u0001\b\u0001\b"+
"\u0001\b\u0005\b\u00bd\b\b\n\b\f\b\u00c0\t\b\u0001\t\u0001\t\u0001\t\u0001"+
"\t\u0001\n\u0001\n\u0001\u000b\u0001\u000b\u0001\u000b\u0001\f\u0001\f"+
"\u0001\f\u0001\r\u0001\r\u0001\r\u0001\r\u0005\r\u00d2\b\r\n\r\f\r\u00d5"+
"\t\r\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001"+
"\u000e\u0001\u000e\u0003\u000e\u00de\b\u000e\u0001\u000f\u0001\u000f\u0001"+
"\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0005"+
"\u000f\u00e8\b\u000f\n\u000f\f\u000f\u00eb\t\u000f\u0001\u0010\u0001\u0010"+
"\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010"+
"\u0003\u0010\u00f5\b\u0010\u0001\u0011\u0003\u0011\u00f8\b\u0011\u0001"+
"\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0012\u0003\u0012\u00ff"+
"\b\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0013\u0003"+
"\u0013\u0106\b\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001"+
"\u0014\u0003\u0014\u010d\b\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001"+
"\u0014\u0001\u0015\u0003\u0015\u0114\b\u0015\u0001\u0015\u0001\u0015\u0001"+
"\u0015\u0001\u0015\u0001\u0016\u0003\u0016\u011b\b\u0016\u0001\u0016\u0001"+
"\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0017\u0001"+
"\u0017\u0003\u0017\u0125\b\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001"+
"\u0017\u0001\u0017\u0005\u0017\u012c\b\u0017\n\u0017\f\u0017\u012f\t\u0017"+
"\u0001\u0017\u0001\u0017\u0001\u0018\u0001\u0018\u0003\u0018\u0135\b\u0018"+
"\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0019\u0001\u0019\u0001\u001a"+
"\u0001\u001a\u0001\u001b\u0001\u001b\u0001\u001c\u0001\u001c\u0001\u001d"+
"\u0001\u001d\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001f\u0001\u001f"+
"\u0001 \u0001 \u0001 \u0005 \u014c\b \n \f \u014f\t \u0001!\u0001!\u0001"+
"!\u0001!\u0001\"\u0001\"\u0001#\u0001#\u0001#\u0005#\u015a\b#\n#\f#\u015d"+
"\t#\u0001$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001$\u0003$\u0166\b$\u0001"+
"%\u0001%\u0003%\u016a\b%\u0001&\u0001&\u0001\'\u0001\'\u0001(\u0001(\u0001"+
"(\u0001(\u0005(\u0174\b(\n(\f(\u0177\t(\u0001(\u0001(\u0001)\u0001)\u0001"+
"*\u0001*\u0001*\u0001*\u0001*\u0001*\u0001+\u0001+\u0003+\u0185\b+\u0001"+
",\u0003,\u0188\b,\u0001,\u0001,\u0001-\u0001-\u0001.\u0001.\u0001/\u0001"+
"/\u0003/\u0192\b/\u00010\u00010\u00010\u00010\u00050\u0198\b0\n0\f0\u019b"+
"\t0\u00010\u00010\u00010\u00010\u00030\u01a1\b0\u00011\u00011\u00011\u0001"+
"1\u00012\u00012\u00012\u00012\u00012\u00012\u00032\u01ad\b2\u00013\u0001"+
"3\u00013\u00013\u00053\u01b3\b3\n3\f3\u01b6\t3\u00013\u00013\u00013\u0001"+
"3\u00033\u01bc\b3\u00014\u00014\u00014\u0000\u00005\u0000\u0002\u0004"+
"\u0006\b\n\f\u000e\u0010\u0012\u0014\u0016\u0018\u001a\u001c\u001e \""+
"$&(*,.02468:<>@BDFHJLNPRTVXZ\\^`bdfh\u0000\u0002\u0001\u0000!&\u0001\u0000"+
"./\u01c2\u0000j\u0001\u0000\u0000\u0000\u0002|\u0001\u0000\u0000\u0000"+
"\u0004\u0087\u0001\u0000\u0000\u0000\u0006\u0092\u0001\u0000\u0000\u0000"+
"\b\u009a\u0001\u0000\u0000\u0000\n\u009e\u0001\u0000\u0000\u0000\f\u00a2"+
"\u0001\u0000\u0000\u0000\u000e\u00b7\u0001\u0000\u0000\u0000\u0010\u00b9"+
"\u0001\u0000\u0000\u0000\u0012\u00c1\u0001\u0000\u0000\u0000\u0014\u00c5"+
"\u0001\u0000\u0000\u0000\u0016\u00c7\u0001\u0000\u0000\u0000\u0018\u00ca"+
"\u0001\u0000\u0000\u0000\u001a\u00cd\u0001\u0000\u0000\u0000\u001c\u00dd"+
"\u0001\u0000\u0000\u0000\u001e\u00df\u0001\u0000\u0000\u0000 \u00f4\u0001"+
"\u0000\u0000\u0000\"\u00f7\u0001\u0000\u0000\u0000$\u00fe\u0001\u0000"+
"\u0000\u0000&\u0105\u0001\u0000\u0000\u0000(\u010c\u0001\u0000\u0000\u0000"+
"*\u0113\u0001\u0000\u0000\u0000,\u011a\u0001\u0000\u0000\u0000.\u0122"+
"\u0001\u0000\u0000\u00000\u0132\u0001\u0000\u0000\u00002\u0139\u0001\u0000"+
"\u0000\u00004\u013b\u0001\u0000\u0000\u00006\u013d\u0001\u0000\u0000\u0000"+
"8\u013f\u0001\u0000\u0000\u0000:\u0141\u0001\u0000\u0000\u0000<\u0143"+
"\u0001\u0000\u0000\u0000>\u0146\u0001\u0000\u0000\u0000@\u0148\u0001\u0000"+
"\u0000\u0000B\u0150\u0001\u0000\u0000\u0000D\u0154\u0001\u0000\u0000\u0000"+
"F\u0156\u0001\u0000\u0000\u0000H\u0165\u0001\u0000\u0000\u0000J\u0169"+
"\u0001\u0000\u0000\u0000L\u016b\u0001\u0000\u0000\u0000N\u016d\u0001\u0000"+
"\u0000\u0000P\u016f\u0001\u0000\u0000\u0000R\u017a\u0001\u0000\u0000\u0000"+
"T\u017c\u0001\u0000\u0000\u0000V\u0184\u0001\u0000\u0000\u0000X\u0187"+
"\u0001\u0000\u0000\u0000Z\u018b\u0001\u0000\u0000\u0000\\\u018d\u0001"+
"\u0000\u0000\u0000^\u0191\u0001\u0000\u0000\u0000`\u01a0\u0001\u0000\u0000"+
"\u0000b\u01a2\u0001\u0000\u0000\u0000d\u01ac\u0001\u0000\u0000\u0000f"+
"\u01bb\u0001\u0000\u0000\u0000h\u01bd\u0001\u0000\u0000\u0000jk\u0005"+
"\u0001\u0000\u0000kl\u0003\u000e\u0007\u0000lm\u0005\u0002\u0000\u0000"+
"mo\u0003N\'\u0000np\u0003\u001e\u000f\u0000on\u0001\u0000\u0000\u0000"+
"op\u0001\u0000\u0000\u0000pr\u0001\u0000\u0000\u0000qs\u0003\u0016\u000b"+
"\u0000rq\u0001\u0000\u0000\u0000rs\u0001\u0000\u0000\u0000su\u0001\u0000"+
"\u0000\u0000tv\u0003\u0018\f\u0000ut\u0001\u0000\u0000\u0000uv\u0001\u0000"+
"\u0000\u0000vx\u0001\u0000\u0000\u0000wy\u0003\u001a\r\u0000xw\u0001\u0000"+
"\u0000\u0000xy\u0001\u0000\u0000\u0000yz\u0001\u0000\u0000\u0000z{\u0005"+
"\u0000\u0000\u0001{\u0001\u0001\u0000\u0000\u0000|~\u0005\u0003\u0000"+
"\u0000}\u007f\u0003\u0010\b\u0000~}\u0001\u0000\u0000\u0000~\u007f\u0001"+
"\u0000\u0000\u0000\u007f\u0080\u0001\u0000\u0000\u0000\u0080\u0081\u0005"+
"\u0002\u0000\u0000\u0081\u0083\u0003N\'\u0000\u0082\u0084\u0003\u001e"+
"\u000f\u0000\u0083\u0082\u0001\u0000\u0000\u0000\u0083\u0084\u0001\u0000"+
"\u0000\u0000\u0084\u0085\u0001\u0000\u0000\u0000\u0085\u0086\u0005\u0000"+
"\u0000\u0001\u0086\u0003\u0001\u0000\u0000\u0000\u0087\u0088\u0005\u0004"+
"\u0000\u0000\u0088\u008b\u0003N\'\u0000\u0089\u008c\u0003\u0012\t\u0000"+
"\u008a\u008c\u0003^/\u0000\u008b\u0089\u0001\u0000\u0000\u0000\u008b\u008a"+
"\u0001\u0000\u0000\u0000\u008c\u008e\u0001\u0000\u0000\u0000\u008d\u008f"+
"\u0003<\u001e\u0000\u008e\u008d\u0001\u0000\u0000\u0000\u008e\u008f\u0001"+
"\u0000\u0000\u0000\u008f\u0090\u0001\u0000\u0000\u0000\u0090\u0091\u0005"+
"\u0000\u0000\u0001\u0091\u0005\u0001\u0000\u0000\u0000\u0092\u0093\u0005"+
"\u0005\u0000\u0000\u0093\u0096\u0003N\'\u0000\u0094\u0097\u0003\u0012"+
"\t\u0000\u0095\u0097\u0003^/\u0000\u0096\u0094\u0001\u0000\u0000\u0000"+
"\u0096\u0095\u0001\u0000\u0000\u0000\u0097\u0098\u0001\u0000\u0000\u0000"+
"\u0098\u0099\u0005\u0000\u0000\u0001\u0099\u0007\u0001\u0000\u0000\u0000"+
"\u009a\u009b\u0005\u0006\u0000\u0000\u009b\u009c\u0003F#\u0000\u009c\u009d"+
"\u0005\u0000\u0000\u0001\u009d\t\u0001\u0000\u0000\u0000\u009e\u009f\u0005"+
"\u0007\u0000\u0000\u009f\u00a0\u0003F#\u0000\u00a0\u00a1\u0005\u0000\u0000"+
"\u0001\u00a1\u000b\u0001\u0000\u0000\u0000\u00a2\u00a3\u0005\b\u0000\u0000"+
"\u00a3\u00a4\u0005\t\u0000\u0000\u00a4\u00a5\u0003D\"\u0000\u00a5\u00a6"+
"\u0005\n\u0000\u0000\u00a6\u00a9\u0003H$\u0000\u00a7\u00a8\u0005\n\u0000"+
"\u0000\u00a8\u00aa\u0003<\u001e\u0000\u00a9\u00a7\u0001\u0000\u0000\u0000"+
"\u00a9\u00aa\u0001\u0000\u0000\u0000\u00aa\u00ab\u0001\u0000\u0000\u0000"+
"\u00ab\u00ac\u0005\u000b\u0000\u0000\u00ac\u00ad\u0005\u0000\u0000\u0001"+
"\u00ad\r\u0001\u0000\u0000\u0000\u00ae\u00b8\u0003\u0014\n\u0000\u00af"+
"\u00b4\u0003L&\u0000\u00b0\u00b1\u0005\n\u0000\u0000\u00b1\u00b3\u0003"+
"L&\u0000\u00b2\u00b0\u0001\u0000\u0000\u0000\u00b3\u00b6\u0001\u0000\u0000"+
"\u0000\u00b4\u00b2\u0001\u0000\u0000\u0000\u00b4\u00b5\u0001\u0000\u0000"+
"\u0000\u00b5\u00b8\u0001\u0000\u0000\u0000\u00b6\u00b4\u0001\u0000\u0000"+
"\u0000\u00b7\u00ae\u0001\u0000\u0000\u0000\u00b7\u00af\u0001\u0000\u0000"+
"\u0000\u00b8\u000f\u0001\u0000\u0000\u0000\u00b9\u00be\u0003L&\u0000\u00ba"+
"\u00bb\u0005\n\u0000\u0000\u00bb\u00bd\u0003L&\u0000\u00bc\u00ba\u0001"+
"\u0000\u0000\u0000\u00bd\u00c0\u0001\u0000\u0000\u0000\u00be\u00bc\u0001"+
"\u0000\u0000\u0000\u00be\u00bf\u0001\u0000\u0000\u0000\u00bf\u0011\u0001"+
"\u0000\u0000\u0000\u00c0\u00be\u0001\u0000\u0000\u0000\u00c1\u00c2\u0005"+
"\f\u0000\u0000\u00c2\u00c3\u0003@ \u0000\u00c3\u00c4\u0005\r\u0000\u0000"+
"\u00c4\u0013\u0001\u0000\u0000\u0000\u00c5\u00c6\u0005\u000e\u0000\u0000"+
"\u00c6\u0015\u0001\u0000\u0000\u0000\u00c7\u00c8\u0005\u000f\u0000\u0000"+
"\u00c8\u00c9\u0005.\u0000\u0000\u00c9\u0017\u0001\u0000\u0000\u0000\u00ca"+
"\u00cb\u0005\u0010\u0000\u0000\u00cb\u00cc\u0005.\u0000\u0000\u00cc\u0019"+
"\u0001\u0000\u0000\u0000\u00cd\u00ce\u0005\u0011\u0000\u0000\u00ce\u00cf"+
"\u0005\u0012\u0000\u0000\u00cf\u00d3\u0003\u001c\u000e\u0000\u00d0\u00d2"+
"\u0003\u001c\u000e\u0000\u00d1\u00d0\u0001\u0000\u0000\u0000\u00d2\u00d5"+
"\u0001\u0000\u0000\u0000\u00d3\u00d1\u0001\u0000\u0000\u0000\u00d3\u00d4"+
"\u0001\u0000\u0000\u0000\u00d4\u001b\u0001\u0000\u0000\u0000\u00d5\u00d3"+
"\u0001\u0000\u0000\u0000\u00d6\u00de\u0003L&\u0000\u00d7\u00d8\u0003L"+
"&\u0000\u00d8\u00d9\u00034\u001a\u0000\u00d9\u00de\u0001\u0000\u0000\u0000"+
"\u00da\u00db\u0003L&\u0000\u00db\u00dc\u00036\u001b\u0000\u00dc\u00de"+
"\u0001\u0000\u0000\u0000\u00dd\u00d6\u0001\u0000\u0000\u0000\u00dd\u00d7"+
"\u0001\u0000\u0000\u0000\u00dd\u00da\u0001\u0000\u0000\u0000\u00de\u001d"+
"\u0001\u0000\u0000\u0000\u00df\u00e0\u0005\u0013\u0000\u0000\u00e0\u00e9"+
"\u0003 \u0010\u0000\u00e1\u00e2\u00038\u001c\u0000\u00e2\u00e3\u0003 "+
"\u0010\u0000\u00e3\u00e8\u0001\u0000\u0000\u0000\u00e4\u00e5\u0003:\u001d"+
"\u0000\u00e5\u00e6\u0003 \u0010\u0000\u00e6\u00e8\u0001\u0000\u0000\u0000"+
"\u00e7\u00e1\u0001\u0000\u0000\u0000\u00e7\u00e4\u0001\u0000\u0000\u0000"+
"\u00e8\u00eb\u0001\u0000\u0000\u0000\u00e9\u00e7\u0001\u0000\u0000\u0000"+
"\u00e9\u00ea\u0001\u0000\u0000\u0000\u00ea\u001f\u0001\u0000\u0000\u0000"+
"\u00eb\u00e9\u0001\u0000\u0000\u0000\u00ec\u00f5\u0003\"\u0011\u0000\u00ed"+
"\u00f5\u0003$\u0012\u0000\u00ee\u00f5\u0003&\u0013\u0000\u00ef\u00f5\u0003"+
"(\u0014\u0000\u00f0\u00f5\u0003*\u0015\u0000\u00f1\u00f5\u0003,\u0016"+
"\u0000\u00f2\u00f5\u0003.\u0017\u0000\u00f3\u00f5\u00030\u0018\u0000\u00f4"+
"\u00ec\u0001\u0000\u0000\u0000\u00f4\u00ed\u0001\u0000\u0000\u0000\u00f4"+
"\u00ee\u0001\u0000\u0000\u0000\u00f4\u00ef\u0001\u0000\u0000\u0000\u00f4"+
"\u00f0\u0001\u0000\u0000\u0000\u00f4\u00f1\u0001\u0000\u0000\u0000\u00f4"+
"\u00f2\u0001\u0000\u0000\u0000\u00f4\u00f3\u0001\u0000\u0000\u0000\u00f5"+
"!\u0001\u0000\u0000\u0000\u00f6\u00f8\u00032\u0019\u0000\u00f7\u00f6\u0001"+
"\u0000\u0000\u0000\u00f7\u00f8\u0001\u0000\u0000\u0000\u00f8\u00f9\u0001"+
"\u0000\u0000\u0000\u00f9\u00fa\u0003L&\u0000\u00fa\u00fb\u0005\u0014\u0000"+
"\u0000\u00fb\u00fc\u0003H$\u0000\u00fc#\u0001\u0000\u0000\u0000\u00fd"+
"\u00ff\u00032\u0019\u0000\u00fe\u00fd\u0001\u0000\u0000\u0000\u00fe\u00ff"+
"\u0001\u0000\u0000\u0000\u00ff\u0100\u0001\u0000\u0000\u0000\u0100\u0101"+
"\u0003L&\u0000\u0101\u0102\u0005\u0015\u0000\u0000\u0102\u0103\u0003H"+
"$\u0000\u0103%\u0001\u0000\u0000\u0000\u0104\u0106\u00032\u0019\u0000"+
"\u0105\u0104\u0001\u0000\u0000\u0000\u0105\u0106\u0001\u0000\u0000\u0000"+
"\u0106\u0107\u0001\u0000\u0000\u0000\u0107\u0108\u0003L&\u0000\u0108\u0109"+
"\u0005\u0016\u0000\u0000\u0109\u010a\u0003H$\u0000\u010a\'\u0001\u0000"+
"\u0000\u0000\u010b\u010d\u00032\u0019\u0000\u010c\u010b\u0001\u0000\u0000"+
"\u0000\u010c\u010d\u0001\u0000\u0000\u0000\u010d\u010e\u0001\u0000\u0000"+
"\u0000\u010e\u010f\u0003L&\u0000\u010f\u0110\u0005\u0017\u0000\u0000\u0110"+
"\u0111\u0003H$\u0000\u0111)\u0001\u0000\u0000\u0000\u0112\u0114\u0003"+
"2\u0019\u0000\u0113\u0112\u0001\u0000\u0000\u0000\u0113\u0114\u0001\u0000"+
"\u0000\u0000\u0114\u0115\u0001\u0000\u0000\u0000\u0115\u0116\u0003L&\u0000"+
"\u0116\u0117\u0005\u0018\u0000\u0000\u0117\u0118\u0003H$\u0000\u0118+"+
"\u0001\u0000\u0000\u0000\u0119\u011b\u00032\u0019\u0000\u011a\u0119\u0001"+
"\u0000\u0000\u0000\u011a\u011b\u0001\u0000\u0000\u0000\u011b\u011c\u0001"+
"\u0000\u0000\u0000\u011c\u011d\u0003L&\u0000\u011d\u011e\u0005\u0019\u0000"+
"\u0000\u011e\u011f\u0003H$\u0000\u011f\u0120\u0005\u001a\u0000\u0000\u0120"+
"\u0121\u0003H$\u0000\u0121-\u0001\u0000\u0000\u0000\u0122\u0124\u0003"+
"L&\u0000\u0123\u0125\u00032\u0019\u0000\u0124\u0123\u0001\u0000\u0000"+
"\u0000\u0124\u0125\u0001\u0000\u0000\u0000\u0125\u0126\u0001\u0000\u0000"+
"\u0000\u0126\u0127\u0005\u001b\u0000\u0000\u0127\u0128\u0005\f\u0000\u0000"+
"\u0128\u012d\u0003H$\u0000\u0129\u012a\u0005\n\u0000\u0000\u012a\u012c"+
"\u0003H$\u0000\u012b\u0129\u0001\u0000\u0000\u0000\u012c\u012f\u0001\u0000"+
"\u0000\u0000\u012d\u012b\u0001\u0000\u0000\u0000\u012d\u012e\u0001\u0000"+
"\u0000\u0000\u012e\u0130\u0001\u0000\u0000\u0000\u012f\u012d\u0001\u0000"+
"\u0000\u0000\u0130\u0131\u0005\r\u0000\u0000\u0131/\u0001\u0000\u0000"+
"\u0000\u0132\u0134\u0003L&\u0000\u0133\u0135\u00032\u0019\u0000\u0134"+
"\u0133\u0001\u0000\u0000\u0000\u0134\u0135\u0001\u0000\u0000\u0000\u0135"+
"\u0136\u0001\u0000\u0000\u0000\u0136\u0137\u0005\u001c\u0000\u0000\u0137"+
"\u0138\u0003J%\u0000\u01381\u0001\u0000\u0000\u0000\u0139\u013a\u0005"+
"\u001d\u0000\u0000\u013a3\u0001\u0000\u0000\u0000\u013b\u013c\u0005\u001e"+
"\u0000\u0000\u013c5\u0001\u0000\u0000\u0000\u013d\u013e\u0005\u001f\u0000"+
"\u0000\u013e7\u0001\u0000\u0000\u0000\u013f\u0140\u0005\u001a\u0000\u0000"+
"\u01409\u0001\u0000\u0000\u0000\u0141\u0142\u0005 \u0000\u0000\u0142;"+
"\u0001\u0000\u0000\u0000\u0143\u0144\u0005.\u0000\u0000\u0144\u0145\u0003"+
">\u001f\u0000\u0145=\u0001\u0000\u0000\u0000\u0146\u0147\u0007\u0000\u0000"+
"\u0000\u0147?\u0001\u0000\u0000\u0000\u0148\u014d\u0003B!\u0000\u0149"+
"\u014a\u0005\n\u0000\u0000\u014a\u014c\u0003B!\u0000\u014b\u0149\u0001"+
"\u0000\u0000\u0000\u014c\u014f\u0001\u0000\u0000\u0000\u014d\u014b\u0001"+
"\u0000\u0000\u0000\u014d\u014e\u0001\u0000\u0000\u0000\u014eA\u0001\u0000"+
"\u0000\u0000\u014f\u014d\u0001\u0000\u0000\u0000\u0150\u0151\u0003L&\u0000"+
"\u0151\u0152\u0005\u0014\u0000\u0000\u0152\u0153\u0003H$\u0000\u0153C"+
"\u0001\u0000\u0000\u0000\u0154\u0155\u0003H$\u0000\u0155E\u0001\u0000"+
"\u0000\u0000\u0156\u015b\u0003H$\u0000\u0157\u0158\u0005\n\u0000\u0000"+
"\u0158\u015a\u0003H$\u0000\u0159\u0157\u0001\u0000\u0000\u0000\u015a\u015d"+
"\u0001\u0000\u0000\u0000\u015b\u0159\u0001\u0000\u0000\u0000\u015b\u015c"+
"\u0001\u0000\u0000\u0000\u015cG\u0001\u0000\u0000\u0000\u015d\u015b\u0001"+
"\u0000\u0000\u0000\u015e\u0166\u0003X,\u0000\u015f\u0166\u0003Z-\u0000"+
"\u0160\u0166\u0003\\.\u0000\u0161\u0166\u0003P(\u0000\u0162\u0166\u0003"+
"R)\u0000\u0163\u0166\u0003h4\u0000\u0164\u0166\u0003^/\u0000\u0165\u015e"+
"\u0001\u0000\u0000\u0000\u0165\u015f\u0001\u0000\u0000\u0000\u0165\u0160"+
"\u0001\u0000\u0000\u0000\u0165\u0161\u0001\u0000\u0000\u0000\u0165\u0162"+
"\u0001\u0000\u0000\u0000\u0165\u0163\u0001\u0000\u0000\u0000\u0165\u0164"+
"\u0001\u0000\u0000\u0000\u0166I\u0001\u0000\u0000\u0000\u0167\u016a\u0003"+
"Z-\u0000\u0168\u016a\u0003h4\u0000\u0169\u0167\u0001\u0000\u0000\u0000"+
"\u0169\u0168\u0001\u0000\u0000\u0000\u016aK\u0001\u0000\u0000\u0000\u016b"+
"\u016c\u00051\u0000\u0000\u016cM\u0001\u0000\u0000\u0000\u016d\u016e\u0005"+
"1\u0000\u0000\u016eO\u0001\u0000\u0000\u0000\u016f\u0170\u0005\t\u0000"+
"\u0000\u0170\u0175\u0003V+\u0000\u0171\u0172\u0005\n\u0000\u0000\u0172"+
"\u0174\u0003V+\u0000\u0173\u0171\u0001\u0000\u0000\u0000\u0174\u0177\u0001"+
"\u0000\u0000\u0000\u0175\u0173\u0001\u0000\u0000\u0000\u0175\u0176\u0001"+
"\u0000\u0000\u0000\u0176\u0178\u0001\u0000\u0000\u0000\u0177\u0175\u0001"+
"\u0000\u0000\u0000\u0178\u0179\u0005\u000b\u0000\u0000\u0179Q\u0001\u0000"+
"\u0000\u0000\u017a\u017b\u0003T*\u0000\u017bS\u0001\u0000\u0000\u0000"+
"\u017c\u017d\u0005\'\u0000\u0000\u017d\u017e\u0003V+\u0000\u017e\u017f"+
"\u0005\n\u0000\u0000\u017f\u0180\u0003L&\u0000\u0180\u0181\u0005\r\u0000"+
"\u0000\u0181U\u0001\u0000\u0000\u0000\u0182\u0185\u0003X,\u0000\u0183"+
"\u0185\u0003Z-\u0000\u0184\u0182\u0001\u0000\u0000\u0000\u0184\u0183\u0001"+
"\u0000\u0000\u0000\u0185W\u0001\u0000\u0000\u0000\u0186\u0188\u0005(\u0000"+
"\u0000\u0187\u0186\u0001\u0000\u0000\u0000\u0187\u0188\u0001\u0000\u0000"+
"\u0000\u0188\u0189\u0001\u0000\u0000\u0000\u0189\u018a\u0007\u0001\u0000"+
"\u0000\u018aY\u0001\u0000\u0000\u0000\u018b\u018c\u0005-\u0000\u0000\u018c"+
"[\u0001\u0000\u0000\u0000\u018d\u018e\u00050\u0000\u0000\u018e]\u0001"+
"\u0000\u0000\u0000\u018f\u0192\u0003`0\u0000\u0190\u0192\u0003f3\u0000"+
"\u0191\u018f\u0001\u0000\u0000\u0000\u0191\u0190\u0001\u0000\u0000\u0000"+
"\u0192_\u0001\u0000\u0000\u0000\u0193\u0194\u0005\t\u0000\u0000\u0194"+
"\u0199\u0003b1\u0000\u0195\u0196\u0005\n\u0000\u0000\u0196\u0198\u0003"+
"b1\u0000\u0197\u0195\u0001\u0000\u0000\u0000\u0198\u019b\u0001\u0000\u0000"+
"\u0000\u0199\u0197\u0001\u0000\u0000\u0000\u0199\u019a\u0001\u0000\u0000"+
"\u0000\u019a\u019c\u0001\u0000\u0000\u0000\u019b\u0199\u0001\u0000\u0000"+
"\u0000\u019c\u019d\u0005\u000b\u0000\u0000\u019d\u01a1\u0001\u0000\u0000"+
"\u0000\u019e\u019f\u0005\t\u0000\u0000\u019f\u01a1\u0005\u000b\u0000\u0000"+
"\u01a0\u0193\u0001\u0000\u0000\u0000\u01a0\u019e\u0001\u0000\u0000\u0000"+
"\u01a1a\u0001\u0000\u0000\u0000\u01a2\u01a3\u0005-\u0000\u0000\u01a3\u01a4"+
"\u0005)\u0000\u0000\u01a4\u01a5\u0003d2\u0000\u01a5c\u0001\u0000\u0000"+
"\u0000\u01a6\u01ad\u0005-\u0000\u0000\u01a7\u01ad\u00050\u0000\u0000\u01a8"+
"\u01ad\u0003X,\u0000\u01a9\u01ad\u0003`0\u0000\u01aa\u01ad\u0003f3\u0000"+
"\u01ab\u01ad\u0005*\u0000\u0000\u01ac\u01a6\u0001\u0000\u0000\u0000\u01ac"+
"\u01a7\u0001\u0000\u0000\u0000\u01ac\u01a8\u0001\u0000\u0000\u0000\u01ac"+
"\u01a9\u0001\u0000\u0000\u0000\u01ac\u01aa\u0001\u0000\u0000\u0000\u01ac"+
"\u01ab\u0001\u0000\u0000\u0000\u01ade\u0001\u0000\u0000\u0000\u01ae\u01af"+
"\u0005+\u0000\u0000\u01af\u01b4\u0003d2\u0000\u01b0\u01b1\u0005\n\u0000"+
"\u0000\u01b1\u01b3\u0003d2\u0000\u01b2\u01b0\u0001\u0000\u0000\u0000\u01b3"+
"\u01b6\u0001\u0000\u0000\u0000\u01b4\u01b2\u0001\u0000\u0000\u0000\u01b4"+
"\u01b5\u0001\u0000\u0000\u0000\u01b5\u01b7\u0001\u0000\u0000\u0000\u01b6"+
"\u01b4\u0001\u0000\u0000\u0000\u01b7\u01b8\u0005,\u0000\u0000\u01b8\u01bc"+
"\u0001\u0000\u0000\u0000\u01b9\u01ba\u0005+\u0000\u0000\u01ba\u01bc\u0005"+
",\u0000\u0000\u01bb\u01ae\u0001\u0000\u0000\u0000\u01bb\u01b9\u0001\u0000"+
"\u0000\u0000\u01bcg\u0001\u0000\u0000\u0000\u01bd\u01be\u00052\u0000\u0000"+
"\u01bei\u0001\u0000\u0000\u0000(orux~\u0083\u008b\u008e\u0096\u00a9\u00b4"+
"\u00b7\u00be\u00d3\u00dd\u00e7\u00e9\u00f4\u00f7\u00fe\u0105\u010c\u0113"+
"\u011a\u0124\u012d\u0134\u014d\u015b\u0165\u0169\u0175\u0184\u0187\u0191"+
"\u0199\u01a0\u01ac\u01b4\u01bb";
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