gr.iti.mklab.framework.utils.booleanparse.BooleanQueryParser Maven / Gradle / Ivy
package gr.iti.mklab.framework.utils.booleanparse;
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 gr.iti.mklab.framework.utils.booleanparse.BooleanQueryListener;
import gr.iti.mklab.framework.utils.booleanparse.BooleanQueryParser;
import gr.iti.mklab.framework.utils.booleanparse.BooleanQueryVisitor;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;
@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class BooleanQueryParser extends Parser {
static { RuntimeMetaData.checkVersion("4.5.3", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
LPAREN=1, RPAREN=2, OR=3, NOT=4, AND=5, WORD=6, WS=7;
public static final int
RULE_expression = 0, RULE_not = 1, RULE_and = 2, RULE_or = 3, RULE_atom = 4;
public static final String[] ruleNames = {
"expression", "not", "and", "or", "atom"
};
private static final String[] _LITERAL_NAMES = {
null, "'('", "')'", "'OR'", "'NOT'", "'AND'"
};
private static final String[] _SYMBOLIC_NAMES = {
null, "LPAREN", "RPAREN", "OR", "NOT", "AND", "WORD", "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 "BooleanQuery.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public BooleanQueryParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class ExpressionContext extends ParserRuleContext {
public NotContext not() {
return getRuleContext(NotContext.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 BooleanQueryListener ) ((BooleanQueryListener)listener).enterExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BooleanQueryListener ) ((BooleanQueryListener)listener).exitExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BooleanQueryVisitor ) return ((BooleanQueryVisitor)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 {
enterOuterAlt(_localctx, 1);
{
setState(10);
not();
}
}
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 List and() {
return getRuleContexts(AndContext.class);
}
public AndContext and(int i) {
return getRuleContext(AndContext.class,i);
}
public List NOT() { return getTokens(BooleanQueryParser.NOT); }
public TerminalNode NOT(int i) {
return getToken(BooleanQueryParser.NOT, i);
}
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 BooleanQueryListener ) ((BooleanQueryListener)listener).enterNot(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BooleanQueryListener ) ((BooleanQueryListener)listener).exitNot(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BooleanQueryVisitor ) return ((BooleanQueryVisitor)visitor).visitNot(this);
else return visitor.visitChildren(this);
}
}
public final NotContext not() throws RecognitionException {
NotContext _localctx = new NotContext(_ctx, getState());
enterRule(_localctx, 2, RULE_not);
int _la;
try {
setState(26);
switch (_input.LA(1)) {
case LPAREN:
case WORD:
enterOuterAlt(_localctx, 1);
{
setState(12);
and();
setState(17);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==NOT) {
{
{
setState(13);
match(NOT);
setState(14);
and();
}
}
setState(19);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
case NOT:
enterOuterAlt(_localctx, 2);
{
setState(22);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(20);
match(NOT);
setState(21);
and();
}
}
setState(24);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==NOT );
}
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 AndContext extends ParserRuleContext {
public List or() {
return getRuleContexts(OrContext.class);
}
public OrContext or(int i) {
return getRuleContext(OrContext.class,i);
}
public List AND() { return getTokens(BooleanQueryParser.AND); }
public TerminalNode AND(int i) {
return getToken(BooleanQueryParser.AND, i);
}
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 BooleanQueryListener ) ((BooleanQueryListener)listener).enterAnd(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BooleanQueryListener ) ((BooleanQueryListener)listener).exitAnd(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BooleanQueryVisitor ) return ((BooleanQueryVisitor)visitor).visitAnd(this);
else return visitor.visitChildren(this);
}
}
public final AndContext and() throws RecognitionException {
AndContext _localctx = new AndContext(_ctx, getState());
enterRule(_localctx, 4, RULE_and);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(28);
or();
setState(33);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AND) {
{
{
setState(29);
match(AND);
setState(30);
or();
}
}
setState(35);
_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 OrContext extends ParserRuleContext {
public List atom() {
return getRuleContexts(AtomContext.class);
}
public AtomContext atom(int i) {
return getRuleContext(AtomContext.class,i);
}
public List OR() { return getTokens(BooleanQueryParser.OR); }
public TerminalNode OR(int i) {
return getToken(BooleanQueryParser.OR, i);
}
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 BooleanQueryListener ) ((BooleanQueryListener)listener).enterOr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BooleanQueryListener ) ((BooleanQueryListener)listener).exitOr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BooleanQueryVisitor ) return ((BooleanQueryVisitor)visitor).visitOr(this);
else return visitor.visitChildren(this);
}
}
public final OrContext or() throws RecognitionException {
OrContext _localctx = new OrContext(_ctx, getState());
enterRule(_localctx, 6, RULE_or);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(36);
atom();
setState(41);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==OR) {
{
{
setState(37);
match(OR);
setState(38);
atom();
}
}
setState(43);
_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 AtomContext extends ParserRuleContext {
public List WORD() { return getTokens(BooleanQueryParser.WORD); }
public TerminalNode WORD(int i) {
return getToken(BooleanQueryParser.WORD, i);
}
public TerminalNode LPAREN() { return getToken(BooleanQueryParser.LPAREN, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RPAREN() { return getToken(BooleanQueryParser.RPAREN, 0); }
public AtomContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_atom; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof BooleanQueryListener ) ((BooleanQueryListener)listener).enterAtom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof BooleanQueryListener ) ((BooleanQueryListener)listener).exitAtom(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof BooleanQueryVisitor ) return ((BooleanQueryVisitor)visitor).visitAtom(this);
else return visitor.visitChildren(this);
}
}
public final AtomContext atom() throws RecognitionException {
AtomContext _localctx = new AtomContext(_ctx, getState());
enterRule(_localctx, 8, RULE_atom);
int _la;
try {
setState(53);
switch (_input.LA(1)) {
case WORD:
enterOuterAlt(_localctx, 1);
{
setState(45);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(44);
match(WORD);
}
}
setState(47);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==WORD );
}
break;
case LPAREN:
enterOuterAlt(_localctx, 2);
{
setState(49);
match(LPAREN);
setState(50);
expression();
setState(51);
match(RPAREN);
}
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 final String _serializedATN =
"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\t:\4\2\t\2\4\3\t"+
"\3\4\4\t\4\4\5\t\5\4\6\t\6\3\2\3\2\3\3\3\3\3\3\7\3\22\n\3\f\3\16\3\25"+
"\13\3\3\3\3\3\6\3\31\n\3\r\3\16\3\32\5\3\35\n\3\3\4\3\4\3\4\7\4\"\n\4"+
"\f\4\16\4%\13\4\3\5\3\5\3\5\7\5*\n\5\f\5\16\5-\13\5\3\6\6\6\60\n\6\r\6"+
"\16\6\61\3\6\3\6\3\6\3\6\5\68\n\6\3\6\2\2\7\2\4\6\b\n\2\2;\2\f\3\2\2\2"+
"\4\34\3\2\2\2\6\36\3\2\2\2\b&\3\2\2\2\n\67\3\2\2\2\f\r\5\4\3\2\r\3\3\2"+
"\2\2\16\23\5\6\4\2\17\20\7\6\2\2\20\22\5\6\4\2\21\17\3\2\2\2\22\25\3\2"+
"\2\2\23\21\3\2\2\2\23\24\3\2\2\2\24\35\3\2\2\2\25\23\3\2\2\2\26\27\7\6"+
"\2\2\27\31\5\6\4\2\30\26\3\2\2\2\31\32\3\2\2\2\32\30\3\2\2\2\32\33\3\2"+
"\2\2\33\35\3\2\2\2\34\16\3\2\2\2\34\30\3\2\2\2\35\5\3\2\2\2\36#\5\b\5"+
"\2\37 \7\7\2\2 \"\5\b\5\2!\37\3\2\2\2\"%\3\2\2\2#!\3\2\2\2#$\3\2\2\2$"+
"\7\3\2\2\2%#\3\2\2\2&+\5\n\6\2\'(\7\5\2\2(*\5\n\6\2)\'\3\2\2\2*-\3\2\2"+
"\2+)\3\2\2\2+,\3\2\2\2,\t\3\2\2\2-+\3\2\2\2.\60\7\b\2\2/.\3\2\2\2\60\61"+
"\3\2\2\2\61/\3\2\2\2\61\62\3\2\2\2\628\3\2\2\2\63\64\7\3\2\2\64\65\5\2"+
"\2\2\65\66\7\4\2\2\668\3\2\2\2\67/\3\2\2\2\67\63\3\2\2\28\13\3\2\2\2\t"+
"\23\32\34#+\61\67";
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