com.sap.cloud.sdk.service.csn2jpa.csn.antlr.OnConditionsParser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of csn-reader Show documentation
Show all versions of csn-reader Show documentation
API for reading CDS models in CSN format
The newest version!
// Generated from com/sap/cloud/sdk/service/csn2jpa/csn/antlr/OnConditions.g4 by ANTLR 4.7.1
package com.sap.cloud.sdk.service.csn2jpa.csn.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 OnConditionsParser extends Parser {
static { RuntimeMetaData.checkVersion("4.7.1", 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, AND=6, OR=7, GT=8, GE=9, LT=10,
LE=11, EQ=12, NE=13, LPAREN=14, RPAREN=15, LCURLYBRAC=16, RCURLYBRAC=17,
LSQUAREBRAC=18, RSQUAREBRAC=19, COLON=20, COMMA=21, NULLVALUE=22, BOOL=23,
NUMBER=24, STRING=25, WS=26;
public static final int
RULE_expression = 0, RULE_expr = 1, RULE_scalar_value = 2, RULE_reference = 3,
RULE_ref = 4, RULE_literal = 5, RULE_value = 6, RULE_function = 7, RULE_comp_operator = 8;
public static final String[] ruleNames = {
"expression", "expr", "scalar_value", "reference", "ref", "literal", "value",
"function", "comp_operator"
};
private static final String[] _LITERAL_NAMES = {
null, "'\"ref\"'", "']}'", "'\"val\"'", "'\"func\"'", "'\"args\"'", "'and'",
"'or'", "'>'", "'>='", "'<'", "'<='", "'='", "'<>'", "'('", "')'", "'{'",
"'}'", "'['", "']'", "':'", "','", "'null'"
};
private static final String[] _SYMBOLIC_NAMES = {
null, null, null, null, null, null, "AND", "OR", "GT", "GE", "LT", "LE",
"EQ", "NE", "LPAREN", "RPAREN", "LCURLYBRAC", "RCURLYBRAC", "LSQUAREBRAC",
"RSQUAREBRAC", "COLON", "COMMA", "NULLVALUE", "BOOL", "NUMBER", "STRING",
"WS"
};
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 "OnConditions.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public OnConditionsParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class ExpressionContext extends ParserRuleContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public ReferenceContext reference() {
return getRuleContext(ReferenceContext.class,0);
}
public FunctionContext function() {
return getRuleContext(FunctionContext.class,0);
}
public ExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OnConditionsListener ) ((OnConditionsListener)listener).enterExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OnConditionsListener ) ((OnConditionsListener)listener).exitExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OnConditionsVisitor ) return ((OnConditionsVisitor)visitor).visitExpression(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionContext expression() throws RecognitionException {
ExpressionContext _localctx = new ExpressionContext(_ctx, getState());
enterRule(_localctx, 0, RULE_expression);
try {
setState(21);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(18);
expr(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(19);
reference();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(20);
function();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExprContext extends ParserRuleContext {
public ExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr; }
public ExprContext() { }
public void copyFrom(ExprContext ctx) {
super.copyFrom(ctx);
}
}
public static class OrContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode OR() { return getToken(OnConditionsParser.OR, 0); }
public OrContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OnConditionsListener ) ((OnConditionsListener)listener).enterOr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OnConditionsListener ) ((OnConditionsListener)listener).exitOr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OnConditionsVisitor ) return ((OnConditionsVisitor)visitor).visitOr(this);
else return visitor.visitChildren(this);
}
}
public static class ComparisonContext extends ExprContext {
public List scalar_value() {
return getRuleContexts(Scalar_valueContext.class);
}
public Scalar_valueContext scalar_value(int i) {
return getRuleContext(Scalar_valueContext.class,i);
}
public Comp_operatorContext comp_operator() {
return getRuleContext(Comp_operatorContext.class,0);
}
public ComparisonContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OnConditionsListener ) ((OnConditionsListener)listener).enterComparison(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OnConditionsListener ) ((OnConditionsListener)listener).exitComparison(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OnConditionsVisitor ) return ((OnConditionsVisitor)visitor).visitComparison(this);
else return visitor.visitChildren(this);
}
}
public static class AndContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode AND() { return getToken(OnConditionsParser.AND, 0); }
public AndContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OnConditionsListener ) ((OnConditionsListener)listener).enterAnd(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OnConditionsListener ) ((OnConditionsListener)listener).exitAnd(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OnConditionsVisitor ) return ((OnConditionsVisitor)visitor).visitAnd(this);
else return visitor.visitChildren(this);
}
}
public static class BoolExpressionInParenContext extends ExprContext {
public TerminalNode LPAREN() { return getToken(OnConditionsParser.LPAREN, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode RPAREN() { return getToken(OnConditionsParser.RPAREN, 0); }
public BoolExpressionInParenContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OnConditionsListener ) ((OnConditionsListener)listener).enterBoolExpressionInParen(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OnConditionsListener ) ((OnConditionsListener)listener).exitBoolExpressionInParen(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OnConditionsVisitor ) return ((OnConditionsVisitor)visitor).visitBoolExpressionInParen(this);
else return visitor.visitChildren(this);
}
}
public final ExprContext expr() throws RecognitionException {
return expr(0);
}
private ExprContext expr(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ExprContext _localctx = new ExprContext(_ctx, _parentState);
ExprContext _prevctx = _localctx;
int _startState = 2;
enterRecursionRule(_localctx, 2, RULE_expr, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(32);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LCURLYBRAC:
{
_localctx = new ComparisonContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(24);
scalar_value();
setState(25);
comp_operator();
setState(26);
scalar_value();
}
break;
case LPAREN:
{
_localctx = new BoolExpressionInParenContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(28);
match(LPAREN);
setState(29);
expr(0);
setState(30);
match(RPAREN);
}
break;
default:
throw new NoViableAltException(this);
}
_ctx.stop = _input.LT(-1);
setState(42);
_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(40);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
case 1:
{
_localctx = new AndContext(new ExprContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(34);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(35);
match(AND);
setState(36);
expr(5);
}
break;
case 2:
{
_localctx = new OrContext(new ExprContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(37);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(38);
match(OR);
setState(39);
expr(4);
}
break;
}
}
}
setState(44);
_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 Scalar_valueContext extends ParserRuleContext {
public ReferenceContext reference() {
return getRuleContext(ReferenceContext.class,0);
}
public LiteralContext literal() {
return getRuleContext(LiteralContext.class,0);
}
public FunctionContext function() {
return getRuleContext(FunctionContext.class,0);
}
public Scalar_valueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_scalar_value; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OnConditionsListener ) ((OnConditionsListener)listener).enterScalar_value(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OnConditionsListener ) ((OnConditionsListener)listener).exitScalar_value(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OnConditionsVisitor ) return ((OnConditionsVisitor)visitor).visitScalar_value(this);
else return visitor.visitChildren(this);
}
}
public final Scalar_valueContext scalar_value() throws RecognitionException {
Scalar_valueContext _localctx = new Scalar_valueContext(_ctx, getState());
enterRule(_localctx, 4, RULE_scalar_value);
try {
setState(48);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(45);
reference();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(46);
literal();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(47);
function();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReferenceContext extends ParserRuleContext {
public TerminalNode LCURLYBRAC() { return getToken(OnConditionsParser.LCURLYBRAC, 0); }
public TerminalNode COLON() { return getToken(OnConditionsParser.COLON, 0); }
public TerminalNode LSQUAREBRAC() { return getToken(OnConditionsParser.LSQUAREBRAC, 0); }
public List ref() {
return getRuleContexts(RefContext.class);
}
public RefContext ref(int i) {
return getRuleContext(RefContext.class,i);
}
public List COMMA() { return getTokens(OnConditionsParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(OnConditionsParser.COMMA, i);
}
public TerminalNode RSQUAREBRAC() { return getToken(OnConditionsParser.RSQUAREBRAC, 0); }
public TerminalNode RCURLYBRAC() { return getToken(OnConditionsParser.RCURLYBRAC, 0); }
public ReferenceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_reference; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OnConditionsListener ) ((OnConditionsListener)listener).enterReference(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OnConditionsListener ) ((OnConditionsListener)listener).exitReference(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OnConditionsVisitor ) return ((OnConditionsVisitor)visitor).visitReference(this);
else return visitor.visitChildren(this);
}
}
public final ReferenceContext reference() throws RecognitionException {
ReferenceContext _localctx = new ReferenceContext(_ctx, getState());
enterRule(_localctx, 6, RULE_reference);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(50);
match(LCURLYBRAC);
setState(51);
match(T__0);
setState(52);
match(COLON);
setState(53);
match(LSQUAREBRAC);
setState(54);
ref();
setState(59);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(55);
match(COMMA);
setState(56);
ref();
}
}
}
setState(61);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
}
setState(66);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
case 1:
{
{
setState(62);
match(RSQUAREBRAC);
setState(63);
match(RCURLYBRAC);
}
}
break;
case 2:
{
}
break;
case 3:
{
{
setState(65);
match(T__1);
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RefContext extends ParserRuleContext {
public TerminalNode STRING() { return getToken(OnConditionsParser.STRING, 0); }
public RefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ref; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OnConditionsListener ) ((OnConditionsListener)listener).enterRef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OnConditionsListener ) ((OnConditionsListener)listener).exitRef(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OnConditionsVisitor ) return ((OnConditionsVisitor)visitor).visitRef(this);
else return visitor.visitChildren(this);
}
}
public final RefContext ref() throws RecognitionException {
RefContext _localctx = new RefContext(_ctx, getState());
enterRule(_localctx, 8, RULE_ref);
try {
enterOuterAlt(_localctx, 1);
{
setState(68);
match(STRING);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LiteralContext extends ParserRuleContext {
public TerminalNode LCURLYBRAC() { return getToken(OnConditionsParser.LCURLYBRAC, 0); }
public TerminalNode COLON() { return getToken(OnConditionsParser.COLON, 0); }
public ValueContext value() {
return getRuleContext(ValueContext.class,0);
}
public TerminalNode RCURLYBRAC() { return getToken(OnConditionsParser.RCURLYBRAC, 0); }
public LiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_literal; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OnConditionsListener ) ((OnConditionsListener)listener).enterLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OnConditionsListener ) ((OnConditionsListener)listener).exitLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OnConditionsVisitor ) return ((OnConditionsVisitor)visitor).visitLiteral(this);
else return visitor.visitChildren(this);
}
}
public final LiteralContext literal() throws RecognitionException {
LiteralContext _localctx = new LiteralContext(_ctx, getState());
enterRule(_localctx, 10, RULE_literal);
try {
enterOuterAlt(_localctx, 1);
{
setState(70);
match(LCURLYBRAC);
setState(71);
match(T__2);
setState(72);
match(COLON);
setState(73);
value();
setState(74);
match(RCURLYBRAC);
}
}
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 ValueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_value; }
public ValueContext() { }
public void copyFrom(ValueContext ctx) {
super.copyFrom(ctx);
}
}
public static class NullValueContext extends ValueContext {
public TerminalNode NULLVALUE() { return getToken(OnConditionsParser.NULLVALUE, 0); }
public NullValueContext(ValueContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OnConditionsListener ) ((OnConditionsListener)listener).enterNullValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OnConditionsListener ) ((OnConditionsListener)listener).exitNullValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OnConditionsVisitor ) return ((OnConditionsVisitor)visitor).visitNullValue(this);
else return visitor.visitChildren(this);
}
}
public static class NumberValueContext extends ValueContext {
public TerminalNode NUMBER() { return getToken(OnConditionsParser.NUMBER, 0); }
public NumberValueContext(ValueContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OnConditionsListener ) ((OnConditionsListener)listener).enterNumberValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OnConditionsListener ) ((OnConditionsListener)listener).exitNumberValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OnConditionsVisitor ) return ((OnConditionsVisitor)visitor).visitNumberValue(this);
else return visitor.visitChildren(this);
}
}
public static class BooleanValueContext extends ValueContext {
public TerminalNode BOOL() { return getToken(OnConditionsParser.BOOL, 0); }
public BooleanValueContext(ValueContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OnConditionsListener ) ((OnConditionsListener)listener).enterBooleanValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OnConditionsListener ) ((OnConditionsListener)listener).exitBooleanValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OnConditionsVisitor ) return ((OnConditionsVisitor)visitor).visitBooleanValue(this);
else return visitor.visitChildren(this);
}
}
public static class QuotedValueContext extends ValueContext {
public TerminalNode STRING() { return getToken(OnConditionsParser.STRING, 0); }
public QuotedValueContext(ValueContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OnConditionsListener ) ((OnConditionsListener)listener).enterQuotedValue(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OnConditionsListener ) ((OnConditionsListener)listener).exitQuotedValue(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OnConditionsVisitor ) return ((OnConditionsVisitor)visitor).visitQuotedValue(this);
else return visitor.visitChildren(this);
}
}
public final ValueContext value() throws RecognitionException {
ValueContext _localctx = new ValueContext(_ctx, getState());
enterRule(_localctx, 12, RULE_value);
try {
setState(80);
_errHandler.sync(this);
switch (_input.LA(1)) {
case BOOL:
_localctx = new BooleanValueContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(76);
match(BOOL);
}
break;
case NUMBER:
_localctx = new NumberValueContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(77);
match(NUMBER);
}
break;
case NULLVALUE:
_localctx = new NullValueContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(78);
match(NULLVALUE);
}
break;
case STRING:
_localctx = new QuotedValueContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(79);
match(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 FunctionContext extends ParserRuleContext {
public TerminalNode LCURLYBRAC() { return getToken(OnConditionsParser.LCURLYBRAC, 0); }
public List COLON() { return getTokens(OnConditionsParser.COLON); }
public TerminalNode COLON(int i) {
return getToken(OnConditionsParser.COLON, i);
}
public TerminalNode STRING() { return getToken(OnConditionsParser.STRING, 0); }
public List COMMA() { return getTokens(OnConditionsParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(OnConditionsParser.COMMA, i);
}
public TerminalNode LSQUAREBRAC() { return getToken(OnConditionsParser.LSQUAREBRAC, 0); }
public List scalar_value() {
return getRuleContexts(Scalar_valueContext.class);
}
public Scalar_valueContext scalar_value(int i) {
return getRuleContext(Scalar_valueContext.class,i);
}
public TerminalNode RSQUAREBRAC() { return getToken(OnConditionsParser.RSQUAREBRAC, 0); }
public TerminalNode RCURLYBRAC() { return getToken(OnConditionsParser.RCURLYBRAC, 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 OnConditionsListener ) ((OnConditionsListener)listener).enterFunction(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OnConditionsListener ) ((OnConditionsListener)listener).exitFunction(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OnConditionsVisitor ) return ((OnConditionsVisitor)visitor).visitFunction(this);
else return visitor.visitChildren(this);
}
}
public final FunctionContext function() throws RecognitionException {
FunctionContext _localctx = new FunctionContext(_ctx, getState());
enterRule(_localctx, 14, RULE_function);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(82);
match(LCURLYBRAC);
setState(83);
match(T__3);
setState(84);
match(COLON);
setState(85);
match(STRING);
setState(86);
match(COMMA);
setState(87);
match(T__4);
setState(88);
match(COLON);
setState(89);
match(LSQUAREBRAC);
setState(91);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {
case 1:
{
setState(90);
scalar_value();
}
break;
}
setState(97);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,9,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(93);
match(COMMA);
setState(94);
scalar_value();
}
}
}
setState(99);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,9,_ctx);
}
setState(104);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
case 1:
{
{
setState(100);
match(RSQUAREBRAC);
setState(101);
match(RCURLYBRAC);
}
}
break;
case 2:
{
}
break;
case 3:
{
{
setState(103);
match(T__1);
}
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Comp_operatorContext extends ParserRuleContext {
public TerminalNode GT() { return getToken(OnConditionsParser.GT, 0); }
public TerminalNode GE() { return getToken(OnConditionsParser.GE, 0); }
public TerminalNode LT() { return getToken(OnConditionsParser.LT, 0); }
public TerminalNode LE() { return getToken(OnConditionsParser.LE, 0); }
public TerminalNode EQ() { return getToken(OnConditionsParser.EQ, 0); }
public TerminalNode NE() { return getToken(OnConditionsParser.NE, 0); }
public Comp_operatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_comp_operator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OnConditionsListener ) ((OnConditionsListener)listener).enterComp_operator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OnConditionsListener ) ((OnConditionsListener)listener).exitComp_operator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OnConditionsVisitor ) return ((OnConditionsVisitor)visitor).visitComp_operator(this);
else return visitor.visitChildren(this);
}
}
public final Comp_operatorContext comp_operator() throws RecognitionException {
Comp_operatorContext _localctx = new Comp_operatorContext(_ctx, getState());
enterRule(_localctx, 16, RULE_comp_operator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(106);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << GT) | (1L << GE) | (1L << LT) | (1L << LE) | (1L << EQ) | (1L << NE))) != 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 boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
switch (ruleIndex) {
case 1:
return expr_sempred((ExprContext)_localctx, predIndex);
}
return true;
}
private boolean expr_sempred(ExprContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return precpred(_ctx, 4);
case 1:
return precpred(_ctx, 3);
}
return true;
}
public static final String _serializedATN =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\34o\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\3\2\3\2\3\2"+
"\5\2\30\n\2\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\5\3#\n\3\3\3\3\3\3\3\3"+
"\3\3\3\3\3\7\3+\n\3\f\3\16\3.\13\3\3\4\3\4\3\4\5\4\63\n\4\3\5\3\5\3\5"+
"\3\5\3\5\3\5\3\5\7\5<\n\5\f\5\16\5?\13\5\3\5\3\5\3\5\3\5\5\5E\n\5\3\6"+
"\3\6\3\7\3\7\3\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b\5\bS\n\b\3\t\3\t\3\t\3\t"+
"\3\t\3\t\3\t\3\t\3\t\5\t^\n\t\3\t\3\t\7\tb\n\t\f\t\16\te\13\t\3\t\3\t"+
"\3\t\3\t\5\tk\n\t\3\n\3\n\3\n\2\3\4\13\2\4\6\b\n\f\16\20\22\2\3\3\2\n"+
"\17\2v\2\27\3\2\2\2\4\"\3\2\2\2\6\62\3\2\2\2\b\64\3\2\2\2\nF\3\2\2\2\f"+
"H\3\2\2\2\16R\3\2\2\2\20T\3\2\2\2\22l\3\2\2\2\24\30\5\4\3\2\25\30\5\b"+
"\5\2\26\30\5\20\t\2\27\24\3\2\2\2\27\25\3\2\2\2\27\26\3\2\2\2\30\3\3\2"+
"\2\2\31\32\b\3\1\2\32\33\5\6\4\2\33\34\5\22\n\2\34\35\5\6\4\2\35#\3\2"+
"\2\2\36\37\7\20\2\2\37 \5\4\3\2 !\7\21\2\2!#\3\2\2\2\"\31\3\2\2\2\"\36"+
"\3\2\2\2#,\3\2\2\2$%\f\6\2\2%&\7\b\2\2&+\5\4\3\7\'(\f\5\2\2()\7\t\2\2"+
")+\5\4\3\6*$\3\2\2\2*\'\3\2\2\2+.\3\2\2\2,*\3\2\2\2,-\3\2\2\2-\5\3\2\2"+
"\2.,\3\2\2\2/\63\5\b\5\2\60\63\5\f\7\2\61\63\5\20\t\2\62/\3\2\2\2\62\60"+
"\3\2\2\2\62\61\3\2\2\2\63\7\3\2\2\2\64\65\7\22\2\2\65\66\7\3\2\2\66\67"+
"\7\26\2\2\678\7\24\2\28=\5\n\6\29:\7\27\2\2:<\5\n\6\2;9\3\2\2\2\3\2\2\2>D\3\2\2\2?=\3\2\2\2@A\7\25\2\2AE\7\23\2\2BE\3"+
"\2\2\2CE\7\4\2\2D@\3\2\2\2DB\3\2\2\2DC\3\2\2\2E\t\3\2\2\2FG\7\33\2\2G"+
"\13\3\2\2\2HI\7\22\2\2IJ\7\5\2\2JK\7\26\2\2KL\5\16\b\2LM\7\23\2\2M\r\3"+
"\2\2\2NS\7\31\2\2OS\7\32\2\2PS\7\30\2\2QS\7\33\2\2RN\3\2\2\2RO\3\2\2\2"+
"RP\3\2\2\2RQ\3\2\2\2S\17\3\2\2\2TU\7\22\2\2UV\7\6\2\2VW\7\26\2\2WX\7\33"+
"\2\2XY\7\27\2\2YZ\7\7\2\2Z[\7\26\2\2[]\7\24\2\2\\^\5\6\4\2]\\\3\2\2\2"+
"]^\3\2\2\2^c\3\2\2\2_`\7\27\2\2`b\5\6\4\2a_\3\2\2\2be\3\2\2\2ca\3\2\2"+
"\2cd\3\2\2\2dj\3\2\2\2ec\3\2\2\2fg\7\25\2\2gk\7\23\2\2hk\3\2\2\2ik\7\4"+
"\2\2jf\3\2\2\2jh\3\2\2\2ji\3\2\2\2k\21\3\2\2\2lm\t\2\2\2m\23\3\2\2\2\r"+
"\27\"*,\62=DR]cj";
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