876 lines
32 KiB
Java
876 lines
32 KiB
Java
// Generated from OQL.g4 by ANTLR 4.4
|
|
package com.amarsoft.app.base.antlr;
|
|
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 OQLParser extends Parser {
|
|
static { RuntimeMetaData.checkVersion("4.4", RuntimeMetaData.VERSION); }
|
|
|
|
protected static final DFA[] _decisionToDFA;
|
|
protected static final PredictionContextCache _sharedContextCache =
|
|
new PredictionContextCache();
|
|
public static final int
|
|
WS=1, PARAMETER=2, ADD=3, SUB=4, MUL=5, DIV=6, IN=7, NOTIN=8, GREATE_THAN=9,
|
|
GREATE_EQUAL_THAN=10, LESS_THAN=11, LESS_EQUAL_THAN=12, EQUAL=13, TRUE=14,
|
|
FALSE=15, NULL=16, NOT_EQUAL=17, LOGICAL_AND=18, LOGICAL_OR=19, LEFT_PAREN=20,
|
|
RIGHT_PAREN=21, COMMA=22, LIKE=23, LENGTH=24, MONTH=25, ATTRIBUTE=26,
|
|
NUMBER=27, STRING=28;
|
|
public static final String[] tokenNames = {
|
|
"<INVALID>", "WS", "PARAMETER", "'+'", "'-'", "'*'", "'/'", "'in'", "'not in'",
|
|
"'>'", "'>='", "'<'", "'<='", "'='", "'true'", "'false'", "NULL", "'<>'",
|
|
"'and'", "'or'", "'('", "')'", "','", "'like'", "'length'", "'month'",
|
|
"ATTRIBUTE", "NUMBER", "STRING"
|
|
};
|
|
public static final int
|
|
RULE_expression = 0, RULE_equality_expression = 1;
|
|
public static final String[] ruleNames = {
|
|
"expression", "equality_expression"
|
|
};
|
|
|
|
@Override
|
|
public String getGrammarFileName() { return "OQL.g4"; }
|
|
|
|
@Override
|
|
public String[] getTokenNames() { return tokenNames; }
|
|
|
|
@Override
|
|
public String[] getRuleNames() { return ruleNames; }
|
|
|
|
@Override
|
|
public String getSerializedATN() { return _serializedATN; }
|
|
|
|
@Override
|
|
public ATN getATN() { return _ATN; }
|
|
|
|
public OQLParser(TokenStream input) {
|
|
super(input);
|
|
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
|
|
}
|
|
public static class ExpressionContext extends ParserRuleContext {
|
|
public ExpressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_expression; }
|
|
|
|
public ExpressionContext() { }
|
|
public void copyFrom(ExpressionContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
public static class SubExprContext extends ExpressionContext {
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode SUB() { return getToken(OQLParser.SUB, 0); }
|
|
public SubExprContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).enterSubExpr(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).exitSubExpr(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitSubExpr(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
public static class LogicalMonthContext extends ExpressionContext {
|
|
public ExpressionContext expression(int i) {
|
|
return getRuleContext(ExpressionContext.class,i);
|
|
}
|
|
public TerminalNode MONTH() { return getToken(OQLParser.MONTH, 0); }
|
|
public TerminalNode COMMA() { return getToken(OQLParser.COMMA, 0); }
|
|
public List<ExpressionContext> expression() {
|
|
return getRuleContexts(ExpressionContext.class);
|
|
}
|
|
public TerminalNode RIGHT_PAREN() { return getToken(OQLParser.RIGHT_PAREN, 0); }
|
|
public TerminalNode LEFT_PAREN() { return getToken(OQLParser.LEFT_PAREN, 0); }
|
|
public LogicalMonthContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).enterLogicalMonth(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).exitLogicalMonth(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitLogicalMonth(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
public static class StringContext extends ExpressionContext {
|
|
public TerminalNode STRING() { return getToken(OQLParser.STRING, 0); }
|
|
public StringContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).enterString(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).exitString(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitString(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
public static class NumberContext extends ExpressionContext {
|
|
public TerminalNode NUMBER() { return getToken(OQLParser.NUMBER, 0); }
|
|
public NumberContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).enterNumber(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).exitNumber(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitNumber(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
public static class AddSubContext extends ExpressionContext {
|
|
public Token op;
|
|
public ExpressionContext expression(int i) {
|
|
return getRuleContext(ExpressionContext.class,i);
|
|
}
|
|
public List<ExpressionContext> expression() {
|
|
return getRuleContexts(ExpressionContext.class);
|
|
}
|
|
public TerminalNode SUB() { return getToken(OQLParser.SUB, 0); }
|
|
public TerminalNode ADD() { return getToken(OQLParser.ADD, 0); }
|
|
public AddSubContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).enterAddSub(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).exitAddSub(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitAddSub(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
public static class LogicalLengthContext extends ExpressionContext {
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode RIGHT_PAREN() { return getToken(OQLParser.RIGHT_PAREN, 0); }
|
|
public TerminalNode LENGTH() { return getToken(OQLParser.LENGTH, 0); }
|
|
public TerminalNode LEFT_PAREN() { return getToken(OQLParser.LEFT_PAREN, 0); }
|
|
public LogicalLengthContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).enterLogicalLength(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).exitLogicalLength(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitLogicalLength(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
public static class ArrayExprContext extends ExpressionContext {
|
|
public TerminalNode STRING(int i) {
|
|
return getToken(OQLParser.STRING, i);
|
|
}
|
|
public List<TerminalNode> COMMA() { return getTokens(OQLParser.COMMA); }
|
|
public List<TerminalNode> ATTRIBUTE() { return getTokens(OQLParser.ATTRIBUTE); }
|
|
public List<TerminalNode> STRING() { return getTokens(OQLParser.STRING); }
|
|
public TerminalNode COMMA(int i) {
|
|
return getToken(OQLParser.COMMA, i);
|
|
}
|
|
public TerminalNode ATTRIBUTE(int i) {
|
|
return getToken(OQLParser.ATTRIBUTE, i);
|
|
}
|
|
public ArrayExprContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).enterArrayExpr(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).exitArrayExpr(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitArrayExpr(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
public static class AttributeContext extends ExpressionContext {
|
|
public TerminalNode ATTRIBUTE() { return getToken(OQLParser.ATTRIBUTE, 0); }
|
|
public AttributeContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).enterAttribute(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).exitAttribute(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitAttribute(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
public static class ParameterContext extends ExpressionContext {
|
|
public TerminalNode PARAMETER() { return getToken(OQLParser.PARAMETER, 0); }
|
|
public ParameterContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).enterParameter(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).exitParameter(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitParameter(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
public static class ParenContext extends ExpressionContext {
|
|
public ExpressionContext expression() {
|
|
return getRuleContext(ExpressionContext.class,0);
|
|
}
|
|
public TerminalNode RIGHT_PAREN() { return getToken(OQLParser.RIGHT_PAREN, 0); }
|
|
public TerminalNode LEFT_PAREN() { return getToken(OQLParser.LEFT_PAREN, 0); }
|
|
public ParenContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).enterParen(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).exitParen(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitParen(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
public static class NullContext extends ExpressionContext {
|
|
public TerminalNode NULL() { return getToken(OQLParser.NULL, 0); }
|
|
public NullContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).enterNull(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).exitNull(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitNull(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
public static class MulDivContext extends ExpressionContext {
|
|
public Token op;
|
|
public ExpressionContext expression(int i) {
|
|
return getRuleContext(ExpressionContext.class,i);
|
|
}
|
|
public TerminalNode MUL() { return getToken(OQLParser.MUL, 0); }
|
|
public TerminalNode DIV() { return getToken(OQLParser.DIV, 0); }
|
|
public List<ExpressionContext> expression() {
|
|
return getRuleContexts(ExpressionContext.class);
|
|
}
|
|
public MulDivContext(ExpressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).enterMulDiv(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).exitMulDiv(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitMulDiv(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final ExpressionContext expression() throws RecognitionException {
|
|
return expression(0);
|
|
}
|
|
|
|
private ExpressionContext expression(int _p) throws RecognitionException {
|
|
ParserRuleContext _parentctx = _ctx;
|
|
int _parentState = getState();
|
|
ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState);
|
|
ExpressionContext _prevctx = _localctx;
|
|
int _startState = 0;
|
|
enterRecursionRule(_localctx, 0, RULE_expression, _p);
|
|
int _la;
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(36);
|
|
switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) {
|
|
case 1:
|
|
{
|
|
_localctx = new SubExprContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
|
|
setState(5); match(SUB);
|
|
setState(6); expression(7);
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
_localctx = new NumberContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
setState(7); match(NUMBER);
|
|
}
|
|
break;
|
|
case 3:
|
|
{
|
|
_localctx = new NullContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
setState(8); match(NULL);
|
|
}
|
|
break;
|
|
case 4:
|
|
{
|
|
_localctx = new StringContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
setState(9); match(STRING);
|
|
}
|
|
break;
|
|
case 5:
|
|
{
|
|
_localctx = new ParameterContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
setState(10); match(PARAMETER);
|
|
}
|
|
break;
|
|
case 6:
|
|
{
|
|
_localctx = new AttributeContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
setState(11); match(ATTRIBUTE);
|
|
}
|
|
break;
|
|
case 7:
|
|
{
|
|
_localctx = new LogicalLengthContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
setState(12); match(LENGTH);
|
|
setState(13); match(LEFT_PAREN);
|
|
setState(14); expression(0);
|
|
setState(15); match(RIGHT_PAREN);
|
|
}
|
|
break;
|
|
case 8:
|
|
{
|
|
_localctx = new LogicalMonthContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
setState(17); match(MONTH);
|
|
setState(18); match(LEFT_PAREN);
|
|
setState(19); expression(0);
|
|
setState(20); match(COMMA);
|
|
setState(21); expression(0);
|
|
setState(22); match(RIGHT_PAREN);
|
|
}
|
|
break;
|
|
case 9:
|
|
{
|
|
_localctx = new ArrayExprContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
setState(24);
|
|
_la = _input.LA(1);
|
|
if ( !(_la==ATTRIBUTE || _la==STRING) ) {
|
|
_errHandler.recoverInline(this);
|
|
}
|
|
consume();
|
|
setState(29);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,0,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
{
|
|
{
|
|
setState(25); match(COMMA);
|
|
setState(26);
|
|
_la = _input.LA(1);
|
|
if ( !(_la==ATTRIBUTE || _la==STRING) ) {
|
|
_errHandler.recoverInline(this);
|
|
}
|
|
consume();
|
|
}
|
|
}
|
|
}
|
|
setState(31);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,0,_ctx);
|
|
}
|
|
}
|
|
break;
|
|
case 10:
|
|
{
|
|
_localctx = new ParenContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
setState(32); match(LEFT_PAREN);
|
|
setState(33); expression(0);
|
|
setState(34); match(RIGHT_PAREN);
|
|
}
|
|
break;
|
|
}
|
|
_ctx.stop = _input.LT(-1);
|
|
setState(46);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,3,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
if ( _parseListeners!=null ) triggerExitRuleEvent();
|
|
_prevctx = _localctx;
|
|
{
|
|
setState(44);
|
|
switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
|
|
case 1:
|
|
{
|
|
_localctx = new MulDivContext(new ExpressionContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_expression);
|
|
setState(38);
|
|
if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
|
|
setState(39);
|
|
((MulDivContext)_localctx).op = _input.LT(1);
|
|
_la = _input.LA(1);
|
|
if ( !(_la==MUL || _la==DIV) ) {
|
|
((MulDivContext)_localctx).op = (Token)_errHandler.recoverInline(this);
|
|
}
|
|
consume();
|
|
setState(40); expression(7);
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
_localctx = new AddSubContext(new ExpressionContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_expression);
|
|
setState(41);
|
|
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
|
|
setState(42);
|
|
((AddSubContext)_localctx).op = _input.LT(1);
|
|
_la = _input.LA(1);
|
|
if ( !(_la==ADD || _la==SUB) ) {
|
|
((AddSubContext)_localctx).op = (Token)_errHandler.recoverInline(this);
|
|
}
|
|
consume();
|
|
setState(43); expression(6);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
setState(48);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,3,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
unrollRecursionContexts(_parentctx);
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public static class Equality_expressionContext extends ParserRuleContext {
|
|
public Equality_expressionContext(ParserRuleContext parent, int invokingState) {
|
|
super(parent, invokingState);
|
|
}
|
|
@Override public int getRuleIndex() { return RULE_equality_expression; }
|
|
|
|
public Equality_expressionContext() { }
|
|
public void copyFrom(Equality_expressionContext ctx) {
|
|
super.copyFrom(ctx);
|
|
}
|
|
}
|
|
public static class LogicalTrueContext extends Equality_expressionContext {
|
|
public TerminalNode TRUE() { return getToken(OQLParser.TRUE, 0); }
|
|
public LogicalTrueContext(Equality_expressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).enterLogicalTrue(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).exitLogicalTrue(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitLogicalTrue(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
public static class LogicalAndOrContext extends Equality_expressionContext {
|
|
public Token op;
|
|
public TerminalNode LOGICAL_AND() { return getToken(OQLParser.LOGICAL_AND, 0); }
|
|
public Equality_expressionContext equality_expression(int i) {
|
|
return getRuleContext(Equality_expressionContext.class,i);
|
|
}
|
|
public List<Equality_expressionContext> equality_expression() {
|
|
return getRuleContexts(Equality_expressionContext.class);
|
|
}
|
|
public TerminalNode LOGICAL_OR() { return getToken(OQLParser.LOGICAL_OR, 0); }
|
|
public LogicalAndOrContext(Equality_expressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).enterLogicalAndOr(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).exitLogicalAndOr(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitLogicalAndOr(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
public static class LogicalNotInContext extends Equality_expressionContext {
|
|
public Token op;
|
|
public ExpressionContext expression(int i) {
|
|
return getRuleContext(ExpressionContext.class,i);
|
|
}
|
|
public TerminalNode NOTIN() { return getToken(OQLParser.NOTIN, 0); }
|
|
public List<ExpressionContext> expression() {
|
|
return getRuleContexts(ExpressionContext.class);
|
|
}
|
|
public TerminalNode RIGHT_PAREN() { return getToken(OQLParser.RIGHT_PAREN, 0); }
|
|
public TerminalNode LEFT_PAREN() { return getToken(OQLParser.LEFT_PAREN, 0); }
|
|
public LogicalNotInContext(Equality_expressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).enterLogicalNotIn(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).exitLogicalNotIn(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitLogicalNotIn(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
public static class LogicalFalseContext extends Equality_expressionContext {
|
|
public TerminalNode FALSE() { return getToken(OQLParser.FALSE, 0); }
|
|
public LogicalFalseContext(Equality_expressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).enterLogicalFalse(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).exitLogicalFalse(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitLogicalFalse(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
public static class Paren2Context extends Equality_expressionContext {
|
|
public Equality_expressionContext equality_expression() {
|
|
return getRuleContext(Equality_expressionContext.class,0);
|
|
}
|
|
public TerminalNode RIGHT_PAREN() { return getToken(OQLParser.RIGHT_PAREN, 0); }
|
|
public TerminalNode LEFT_PAREN() { return getToken(OQLParser.LEFT_PAREN, 0); }
|
|
public Paren2Context(Equality_expressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).enterParen2(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).exitParen2(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitParen2(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
public static class LogicalInContext extends Equality_expressionContext {
|
|
public Token op;
|
|
public TerminalNode IN() { return getToken(OQLParser.IN, 0); }
|
|
public ExpressionContext expression(int i) {
|
|
return getRuleContext(ExpressionContext.class,i);
|
|
}
|
|
public List<ExpressionContext> expression() {
|
|
return getRuleContexts(ExpressionContext.class);
|
|
}
|
|
public TerminalNode RIGHT_PAREN() { return getToken(OQLParser.RIGHT_PAREN, 0); }
|
|
public TerminalNode LEFT_PAREN() { return getToken(OQLParser.LEFT_PAREN, 0); }
|
|
public LogicalInContext(Equality_expressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).enterLogicalIn(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).exitLogicalIn(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitLogicalIn(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
public static class LogicalCompareContext extends Equality_expressionContext {
|
|
public Token op;
|
|
public TerminalNode LESS_THAN() { return getToken(OQLParser.LESS_THAN, 0); }
|
|
public ExpressionContext expression(int i) {
|
|
return getRuleContext(ExpressionContext.class,i);
|
|
}
|
|
public TerminalNode LESS_EQUAL_THAN() { return getToken(OQLParser.LESS_EQUAL_THAN, 0); }
|
|
public TerminalNode GREATE_EQUAL_THAN() { return getToken(OQLParser.GREATE_EQUAL_THAN, 0); }
|
|
public List<ExpressionContext> expression() {
|
|
return getRuleContexts(ExpressionContext.class);
|
|
}
|
|
public TerminalNode EQUAL() { return getToken(OQLParser.EQUAL, 0); }
|
|
public TerminalNode LIKE() { return getToken(OQLParser.LIKE, 0); }
|
|
public TerminalNode NOT_EQUAL() { return getToken(OQLParser.NOT_EQUAL, 0); }
|
|
public TerminalNode GREATE_THAN() { return getToken(OQLParser.GREATE_THAN, 0); }
|
|
public LogicalCompareContext(Equality_expressionContext ctx) { copyFrom(ctx); }
|
|
@Override
|
|
public void enterRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).enterLogicalCompare(this);
|
|
}
|
|
@Override
|
|
public void exitRule(ParseTreeListener listener) {
|
|
if ( listener instanceof OQLListener ) ((OQLListener)listener).exitLogicalCompare(this);
|
|
}
|
|
@Override
|
|
public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
|
|
if ( visitor instanceof OQLVisitor ) return ((OQLVisitor<? extends T>)visitor).visitLogicalCompare(this);
|
|
else return visitor.visitChildren(this);
|
|
}
|
|
}
|
|
|
|
public final Equality_expressionContext equality_expression() throws RecognitionException {
|
|
return equality_expression(0);
|
|
}
|
|
|
|
private Equality_expressionContext equality_expression(int _p) throws RecognitionException {
|
|
ParserRuleContext _parentctx = _ctx;
|
|
int _parentState = getState();
|
|
Equality_expressionContext _localctx = new Equality_expressionContext(_ctx, _parentState);
|
|
Equality_expressionContext _prevctx = _localctx;
|
|
int _startState = 2;
|
|
enterRecursionRule(_localctx, 2, RULE_equality_expression, _p);
|
|
int _la;
|
|
try {
|
|
int _alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
{
|
|
setState(72);
|
|
switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
|
|
case 1:
|
|
{
|
|
_localctx = new LogicalTrueContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
|
|
setState(50); match(TRUE);
|
|
}
|
|
break;
|
|
case 2:
|
|
{
|
|
_localctx = new LogicalFalseContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
setState(51); match(FALSE);
|
|
}
|
|
break;
|
|
case 3:
|
|
{
|
|
_localctx = new LogicalCompareContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
setState(52); expression(0);
|
|
setState(53);
|
|
((LogicalCompareContext)_localctx).op = _input.LT(1);
|
|
_la = _input.LA(1);
|
|
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << GREATE_THAN) | (1L << GREATE_EQUAL_THAN) | (1L << LESS_THAN) | (1L << LESS_EQUAL_THAN) | (1L << EQUAL) | (1L << NOT_EQUAL) | (1L << LIKE))) != 0)) ) {
|
|
((LogicalCompareContext)_localctx).op = (Token)_errHandler.recoverInline(this);
|
|
}
|
|
consume();
|
|
setState(54); expression(0);
|
|
}
|
|
break;
|
|
case 4:
|
|
{
|
|
_localctx = new LogicalInContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
setState(56); expression(0);
|
|
setState(57); ((LogicalInContext)_localctx).op = match(IN);
|
|
setState(58); match(LEFT_PAREN);
|
|
setState(59); expression(0);
|
|
setState(60); match(RIGHT_PAREN);
|
|
}
|
|
break;
|
|
case 5:
|
|
{
|
|
_localctx = new LogicalNotInContext(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
setState(62); expression(0);
|
|
setState(63); ((LogicalNotInContext)_localctx).op = match(NOTIN);
|
|
setState(64); match(LEFT_PAREN);
|
|
setState(65); expression(0);
|
|
setState(66); match(RIGHT_PAREN);
|
|
}
|
|
break;
|
|
case 6:
|
|
{
|
|
_localctx = new Paren2Context(_localctx);
|
|
_ctx = _localctx;
|
|
_prevctx = _localctx;
|
|
setState(68); match(LEFT_PAREN);
|
|
setState(69); equality_expression(0);
|
|
setState(70); match(RIGHT_PAREN);
|
|
}
|
|
break;
|
|
}
|
|
_ctx.stop = _input.LT(-1);
|
|
setState(79);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
|
|
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
|
|
if ( _alt==1 ) {
|
|
if ( _parseListeners!=null ) triggerExitRuleEvent();
|
|
_prevctx = _localctx;
|
|
{
|
|
{
|
|
_localctx = new LogicalAndOrContext(new Equality_expressionContext(_parentctx, _parentState));
|
|
pushNewRecursionContext(_localctx, _startState, RULE_equality_expression);
|
|
setState(74);
|
|
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
|
|
setState(75);
|
|
((LogicalAndOrContext)_localctx).op = _input.LT(1);
|
|
_la = _input.LA(1);
|
|
if ( !(_la==LOGICAL_AND || _la==LOGICAL_OR) ) {
|
|
((LogicalAndOrContext)_localctx).op = (Token)_errHandler.recoverInline(this);
|
|
}
|
|
consume();
|
|
setState(76); equality_expression(3);
|
|
}
|
|
}
|
|
}
|
|
setState(81);
|
|
_errHandler.sync(this);
|
|
_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
|
|
}
|
|
}
|
|
}
|
|
catch (RecognitionException re) {
|
|
_localctx.exception = re;
|
|
_errHandler.reportError(this, re);
|
|
_errHandler.recover(this, re);
|
|
}
|
|
finally {
|
|
unrollRecursionContexts(_parentctx);
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
|
|
switch (ruleIndex) {
|
|
case 0: return expression_sempred((ExpressionContext)_localctx, predIndex);
|
|
case 1: return equality_expression_sempred((Equality_expressionContext)_localctx, predIndex);
|
|
}
|
|
return true;
|
|
}
|
|
private boolean expression_sempred(ExpressionContext _localctx, int predIndex) {
|
|
switch (predIndex) {
|
|
case 0: return precpred(_ctx, 6);
|
|
case 1: return precpred(_ctx, 5);
|
|
}
|
|
return true;
|
|
}
|
|
private boolean equality_expression_sempred(Equality_expressionContext _localctx, int predIndex) {
|
|
switch (predIndex) {
|
|
case 2: return precpred(_ctx, 2);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static final String _serializedATN =
|
|
"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\36U\4\2\t\2\4\3\t"+
|
|
"\3\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2\3\2"+
|
|
"\3\2\3\2\3\2\3\2\3\2\3\2\7\2\36\n\2\f\2\16\2!\13\2\3\2\3\2\3\2\3\2\5\2"+
|
|
"\'\n\2\3\2\3\2\3\2\3\2\3\2\3\2\7\2/\n\2\f\2\16\2\62\13\2\3\3\3\3\3\3\3"+
|
|
"\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3"+
|
|
"\3\3\3\3\5\3K\n\3\3\3\3\3\3\3\7\3P\n\3\f\3\16\3S\13\3\3\3\2\4\2\4\4\2"+
|
|
"\4\2\7\4\2\34\34\36\36\3\2\7\b\3\2\5\6\5\2\13\17\23\23\31\31\3\2\24\25"+
|
|
"d\2&\3\2\2\2\4J\3\2\2\2\6\7\b\2\1\2\7\b\7\6\2\2\b\'\5\2\2\t\t\'\7\35\2"+
|
|
"\2\n\'\7\22\2\2\13\'\7\36\2\2\f\'\7\4\2\2\r\'\7\34\2\2\16\17\7\32\2\2"+
|
|
"\17\20\7\26\2\2\20\21\5\2\2\2\21\22\7\27\2\2\22\'\3\2\2\2\23\24\7\33\2"+
|
|
"\2\24\25\7\26\2\2\25\26\5\2\2\2\26\27\7\30\2\2\27\30\5\2\2\2\30\31\7\27"+
|
|
"\2\2\31\'\3\2\2\2\32\37\t\2\2\2\33\34\7\30\2\2\34\36\t\2\2\2\35\33\3\2"+
|
|
"\2\2\36!\3\2\2\2\37\35\3\2\2\2\37 \3\2\2\2 \'\3\2\2\2!\37\3\2\2\2\"#\7"+
|
|
"\26\2\2#$\5\2\2\2$%\7\27\2\2%\'\3\2\2\2&\6\3\2\2\2&\t\3\2\2\2&\n\3\2\2"+
|
|
"\2&\13\3\2\2\2&\f\3\2\2\2&\r\3\2\2\2&\16\3\2\2\2&\23\3\2\2\2&\32\3\2\2"+
|
|
"\2&\"\3\2\2\2\'\60\3\2\2\2()\f\b\2\2)*\t\3\2\2*/\5\2\2\t+,\f\7\2\2,-\t"+
|
|
"\4\2\2-/\5\2\2\b.(\3\2\2\2.+\3\2\2\2/\62\3\2\2\2\60.\3\2\2\2\60\61\3\2"+
|
|
"\2\2\61\3\3\2\2\2\62\60\3\2\2\2\63\64\b\3\1\2\64K\7\20\2\2\65K\7\21\2"+
|
|
"\2\66\67\5\2\2\2\678\t\5\2\289\5\2\2\29K\3\2\2\2:;\5\2\2\2;<\7\t\2\2<"+
|
|
"=\7\26\2\2=>\5\2\2\2>?\7\27\2\2?K\3\2\2\2@A\5\2\2\2AB\7\n\2\2BC\7\26\2"+
|
|
"\2CD\5\2\2\2DE\7\27\2\2EK\3\2\2\2FG\7\26\2\2GH\5\4\3\2HI\7\27\2\2IK\3"+
|
|
"\2\2\2J\63\3\2\2\2J\65\3\2\2\2J\66\3\2\2\2J:\3\2\2\2J@\3\2\2\2JF\3\2\2"+
|
|
"\2KQ\3\2\2\2LM\f\4\2\2MN\t\6\2\2NP\5\4\3\5OL\3\2\2\2PS\3\2\2\2QO\3\2\2"+
|
|
"\2QR\3\2\2\2R\5\3\2\2\2SQ\3\2\2\2\b\37&.\60JQ";
|
|
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);
|
|
}
|
|
}
|
|
} |