org.eclipse.jnosql.query.grammar.QueryParser Maven / Gradle / Ivy
// Generated from org/eclipse/jnosql/query/grammar/Query.g4 by ANTLR 4.9.3
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"})
public class QueryParser extends Parser {
static { RuntimeMetaData.checkVersion("4.9.3", 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);
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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) & ((1L << T__32) | (1L << T__33) | (1L << T__34) | (1L << T__35) | (1L << T__36) | (1L << T__37))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static 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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
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 =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\66\u01c2\4\2\t\2"+
"\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+
"\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
"\64\4\65\t\65\4\66\t\66\3\2\3\2\3\2\3\2\3\2\5\2r\n\2\3\2\5\2u\n\2\3\2"+
"\5\2x\n\2\3\2\5\2{\n\2\3\2\3\2\3\3\3\3\5\3\u0081\n\3\3\3\3\3\3\3\5\3\u0086"+
"\n\3\3\3\3\3\3\4\3\4\3\4\3\4\5\4\u008e\n\4\3\4\5\4\u0091\n\4\3\4\3\4\3"+
"\5\3\5\3\5\3\5\5\5\u0099\n\5\3\5\3\5\3\6\3\6\3\6\3\6\3\7\3\7\3\7\3\7\3"+
"\b\3\b\3\b\3\b\3\b\3\b\3\b\5\b\u00ac\n\b\3\b\3\b\3\b\3\t\3\t\3\t\3\t\7"+
"\t\u00b5\n\t\f\t\16\t\u00b8\13\t\5\t\u00ba\n\t\3\n\3\n\3\n\7\n\u00bf\n"+
"\n\f\n\16\n\u00c2\13\n\3\13\3\13\3\13\3\13\3\f\3\f\3\r\3\r\3\r\3\16\3"+
"\16\3\16\3\17\3\17\3\17\3\17\7\17\u00d4\n\17\f\17\16\17\u00d7\13\17\3"+
"\20\3\20\3\20\3\20\3\20\3\20\3\20\5\20\u00e0\n\20\3\21\3\21\3\21\3\21"+
"\3\21\3\21\3\21\3\21\7\21\u00ea\n\21\f\21\16\21\u00ed\13\21\3\22\3\22"+
"\3\22\3\22\3\22\3\22\3\22\3\22\5\22\u00f7\n\22\3\23\5\23\u00fa\n\23\3"+
"\23\3\23\3\23\3\23\3\24\5\24\u0101\n\24\3\24\3\24\3\24\3\24\3\25\5\25"+
"\u0108\n\25\3\25\3\25\3\25\3\25\3\26\5\26\u010f\n\26\3\26\3\26\3\26\3"+
"\26\3\27\5\27\u0116\n\27\3\27\3\27\3\27\3\27\3\30\5\30\u011d\n\30\3\30"+
"\3\30\3\30\3\30\3\30\3\30\3\31\3\31\5\31\u0127\n\31\3\31\3\31\3\31\3\31"+
"\3\31\7\31\u012e\n\31\f\31\16\31\u0131\13\31\3\31\3\31\3\32\3\32\5\32"+
"\u0137\n\32\3\32\3\32\3\32\3\33\3\33\3\34\3\34\3\35\3\35\3\36\3\36\3\37"+
"\3\37\3 \3 \3 \3!\3!\3\"\3\"\3\"\7\"\u014e\n\"\f\"\16\"\u0151\13\"\3#"+
"\3#\3#\3#\3$\3$\3%\3%\3%\7%\u015c\n%\f%\16%\u015f\13%\3&\3&\3&\3&\3&\3"+
"&\3&\5&\u0168\n&\3\'\3\'\5\'\u016c\n\'\3(\3(\3)\3)\3*\3*\3*\3*\7*\u0176"+
"\n*\f*\16*\u0179\13*\3*\3*\3+\3+\3,\3,\3,\3,\3,\3,\3-\3-\5-\u0187\n-\3"+
".\5.\u018a\n.\3.\3.\3/\3/\3\60\3\60\3\61\3\61\5\61\u0194\n\61\3\62\3\62"+
"\3\62\3\62\7\62\u019a\n\62\f\62\16\62\u019d\13\62\3\62\3\62\3\62\3\62"+
"\5\62\u01a3\n\62\3\63\3\63\3\63\3\63\3\64\3\64\3\64\3\64\3\64\3\64\5\64"+
"\u01af\n\64\3\65\3\65\3\65\3\65\7\65\u01b5\n\65\f\65\16\65\u01b8\13\65"+
"\3\65\3\65\3\65\3\65\5\65\u01be\n\65\3\66\3\66\3\66\2\2\67\2\4\6\b\n\f"+
"\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^"+
"`bdfhj\2\4\3\2#(\3\2\60\61\2\u01c4\2l\3\2\2\2\4~\3\2\2\2\6\u0089\3\2\2"+
"\2\b\u0094\3\2\2\2\n\u009c\3\2\2\2\f\u00a0\3\2\2\2\16\u00a4\3\2\2\2\20"+
"\u00b9\3\2\2\2\22\u00bb\3\2\2\2\24\u00c3\3\2\2\2\26\u00c7\3\2\2\2\30\u00c9"+
"\3\2\2\2\32\u00cc\3\2\2\2\34\u00cf\3\2\2\2\36\u00df\3\2\2\2 \u00e1\3\2"+
"\2\2\"\u00f6\3\2\2\2$\u00f9\3\2\2\2&\u0100\3\2\2\2(\u0107\3\2\2\2*\u010e"+
"\3\2\2\2,\u0115\3\2\2\2.\u011c\3\2\2\2\60\u0124\3\2\2\2\62\u0134\3\2\2"+
"\2\64\u013b\3\2\2\2\66\u013d\3\2\2\28\u013f\3\2\2\2:\u0141\3\2\2\2<\u0143"+
"\3\2\2\2>\u0145\3\2\2\2@\u0148\3\2\2\2B\u014a\3\2\2\2D\u0152\3\2\2\2F"+
"\u0156\3\2\2\2H\u0158\3\2\2\2J\u0167\3\2\2\2L\u016b\3\2\2\2N\u016d\3\2"+
"\2\2P\u016f\3\2\2\2R\u0171\3\2\2\2T\u017c\3\2\2\2V\u017e\3\2\2\2X\u0186"+
"\3\2\2\2Z\u0189\3\2\2\2\\\u018d\3\2\2\2^\u018f\3\2\2\2`\u0193\3\2\2\2"+
"b\u01a2\3\2\2\2d\u01a4\3\2\2\2f\u01ae\3\2\2\2h\u01bd\3\2\2\2j\u01bf\3"+
"\2\2\2lm\7\3\2\2mn\5\20\t\2no\7\4\2\2oq\5P)\2pr\5 \21\2qp\3\2\2\2qr\3"+
"\2\2\2rt\3\2\2\2su\5\30\r\2ts\3\2\2\2tu\3\2\2\2uw\3\2\2\2vx\5\32\16\2"+
"wv\3\2\2\2wx\3\2\2\2xz\3\2\2\2y{\5\34\17\2zy\3\2\2\2z{\3\2\2\2{|\3\2\2"+
"\2|}\7\2\2\3}\3\3\2\2\2~\u0080\7\5\2\2\177\u0081\5\22\n\2\u0080\177\3"+
"\2\2\2\u0080\u0081\3\2\2\2\u0081\u0082\3\2\2\2\u0082\u0083\7\4\2\2\u0083"+
"\u0085\5P)\2\u0084\u0086\5 \21\2\u0085\u0084\3\2\2\2\u0085\u0086\3\2\2"+
"\2\u0086\u0087\3\2\2\2\u0087\u0088\7\2\2\3\u0088\5\3\2\2\2\u0089\u008a"+
"\7\6\2\2\u008a\u008d\5P)\2\u008b\u008e\5\24\13\2\u008c\u008e\5`\61\2\u008d"+
"\u008b\3\2\2\2\u008d\u008c\3\2\2\2\u008e\u0090\3\2\2\2\u008f\u0091\5>"+
" \2\u0090\u008f\3\2\2\2\u0090\u0091\3\2\2\2\u0091\u0092\3\2\2\2\u0092"+
"\u0093\7\2\2\3\u0093\7\3\2\2\2\u0094\u0095\7\7\2\2\u0095\u0098\5P)\2\u0096"+
"\u0099\5\24\13\2\u0097\u0099\5`\61\2\u0098\u0096\3\2\2\2\u0098\u0097\3"+
"\2\2\2\u0099\u009a\3\2\2\2\u009a\u009b\7\2\2\3\u009b\t\3\2\2\2\u009c\u009d"+
"\7\b\2\2\u009d\u009e\5H%\2\u009e\u009f\7\2\2\3\u009f\13\3\2\2\2\u00a0"+
"\u00a1\7\t\2\2\u00a1\u00a2\5H%\2\u00a2\u00a3\7\2\2\3\u00a3\r\3\2\2\2\u00a4"+
"\u00a5\7\n\2\2\u00a5\u00a6\7\13\2\2\u00a6\u00a7\5F$\2\u00a7\u00a8\7\f"+
"\2\2\u00a8\u00ab\5J&\2\u00a9\u00aa\7\f\2\2\u00aa\u00ac\5> \2\u00ab\u00a9"+
"\3\2\2\2\u00ab\u00ac\3\2\2\2\u00ac\u00ad\3\2\2\2\u00ad\u00ae\7\r\2\2\u00ae"+
"\u00af\7\2\2\3\u00af\17\3\2\2\2\u00b0\u00ba\5\26\f\2\u00b1\u00b6\5N(\2"+
"\u00b2\u00b3\7\f\2\2\u00b3\u00b5\5N(\2\u00b4\u00b2\3\2\2\2\u00b5\u00b8"+
"\3\2\2\2\u00b6\u00b4\3\2\2\2\u00b6\u00b7\3\2\2\2\u00b7\u00ba\3\2\2\2\u00b8"+
"\u00b6\3\2\2\2\u00b9\u00b0\3\2\2\2\u00b9\u00b1\3\2\2\2\u00ba\21\3\2\2"+
"\2\u00bb\u00c0\5N(\2\u00bc\u00bd\7\f\2\2\u00bd\u00bf\5N(\2\u00be\u00bc"+
"\3\2\2\2\u00bf\u00c2\3\2\2\2\u00c0\u00be\3\2\2\2\u00c0\u00c1\3\2\2\2\u00c1"+
"\23\3\2\2\2\u00c2\u00c0\3\2\2\2\u00c3\u00c4\7\16\2\2\u00c4\u00c5\5B\""+
"\2\u00c5\u00c6\7\17\2\2\u00c6\25\3\2\2\2\u00c7\u00c8\7\20\2\2\u00c8\27"+
"\3\2\2\2\u00c9\u00ca\7\21\2\2\u00ca\u00cb\7\60\2\2\u00cb\31\3\2\2\2\u00cc"+
"\u00cd\7\22\2\2\u00cd\u00ce\7\60\2\2\u00ce\33\3\2\2\2\u00cf\u00d0\7\23"+
"\2\2\u00d0\u00d1\7\24\2\2\u00d1\u00d5\5\36\20\2\u00d2\u00d4\5\36\20\2"+
"\u00d3\u00d2\3\2\2\2\u00d4\u00d7\3\2\2\2\u00d5\u00d3\3\2\2\2\u00d5\u00d6"+
"\3\2\2\2\u00d6\35\3\2\2\2\u00d7\u00d5\3\2\2\2\u00d8\u00e0\5N(\2\u00d9"+
"\u00da\5N(\2\u00da\u00db\5\66\34\2\u00db\u00e0\3\2\2\2\u00dc\u00dd\5N"+
"(\2\u00dd\u00de\58\35\2\u00de\u00e0\3\2\2\2\u00df\u00d8\3\2\2\2\u00df"+
"\u00d9\3\2\2\2\u00df\u00dc\3\2\2\2\u00e0\37\3\2\2\2\u00e1\u00e2\7\25\2"+
"\2\u00e2\u00eb\5\"\22\2\u00e3\u00e4\5:\36\2\u00e4\u00e5\5\"\22\2\u00e5"+
"\u00ea\3\2\2\2\u00e6\u00e7\5<\37\2\u00e7\u00e8\5\"\22\2\u00e8\u00ea\3"+
"\2\2\2\u00e9\u00e3\3\2\2\2\u00e9\u00e6\3\2\2\2\u00ea\u00ed\3\2\2\2\u00eb"+
"\u00e9\3\2\2\2\u00eb\u00ec\3\2\2\2\u00ec!\3\2\2\2\u00ed\u00eb\3\2\2\2"+
"\u00ee\u00f7\5$\23\2\u00ef\u00f7\5&\24\2\u00f0\u00f7\5(\25\2\u00f1\u00f7"+
"\5*\26\2\u00f2\u00f7\5,\27\2\u00f3\u00f7\5.\30\2\u00f4\u00f7\5\60\31\2"+
"\u00f5\u00f7\5\62\32\2\u00f6\u00ee\3\2\2\2\u00f6\u00ef\3\2\2\2\u00f6\u00f0"+
"\3\2\2\2\u00f6\u00f1\3\2\2\2\u00f6\u00f2\3\2\2\2\u00f6\u00f3\3\2\2\2\u00f6"+
"\u00f4\3\2\2\2\u00f6\u00f5\3\2\2\2\u00f7#\3\2\2\2\u00f8\u00fa\5\64\33"+
"\2\u00f9\u00f8\3\2\2\2\u00f9\u00fa\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb\u00fc"+
"\5N(\2\u00fc\u00fd\7\26\2\2\u00fd\u00fe\5J&\2\u00fe%\3\2\2\2\u00ff\u0101"+
"\5\64\33\2\u0100\u00ff\3\2\2\2\u0100\u0101\3\2\2\2\u0101\u0102\3\2\2\2"+
"\u0102\u0103\5N(\2\u0103\u0104\7\27\2\2\u0104\u0105\5J&\2\u0105\'\3\2"+
"\2\2\u0106\u0108\5\64\33\2\u0107\u0106\3\2\2\2\u0107\u0108\3\2\2\2\u0108"+
"\u0109\3\2\2\2\u0109\u010a\5N(\2\u010a\u010b\7\30\2\2\u010b\u010c\5J&"+
"\2\u010c)\3\2\2\2\u010d\u010f\5\64\33\2\u010e\u010d\3\2\2\2\u010e\u010f"+
"\3\2\2\2\u010f\u0110\3\2\2\2\u0110\u0111\5N(\2\u0111\u0112\7\31\2\2\u0112"+
"\u0113\5J&\2\u0113+\3\2\2\2\u0114\u0116\5\64\33\2\u0115\u0114\3\2\2\2"+
"\u0115\u0116\3\2\2\2\u0116\u0117\3\2\2\2\u0117\u0118\5N(\2\u0118\u0119"+
"\7\32\2\2\u0119\u011a\5J&\2\u011a-\3\2\2\2\u011b\u011d\5\64\33\2\u011c"+
"\u011b\3\2\2\2\u011c\u011d\3\2\2\2\u011d\u011e\3\2\2\2\u011e\u011f\5N"+
"(\2\u011f\u0120\7\33\2\2\u0120\u0121\5J&\2\u0121\u0122\7\34\2\2\u0122"+
"\u0123\5J&\2\u0123/\3\2\2\2\u0124\u0126\5N(\2\u0125\u0127\5\64\33\2\u0126"+
"\u0125\3\2\2\2\u0126\u0127\3\2\2\2\u0127\u0128\3\2\2\2\u0128\u0129\7\35"+
"\2\2\u0129\u012a\7\16\2\2\u012a\u012f\5J&\2\u012b\u012c\7\f\2\2\u012c"+
"\u012e\5J&\2\u012d\u012b\3\2\2\2\u012e\u0131\3\2\2\2\u012f\u012d\3\2\2"+
"\2\u012f\u0130\3\2\2\2\u0130\u0132\3\2\2\2\u0131\u012f\3\2\2\2\u0132\u0133"+
"\7\17\2\2\u0133\61\3\2\2\2\u0134\u0136\5N(\2\u0135\u0137\5\64\33\2\u0136"+
"\u0135\3\2\2\2\u0136\u0137\3\2\2\2\u0137\u0138\3\2\2\2\u0138\u0139\7\36"+
"\2\2\u0139\u013a\5L\'\2\u013a\63\3\2\2\2\u013b\u013c\7\37\2\2\u013c\65"+
"\3\2\2\2\u013d\u013e\7 \2\2\u013e\67\3\2\2\2\u013f\u0140\7!\2\2\u0140"+
"9\3\2\2\2\u0141\u0142\7\34\2\2\u0142;\3\2\2\2\u0143\u0144\7\"\2\2\u0144"+
"=\3\2\2\2\u0145\u0146\7\60\2\2\u0146\u0147\5@!\2\u0147?\3\2\2\2\u0148"+
"\u0149\t\2\2\2\u0149A\3\2\2\2\u014a\u014f\5D#\2\u014b\u014c\7\f\2\2\u014c"+
"\u014e\5D#\2\u014d\u014b\3\2\2\2\u014e\u0151\3\2\2\2\u014f\u014d\3\2\2"+
"\2\u014f\u0150\3\2\2\2\u0150C\3\2\2\2\u0151\u014f\3\2\2\2\u0152\u0153"+
"\5N(\2\u0153\u0154\7\26\2\2\u0154\u0155\5J&\2\u0155E\3\2\2\2\u0156\u0157"+
"\5J&\2\u0157G\3\2\2\2\u0158\u015d\5J&\2\u0159\u015a\7\f\2\2\u015a\u015c"+
"\5J&\2\u015b\u0159\3\2\2\2\u015c\u015f\3\2\2\2\u015d\u015b\3\2\2\2\u015d"+
"\u015e\3\2\2\2\u015eI\3\2\2\2\u015f\u015d\3\2\2\2\u0160\u0168\5Z.\2\u0161"+
"\u0168\5\\/\2\u0162\u0168\5^\60\2\u0163\u0168\5R*\2\u0164\u0168\5T+\2"+
"\u0165\u0168\5j\66\2\u0166\u0168\5`\61\2\u0167\u0160\3\2\2\2\u0167\u0161"+
"\3\2\2\2\u0167\u0162\3\2\2\2\u0167\u0163\3\2\2\2\u0167\u0164\3\2\2\2\u0167"+
"\u0165\3\2\2\2\u0167\u0166\3\2\2\2\u0168K\3\2\2\2\u0169\u016c\5\\/\2\u016a"+
"\u016c\5j\66\2\u016b\u0169\3\2\2\2\u016b\u016a\3\2\2\2\u016cM\3\2\2\2"+
"\u016d\u016e\7\63\2\2\u016eO\3\2\2\2\u016f\u0170\7\63\2\2\u0170Q\3\2\2"+
"\2\u0171\u0172\7\13\2\2\u0172\u0177\5X-\2\u0173\u0174\7\f\2\2\u0174\u0176"+
"\5X-\2\u0175\u0173\3\2\2\2\u0176\u0179\3\2\2\2\u0177\u0175\3\2\2\2\u0177"+
"\u0178\3\2\2\2\u0178\u017a\3\2\2\2\u0179\u0177\3\2\2\2\u017a\u017b\7\r"+
"\2\2\u017bS\3\2\2\2\u017c\u017d\5V,\2\u017dU\3\2\2\2\u017e\u017f\7)\2"+
"\2\u017f\u0180\5X-\2\u0180\u0181\7\f\2\2\u0181\u0182\5N(\2\u0182\u0183"+
"\7\17\2\2\u0183W\3\2\2\2\u0184\u0187\5Z.\2\u0185\u0187\5\\/\2\u0186\u0184"+
"\3\2\2\2\u0186\u0185\3\2\2\2\u0187Y\3\2\2\2\u0188\u018a\7*\2\2\u0189\u0188"+
"\3\2\2\2\u0189\u018a\3\2\2\2\u018a\u018b\3\2\2\2\u018b\u018c\t\3\2\2\u018c"+
"[\3\2\2\2\u018d\u018e\7/\2\2\u018e]\3\2\2\2\u018f\u0190\7\62\2\2\u0190"+
"_\3\2\2\2\u0191\u0194\5b\62\2\u0192\u0194\5h\65\2\u0193\u0191\3\2\2\2"+
"\u0193\u0192\3\2\2\2\u0194a\3\2\2\2\u0195\u0196\7\13\2\2\u0196\u019b\5"+
"d\63\2\u0197\u0198\7\f\2\2\u0198\u019a\5d\63\2\u0199\u0197\3\2\2\2\u019a"+
"\u019d\3\2\2\2\u019b\u0199\3\2\2\2\u019b\u019c\3\2\2\2\u019c\u019e\3\2"+
"\2\2\u019d\u019b\3\2\2\2\u019e\u019f\7\r\2\2\u019f\u01a3\3\2\2\2\u01a0"+
"\u01a1\7\13\2\2\u01a1\u01a3\7\r\2\2\u01a2\u0195\3\2\2\2\u01a2\u01a0\3"+
"\2\2\2\u01a3c\3\2\2\2\u01a4\u01a5\7/\2\2\u01a5\u01a6\7+\2\2\u01a6\u01a7"+
"\5f\64\2\u01a7e\3\2\2\2\u01a8\u01af\7/\2\2\u01a9\u01af\7\62\2\2\u01aa"+
"\u01af\5Z.\2\u01ab\u01af\5b\62\2\u01ac\u01af\5h\65\2\u01ad\u01af\7,\2"+
"\2\u01ae\u01a8\3\2\2\2\u01ae\u01a9\3\2\2\2\u01ae\u01aa\3\2\2\2\u01ae\u01ab"+
"\3\2\2\2\u01ae\u01ac\3\2\2\2\u01ae\u01ad\3\2\2\2\u01afg\3\2\2\2\u01b0"+
"\u01b1\7-\2\2\u01b1\u01b6\5f\64\2\u01b2\u01b3\7\f\2\2\u01b3\u01b5\5f\64"+
"\2\u01b4\u01b2\3\2\2\2\u01b5\u01b8\3\2\2\2\u01b6\u01b4\3\2\2\2\u01b6\u01b7"+
"\3\2\2\2\u01b7\u01b9\3\2\2\2\u01b8\u01b6\3\2\2\2\u01b9\u01ba\7.\2\2\u01ba"+
"\u01be\3\2\2\2\u01bb\u01bc\7-\2\2\u01bc\u01be\7.\2\2\u01bd\u01b0\3\2\2"+
"\2\u01bd\u01bb\3\2\2\2\u01bei\3\2\2\2\u01bf\u01c0\7\64\2\2\u01c0k\3\2"+
"\2\2*qtwz\u0080\u0085\u008d\u0090\u0098\u00ab\u00b6\u00b9\u00c0\u00d5"+
"\u00df\u00e9\u00eb\u00f6\u00f9\u0100\u0107\u010e\u0115\u011c\u0126\u012f"+
"\u0136\u014f\u015d\u0167\u016b\u0177\u0186\u0189\u0193\u019b\u01a2\u01ae"+
"\u01b6\u01bd";
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