Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
step.core.ql.OQLParser Maven / Gradle / Ivy
/*******************************************************************************
* Copyright (C) 2020, exense GmbH
*
* This file is part of STEP
*
* STEP is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* STEP is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with STEP. If not, see ";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "OQL.g4"; }
@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 ParseContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(OQLParser.EOF, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public ParseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parse; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OQLListener ) ((OQLListener)listener).enterParse(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OQLListener ) ((OQLListener)listener).exitParse(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OQLVisitor ) return ((OQLVisitor)visitor).visitParse(this);
else return visitor.visitChildren(this);
}
}
public final ParseContext parse() throws RecognitionException {
ParseContext _localctx = new ParseContext(_ctx, getState());
enterRule(_localctx, 0, RULE_parse);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(7);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NOT) | (1L << OPAR) | (1L << NONQUOTEDSTRING) | (1L << STRING))) != 0)) {
{
setState(6);
expr(0);
}
}
setState(9);
match(EOF);
}
}
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 NotExprContext extends ExprContext {
public TerminalNode NOT() { return getToken(OQLParser.NOT, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public NotExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OQLListener ) ((OQLListener)listener).enterNotExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OQLListener ) ((OQLListener)listener).exitNotExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OQLVisitor ) return ((OQLVisitor)visitor).visitNotExpr(this);
else return visitor.visitChildren(this);
}
}
public static class AtomExprContext extends ExprContext {
public AtomContext atom() {
return getRuleContext(AtomContext.class,0);
}
public AtomExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OQLListener ) ((OQLListener)listener).enterAtomExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OQLListener ) ((OQLListener)listener).exitAtomExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OQLVisitor ) return ((OQLVisitor)visitor).visitAtomExpr(this);
else return visitor.visitChildren(this);
}
}
public static class OrExprContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode OR() { return getToken(OQLParser.OR, 0); }
public OrExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OQLListener ) ((OQLListener)listener).enterOrExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OQLListener ) ((OQLListener)listener).exitOrExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OQLVisitor ) return ((OQLVisitor)visitor).visitOrExpr(this);
else return visitor.visitChildren(this);
}
}
public static class EqualityExprContext extends ExprContext {
public Token op;
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode EQ() { return getToken(OQLParser.EQ, 0); }
public TerminalNode NEQ() { return getToken(OQLParser.NEQ, 0); }
public TerminalNode REGEX() { return getToken(OQLParser.REGEX, 0); }
public EqualityExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OQLListener ) ((OQLListener)listener).enterEqualityExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OQLListener ) ((OQLListener)listener).exitEqualityExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OQLVisitor ) return ((OQLVisitor)visitor).visitEqualityExpr(this);
else return visitor.visitChildren(this);
}
}
public static class AndExprContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode AND() { return getToken(OQLParser.AND, 0); }
public AndExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OQLListener ) ((OQLListener)listener).enterAndExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OQLListener ) ((OQLListener)listener).exitAndExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OQLVisitor ) return ((OQLVisitor)visitor).visitAndExpr(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);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(15);
switch (_input.LA(1)) {
case NOT:
{
_localctx = new NotExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(12);
match(NOT);
setState(13);
expr(5);
}
break;
case OPAR:
case NONQUOTEDSTRING:
case STRING:
{
_localctx = new AtomExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(14);
atom();
}
break;
default:
throw new NoViableAltException(this);
}
_ctx.stop = _input.LT(-1);
setState(28);
_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(26);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
case 1:
{
_localctx = new EqualityExprContext(new ExprContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(17);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(18);
((EqualityExprContext)_localctx).op = _input.LT(1);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << EQ) | (1L << NEQ) | (1L << REGEX))) != 0)) ) {
((EqualityExprContext)_localctx).op = (Token)_errHandler.recoverInline(this);
} else {
consume();
}
setState(19);
expr(5);
}
break;
case 2:
{
_localctx = new AndExprContext(new ExprContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(20);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(21);
match(AND);
setState(22);
expr(4);
}
break;
case 3:
{
_localctx = new OrExprContext(new ExprContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(23);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(24);
match(OR);
setState(25);
expr(3);
}
break;
}
}
}
setState(30);
_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 AtomContext extends ParserRuleContext {
public AtomContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_atom; }
public AtomContext() { }
public void copyFrom(AtomContext ctx) {
super.copyFrom(ctx);
}
}
public static class ParExprContext extends AtomContext {
public TerminalNode OPAR() { return getToken(OQLParser.OPAR, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode CPAR() { return getToken(OQLParser.CPAR, 0); }
public ParExprContext(AtomContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OQLListener ) ((OQLListener)listener).enterParExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OQLListener ) ((OQLListener)listener).exitParExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OQLVisitor ) return ((OQLVisitor)visitor).visitParExpr(this);
else return visitor.visitChildren(this);
}
}
public static class StringAtomContext extends AtomContext {
public TerminalNode STRING() { return getToken(OQLParser.STRING, 0); }
public StringAtomContext(AtomContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OQLListener ) ((OQLListener)listener).enterStringAtom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OQLListener ) ((OQLListener)listener).exitStringAtom(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OQLVisitor ) return ((OQLVisitor)visitor).visitStringAtom(this);
else return visitor.visitChildren(this);
}
}
public static class NonQuotedStringAtomContext extends AtomContext {
public TerminalNode NONQUOTEDSTRING() { return getToken(OQLParser.NONQUOTEDSTRING, 0); }
public NonQuotedStringAtomContext(AtomContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof OQLListener ) ((OQLListener)listener).enterNonQuotedStringAtom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof OQLListener ) ((OQLListener)listener).exitNonQuotedStringAtom(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof OQLVisitor ) return ((OQLVisitor)visitor).visitNonQuotedStringAtom(this);
else return visitor.visitChildren(this);
}
}
public final AtomContext atom() throws RecognitionException {
AtomContext _localctx = new AtomContext(_ctx, getState());
enterRule(_localctx, 4, RULE_atom);
try {
setState(37);
switch (_input.LA(1)) {
case OPAR:
_localctx = new ParExprContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(31);
match(OPAR);
setState(32);
expr(0);
setState(33);
match(CPAR);
}
break;
case NONQUOTEDSTRING:
_localctx = new NonQuotedStringAtomContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(35);
match(NONQUOTEDSTRING);
}
break;
case STRING:
_localctx = new StringAtomContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(36);
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 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);
case 2:
return precpred(_ctx, 2);
}
return true;
}
public static final String _serializedATN =
"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\r*\4\2\t\2\4\3\t"+
"\3\4\4\t\4\3\2\5\2\n\n\2\3\2\3\2\3\3\3\3\3\3\3\3\5\3\22\n\3\3\3\3\3\3"+
"\3\3\3\3\3\3\3\3\3\3\3\3\3\7\3\35\n\3\f\3\16\3 \13\3\3\4\3\4\3\4\3\4\3"+
"\4\3\4\5\4(\n\4\3\4\2\3\4\5\2\4\6\2\3\3\2\3\5-\2\t\3\2\2\2\4\21\3\2\2"+
"\2\6\'\3\2\2\2\b\n\5\4\3\2\t\b\3\2\2\2\t\n\3\2\2\2\n\13\3\2\2\2\13\f\7"+
"\2\2\3\f\3\3\2\2\2\r\16\b\3\1\2\16\17\7\b\2\2\17\22\5\4\3\7\20\22\5\6"+
"\4\2\21\r\3\2\2\2\21\20\3\2\2\2\22\36\3\2\2\2\23\24\f\6\2\2\24\25\t\2"+
"\2\2\25\35\5\4\3\7\26\27\f\5\2\2\27\30\7\7\2\2\30\35\5\4\3\6\31\32\f\4"+
"\2\2\32\33\7\6\2\2\33\35\5\4\3\5\34\23\3\2\2\2\34\26\3\2\2\2\34\31\3\2"+
"\2\2\35 \3\2\2\2\36\34\3\2\2\2\36\37\3\2\2\2\37\5\3\2\2\2 \36\3\2\2\2"+
"!\"\7\t\2\2\"#\5\4\3\2#$\7\n\2\2$(\3\2\2\2%(\7\13\2\2&(\7\f\2\2\'!\3\2"+
"\2\2\'%\3\2\2\2\'&\3\2\2\2(\7\3\2\2\2\7\t\21\34\36\'";
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);
}
}
}
