com.sri.ai.grinder.parser.antlr.AntlrGrinderParser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of aic-expresso Show documentation
Show all versions of aic-expresso Show documentation
SRI International's AIC Symbolic Manipulation and Evaluation Library (for Java 1.8+)
The newest version!
// Generated from com\sri\ai\grinder\parser\antlr\AntlrGrinder.g4 by ANTLR 4.5.1
package com.sri.ai.grinder.parser.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 AntlrGrinderParser extends Parser {
static { RuntimeMetaData.checkVersion("4.5.1", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
NOT=1, AND=2, OR=3, FOR=4, ALL=5, THERE=6, EXISTS=7, LAMBDA=8, IF=9, THEN=10,
ELSE=11, INTERSECTION=12, UNION=13, ON=14, IN=15, TUPLE_TYPE=16, FUNCTION_TYPE=17,
IMPLICATION=18, BICONDITIONAL=19, EXPONENTIATION=20, DIVIDE=21, TIMES=22,
INTEGER_INTERVAL=23, PLUS=24, SUBTRACT=25, LESS_THAN=26, LESS_THAN_EQUAL=27,
EQUAL=28, NOT_EQUAL=29, GREATER_THAN_EQUAL=30, GREATER_THAN=31, OPEN_PAREN=32,
CLOSE_PAREN=33, OPEN_SQUARE=34, CLOSE_SQUARE=35, OPEN_CURLY=36, CLOSE_CURLY=37,
OPEN_DOUBLE_CURLY=38, CLOSE_DOUBLE_CURLY=39, SEMICOLON=40, COLON=41, VERT_BAR=42,
COMMA=43, UNDERSCORE=44, PERIOD=45, INTEGER=46, RATIONAL=47, CONSTANT_STR=48,
QUOTED_CONSTANT_STR=49, COMMENT=50, LINE_COMMENT=51, WS=52;
public static final int
RULE_expression = 0, RULE_expr = 1, RULE_expr_symbol = 2, RULE_expr_non_numeric_symbol = 3,
RULE_expr_constant_name = 4, RULE_expr_constant_number = 5;
public static final String[] ruleNames = {
"expression", "expr", "expr_symbol", "expr_non_numeric_symbol", "expr_constant_name",
"expr_constant_number"
};
private static final String[] _LITERAL_NAMES = {
null, "'not'", "'and'", "'or'", "'for'", "'all'", "'there'", "'exists'",
"'lambda'", "'if'", "'then'", "'else'", "'intersection'", "'union'", "'on'",
"'in'", "'x'", "'->'", "'=>'", "'<=>'", "'^'", "'/'", "'*'", "'..'", "'+'",
"'-'", "'<'", "'<='", "'='", "'!='", "'>='", "'>'", "'('", "')'", "'['",
"']'", "'{'", "'}'", "'{{'", "'}}'", "';'", "':'", "'|'", "','", "'_'",
"'.'"
};
private static final String[] _SYMBOLIC_NAMES = {
null, "NOT", "AND", "OR", "FOR", "ALL", "THERE", "EXISTS", "LAMBDA", "IF",
"THEN", "ELSE", "INTERSECTION", "UNION", "ON", "IN", "TUPLE_TYPE", "FUNCTION_TYPE",
"IMPLICATION", "BICONDITIONAL", "EXPONENTIATION", "DIVIDE", "TIMES", "INTEGER_INTERVAL",
"PLUS", "SUBTRACT", "LESS_THAN", "LESS_THAN_EQUAL", "EQUAL", "NOT_EQUAL",
"GREATER_THAN_EQUAL", "GREATER_THAN", "OPEN_PAREN", "CLOSE_PAREN", "OPEN_SQUARE",
"CLOSE_SQUARE", "OPEN_CURLY", "CLOSE_CURLY", "OPEN_DOUBLE_CURLY", "CLOSE_DOUBLE_CURLY",
"SEMICOLON", "COLON", "VERT_BAR", "COMMA", "UNDERSCORE", "PERIOD", "INTEGER",
"RATIONAL", "CONSTANT_STR", "QUOTED_CONSTANT_STR", "COMMENT", "LINE_COMMENT",
"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 "AntlrGrinder.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public AntlrGrinderParser(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 ExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expression; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)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(12);
expr(0);
}
}
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 ParenthesesAroundExpressionContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public ParenthesesAroundExpressionContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitParenthesesAroundExpression(this);
else return visitor.visitChildren(this);
}
}
public static class SymbolContext extends ExprContext {
public Expr_symbolContext expr_symbol() {
return getRuleContext(Expr_symbolContext.class,0);
}
public SymbolContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitSymbol(this);
else return visitor.visitChildren(this);
}
}
public static class ExtensionalMultisetContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public ExtensionalMultisetContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitExtensionalMultiset(this);
else return visitor.visitChildren(this);
}
}
public static class MultiplicationOrDivisionOrIntegerIntervalContext extends ExprContext {
public ExprContext leftop;
public Token op;
public ExprContext rightop;
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public MultiplicationOrDivisionOrIntegerIntervalContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitMultiplicationOrDivisionOrIntegerInterval(this);
else return visitor.visitChildren(this);
}
}
public static class ForAllContext extends ExprContext {
public ExprContext index;
public ExprContext body;
public TerminalNode FOR() { return getToken(AntlrGrinderParser.FOR, 0); }
public TerminalNode ALL() { return getToken(AntlrGrinderParser.ALL, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public ForAllContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitForAll(this);
else return visitor.visitChildren(this);
}
}
public static class LamdaContext extends ExprContext {
public ExprContext expr;
public List parameters = new ArrayList();
public ExprContext body;
public TerminalNode LAMBDA() { return getToken(AntlrGrinderParser.LAMBDA, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public LamdaContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitLamda(this);
else return visitor.visitChildren(this);
}
}
public static class ExtensionalUnisetContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public ExtensionalUnisetContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitExtensionalUniset(this);
else return visitor.visitChildren(this);
}
}
public static class TupleTypeContext extends ExprContext {
public ExprContext firstarg;
public ExprContext expr;
public List additionalargs = new ArrayList();
public List TUPLE_TYPE() { return getTokens(AntlrGrinderParser.TUPLE_TYPE); }
public TerminalNode TUPLE_TYPE(int i) {
return getToken(AntlrGrinderParser.TUPLE_TYPE, i);
}
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TupleTypeContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitTupleType(this);
else return visitor.visitChildren(this);
}
}
public static class AdditionOrSubtractionContext extends ExprContext {
public ExprContext leftop;
public Token op;
public ExprContext rightop;
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public AdditionOrSubtractionContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitAdditionOrSubtraction(this);
else return visitor.visitChildren(this);
}
}
public static class ExponentiationContext extends ExprContext {
public ExprContext base;
public ExprContext exponent;
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public ExponentiationContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitExponentiation(this);
else return visitor.visitChildren(this);
}
}
public static class TupleContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TupleContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitTuple(this);
else return visitor.visitChildren(this);
}
}
public static class NotContext extends ExprContext {
public TerminalNode NOT() { return getToken(AntlrGrinderParser.NOT, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public NotContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitNot(this);
else return visitor.visitChildren(this);
}
}
public static class NegativeContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public NegativeContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitNegative(this);
else return visitor.visitChildren(this);
}
}
public static class FunctionApplicationContext extends ExprContext {
public ExprContext functor;
public ExprContext expr;
public List args = new ArrayList();
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public FunctionApplicationContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitFunctionApplication(this);
else return visitor.visitChildren(this);
}
}
public static class AndContext extends ExprContext {
public ExprContext leftconj;
public ExprContext rightconj;
public TerminalNode AND() { return getToken(AntlrGrinderParser.AND, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public AndContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitAnd(this);
else return visitor.visitChildren(this);
}
}
public static class ImplicationContext extends ExprContext {
public ExprContext antecedent;
public ExprContext consequent;
public TerminalNode IMPLICATION() { return getToken(AntlrGrinderParser.IMPLICATION, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public ImplicationContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitImplication(this);
else return visitor.visitChildren(this);
}
}
public static class IntersectionContext extends ExprContext {
public ExprContext leftop;
public ExprContext rightop;
public TerminalNode INTERSECTION() { return getToken(AntlrGrinderParser.INTERSECTION, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public IntersectionContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitIntersection(this);
else return visitor.visitChildren(this);
}
}
public static class BiconditionalContext extends ExprContext {
public ExprContext leftop;
public ExprContext rightop;
public TerminalNode BICONDITIONAL() { return getToken(AntlrGrinderParser.BICONDITIONAL, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public BiconditionalContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitBiconditional(this);
else return visitor.visitChildren(this);
}
}
public static class FunctionTypeContext extends ExprContext {
public List domaintypes = new ArrayList();
public ExprContext expr;
public ExprContext rangetype;
public TerminalNode FUNCTION_TYPE() { return getToken(AntlrGrinderParser.FUNCTION_TYPE, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public List TUPLE_TYPE() { return getTokens(AntlrGrinderParser.TUPLE_TYPE); }
public TerminalNode TUPLE_TYPE(int i) {
return getToken(AntlrGrinderParser.TUPLE_TYPE, i);
}
public FunctionTypeContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitFunctionType(this);
else return visitor.visitChildren(this);
}
}
public static class RealIntervalContext extends ExprContext {
public Token leftBracket;
public ExprContext lower;
public ExprContext upper;
public Token rightBracket;
public TerminalNode SEMICOLON() { return getToken(AntlrGrinderParser.SEMICOLON, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public RealIntervalContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitRealInterval(this);
else return visitor.visitChildren(this);
}
}
public static class IntensionalUnisetContext extends ExprContext {
public Token scope;
public ExprContext expr;
public List scopeargs = new ArrayList();
public ExprContext head;
public ExprContext condition;
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode ON() { return getToken(AntlrGrinderParser.ON, 0); }
public IntensionalUnisetContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitIntensionalUniset(this);
else return visitor.visitChildren(this);
}
}
public static class ComparisonContext extends ExprContext {
public ExprContext leftop;
public Token op;
public ExprContext rightop;
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public ComparisonContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitComparison(this);
else return visitor.visitChildren(this);
}
}
public static class OrContext extends ExprContext {
public ExprContext leftdisj;
public ExprContext rightdisj;
public TerminalNode OR() { return getToken(AntlrGrinderParser.OR, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public OrContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitOr(this);
else return visitor.visitChildren(this);
}
}
public static class IfThenElseContext extends ExprContext {
public ExprContext condition;
public ExprContext thenbranch;
public ExprContext elsebranch;
public TerminalNode IF() { return getToken(AntlrGrinderParser.IF, 0); }
public TerminalNode THEN() { return getToken(AntlrGrinderParser.THEN, 0); }
public TerminalNode ELSE() { return getToken(AntlrGrinderParser.ELSE, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public IfThenElseContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitIfThenElse(this);
else return visitor.visitChildren(this);
}
}
public static class InContext extends ExprContext {
public ExprContext leftop;
public ExprContext rightop;
public TerminalNode IN() { return getToken(AntlrGrinderParser.IN, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public InContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitIn(this);
else return visitor.visitChildren(this);
}
}
public static class ExpressionSymbolContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public ExpressionSymbolContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitExpressionSymbol(this);
else return visitor.visitChildren(this);
}
}
public static class CountingFormulaContext extends ExprContext {
public ExprContext expr;
public List indexes = new ArrayList();
public ExprContext body;
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public CountingFormulaContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitCountingFormula(this);
else return visitor.visitChildren(this);
}
}
public static class UnionContext extends ExprContext {
public ExprContext leftop;
public ExprContext rightop;
public TerminalNode UNION() { return getToken(AntlrGrinderParser.UNION, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public UnionContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitUnion(this);
else return visitor.visitChildren(this);
}
}
public static class CardinalityContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public CardinalityContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitCardinality(this);
else return visitor.visitChildren(this);
}
}
public static class IntensionalMultisetContext extends ExprContext {
public Token scope;
public ExprContext expr;
public List scopeargs = new ArrayList();
public ExprContext head;
public ExprContext condition;
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode ON() { return getToken(AntlrGrinderParser.ON, 0); }
public IntensionalMultisetContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitIntensionalMultiset(this);
else return visitor.visitChildren(this);
}
}
public static class BracketedExpressionContext extends ExprContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public BracketedExpressionContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitBracketedExpression(this);
else return visitor.visitChildren(this);
}
}
public static class ThereExistsContext extends ExprContext {
public ExprContext index;
public ExprContext body;
public TerminalNode THERE() { return getToken(AntlrGrinderParser.THERE, 0); }
public TerminalNode EXISTS() { return getToken(AntlrGrinderParser.EXISTS, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public ThereExistsContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitThereExists(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(185);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
case 1:
{
_localctx = new NotContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(15);
match(NOT);
setState(16);
expr(21);
}
break;
case 2:
{
_localctx = new NegativeContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(17);
match(SUBTRACT);
setState(18);
expr(20);
}
break;
case 3:
{
_localctx = new IfThenElseContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(19);
match(IF);
setState(20);
((IfThenElseContext)_localctx).condition = expr(0);
setState(21);
match(THEN);
setState(22);
((IfThenElseContext)_localctx).thenbranch = expr(0);
setState(23);
match(ELSE);
setState(24);
((IfThenElseContext)_localctx).elsebranch = expr(5);
}
break;
case 4:
{
_localctx = new LamdaContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(26);
match(LAMBDA);
setState(35);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) {
case 1:
{
setState(27);
((LamdaContext)_localctx).expr = expr(0);
((LamdaContext)_localctx).parameters.add(((LamdaContext)_localctx).expr);
setState(32);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(28);
match(COMMA);
setState(29);
((LamdaContext)_localctx).expr = expr(0);
((LamdaContext)_localctx).parameters.add(((LamdaContext)_localctx).expr);
}
}
setState(34);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
}
setState(37);
match(COLON);
setState(38);
((LamdaContext)_localctx).body = expr(4);
}
break;
case 5:
{
_localctx = new ForAllContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(39);
match(FOR);
setState(40);
match(ALL);
setState(41);
((ForAllContext)_localctx).index = expr(0);
setState(42);
match(COLON);
setState(43);
((ForAllContext)_localctx).body = expr(3);
}
break;
case 6:
{
_localctx = new ThereExistsContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(45);
match(THERE);
setState(46);
match(EXISTS);
setState(47);
((ThereExistsContext)_localctx).index = expr(0);
setState(48);
match(COLON);
setState(49);
((ThereExistsContext)_localctx).body = expr(2);
}
break;
case 7:
{
_localctx = new ParenthesesAroundExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(51);
match(OPEN_PAREN);
setState(52);
expr(0);
setState(53);
match(CLOSE_PAREN);
}
break;
case 8:
{
_localctx = new ExpressionSymbolContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(55);
match(LESS_THAN);
setState(56);
expr(0);
setState(57);
match(GREATER_THAN);
}
break;
case 9:
{
_localctx = new TupleContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(59);
match(OPEN_PAREN);
setState(60);
expr(0);
setState(61);
match(COMMA);
setState(62);
expr(0);
setState(67);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(63);
match(COMMA);
setState(64);
expr(0);
}
}
setState(69);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(70);
match(CLOSE_PAREN);
}
break;
case 10:
{
_localctx = new CountingFormulaContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(72);
match(VERT_BAR);
setState(81);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
case 1:
{
setState(73);
((CountingFormulaContext)_localctx).expr = expr(0);
((CountingFormulaContext)_localctx).indexes.add(((CountingFormulaContext)_localctx).expr);
setState(78);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(74);
match(COMMA);
setState(75);
((CountingFormulaContext)_localctx).expr = expr(0);
((CountingFormulaContext)_localctx).indexes.add(((CountingFormulaContext)_localctx).expr);
}
}
setState(80);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
}
setState(83);
match(COLON);
setState(84);
((CountingFormulaContext)_localctx).body = expr(0);
setState(85);
match(VERT_BAR);
}
break;
case 11:
{
_localctx = new CardinalityContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(87);
match(VERT_BAR);
setState(88);
expr(0);
setState(89);
match(VERT_BAR);
}
break;
case 12:
{
_localctx = new IntensionalUnisetContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(91);
match(OPEN_CURLY);
setState(105);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
case 1:
{
setState(92);
match(OPEN_PAREN);
setState(93);
((IntensionalUnisetContext)_localctx).scope = match(ON);
setState(102);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NOT) | (1L << AND) | (1L << OR) | (1L << FOR) | (1L << ALL) | (1L << THERE) | (1L << EXISTS) | (1L << LAMBDA) | (1L << IF) | (1L << THEN) | (1L << ELSE) | (1L << INTERSECTION) | (1L << UNION) | (1L << ON) | (1L << IN) | (1L << TUPLE_TYPE) | (1L << FUNCTION_TYPE) | (1L << IMPLICATION) | (1L << BICONDITIONAL) | (1L << EXPONENTIATION) | (1L << DIVIDE) | (1L << TIMES) | (1L << PLUS) | (1L << SUBTRACT) | (1L << LESS_THAN) | (1L << LESS_THAN_EQUAL) | (1L << EQUAL) | (1L << NOT_EQUAL) | (1L << GREATER_THAN_EQUAL) | (1L << OPEN_PAREN) | (1L << OPEN_SQUARE) | (1L << CLOSE_SQUARE) | (1L << OPEN_CURLY) | (1L << OPEN_DOUBLE_CURLY) | (1L << COLON) | (1L << VERT_BAR) | (1L << UNDERSCORE) | (1L << PERIOD) | (1L << INTEGER) | (1L << RATIONAL) | (1L << CONSTANT_STR) | (1L << QUOTED_CONSTANT_STR))) != 0)) {
{
setState(94);
((IntensionalUnisetContext)_localctx).expr = expr(0);
((IntensionalUnisetContext)_localctx).scopeargs.add(((IntensionalUnisetContext)_localctx).expr);
setState(99);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(95);
match(COMMA);
setState(96);
((IntensionalUnisetContext)_localctx).expr = expr(0);
((IntensionalUnisetContext)_localctx).scopeargs.add(((IntensionalUnisetContext)_localctx).expr);
}
}
setState(101);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(104);
match(CLOSE_PAREN);
}
break;
}
setState(107);
((IntensionalUnisetContext)_localctx).head = expr(0);
setState(110);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(108);
match(COLON);
setState(109);
((IntensionalUnisetContext)_localctx).condition = expr(0);
}
}
setState(112);
match(CLOSE_CURLY);
}
break;
case 13:
{
_localctx = new IntensionalMultisetContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(114);
match(OPEN_DOUBLE_CURLY);
setState(128);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
case 1:
{
setState(115);
match(OPEN_PAREN);
setState(116);
((IntensionalMultisetContext)_localctx).scope = match(ON);
setState(125);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NOT) | (1L << AND) | (1L << OR) | (1L << FOR) | (1L << ALL) | (1L << THERE) | (1L << EXISTS) | (1L << LAMBDA) | (1L << IF) | (1L << THEN) | (1L << ELSE) | (1L << INTERSECTION) | (1L << UNION) | (1L << ON) | (1L << IN) | (1L << TUPLE_TYPE) | (1L << FUNCTION_TYPE) | (1L << IMPLICATION) | (1L << BICONDITIONAL) | (1L << EXPONENTIATION) | (1L << DIVIDE) | (1L << TIMES) | (1L << PLUS) | (1L << SUBTRACT) | (1L << LESS_THAN) | (1L << LESS_THAN_EQUAL) | (1L << EQUAL) | (1L << NOT_EQUAL) | (1L << GREATER_THAN_EQUAL) | (1L << OPEN_PAREN) | (1L << OPEN_SQUARE) | (1L << CLOSE_SQUARE) | (1L << OPEN_CURLY) | (1L << OPEN_DOUBLE_CURLY) | (1L << COLON) | (1L << VERT_BAR) | (1L << UNDERSCORE) | (1L << PERIOD) | (1L << INTEGER) | (1L << RATIONAL) | (1L << CONSTANT_STR) | (1L << QUOTED_CONSTANT_STR))) != 0)) {
{
setState(117);
((IntensionalMultisetContext)_localctx).expr = expr(0);
((IntensionalMultisetContext)_localctx).scopeargs.add(((IntensionalMultisetContext)_localctx).expr);
setState(122);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(118);
match(COMMA);
setState(119);
((IntensionalMultisetContext)_localctx).expr = expr(0);
((IntensionalMultisetContext)_localctx).scopeargs.add(((IntensionalMultisetContext)_localctx).expr);
}
}
setState(124);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(127);
match(CLOSE_PAREN);
}
break;
}
setState(130);
((IntensionalMultisetContext)_localctx).head = expr(0);
setState(133);
_la = _input.LA(1);
if (_la==COLON) {
{
setState(131);
match(COLON);
setState(132);
((IntensionalMultisetContext)_localctx).condition = expr(0);
}
}
setState(135);
match(CLOSE_DOUBLE_CURLY);
}
break;
case 14:
{
_localctx = new ExtensionalUnisetContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(137);
match(OPEN_CURLY);
setState(146);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NOT) | (1L << AND) | (1L << OR) | (1L << FOR) | (1L << ALL) | (1L << THERE) | (1L << EXISTS) | (1L << LAMBDA) | (1L << IF) | (1L << THEN) | (1L << ELSE) | (1L << INTERSECTION) | (1L << UNION) | (1L << ON) | (1L << IN) | (1L << TUPLE_TYPE) | (1L << FUNCTION_TYPE) | (1L << IMPLICATION) | (1L << BICONDITIONAL) | (1L << EXPONENTIATION) | (1L << DIVIDE) | (1L << TIMES) | (1L << PLUS) | (1L << SUBTRACT) | (1L << LESS_THAN) | (1L << LESS_THAN_EQUAL) | (1L << EQUAL) | (1L << NOT_EQUAL) | (1L << GREATER_THAN_EQUAL) | (1L << OPEN_PAREN) | (1L << OPEN_SQUARE) | (1L << CLOSE_SQUARE) | (1L << OPEN_CURLY) | (1L << OPEN_DOUBLE_CURLY) | (1L << COLON) | (1L << VERT_BAR) | (1L << UNDERSCORE) | (1L << PERIOD) | (1L << INTEGER) | (1L << RATIONAL) | (1L << CONSTANT_STR) | (1L << QUOTED_CONSTANT_STR))) != 0)) {
{
setState(138);
expr(0);
setState(143);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(139);
match(COMMA);
setState(140);
expr(0);
}
}
setState(145);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(148);
match(CLOSE_CURLY);
}
break;
case 15:
{
_localctx = new ExtensionalMultisetContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(149);
match(OPEN_DOUBLE_CURLY);
setState(158);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NOT) | (1L << AND) | (1L << OR) | (1L << FOR) | (1L << ALL) | (1L << THERE) | (1L << EXISTS) | (1L << LAMBDA) | (1L << IF) | (1L << THEN) | (1L << ELSE) | (1L << INTERSECTION) | (1L << UNION) | (1L << ON) | (1L << IN) | (1L << TUPLE_TYPE) | (1L << FUNCTION_TYPE) | (1L << IMPLICATION) | (1L << BICONDITIONAL) | (1L << EXPONENTIATION) | (1L << DIVIDE) | (1L << TIMES) | (1L << PLUS) | (1L << SUBTRACT) | (1L << LESS_THAN) | (1L << LESS_THAN_EQUAL) | (1L << EQUAL) | (1L << NOT_EQUAL) | (1L << GREATER_THAN_EQUAL) | (1L << OPEN_PAREN) | (1L << OPEN_SQUARE) | (1L << CLOSE_SQUARE) | (1L << OPEN_CURLY) | (1L << OPEN_DOUBLE_CURLY) | (1L << COLON) | (1L << VERT_BAR) | (1L << UNDERSCORE) | (1L << PERIOD) | (1L << INTEGER) | (1L << RATIONAL) | (1L << CONSTANT_STR) | (1L << QUOTED_CONSTANT_STR))) != 0)) {
{
setState(150);
expr(0);
setState(155);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(151);
match(COMMA);
setState(152);
expr(0);
}
}
setState(157);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(160);
match(CLOSE_DOUBLE_CURLY);
}
break;
case 16:
{
_localctx = new BracketedExpressionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(161);
match(OPEN_SQUARE);
setState(162);
expr(0);
setState(163);
match(CLOSE_SQUARE);
}
break;
case 17:
{
_localctx = new RealIntervalContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(165);
((RealIntervalContext)_localctx).leftBracket = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==OPEN_SQUARE || _la==CLOSE_SQUARE) ) {
((RealIntervalContext)_localctx).leftBracket = (Token)_errHandler.recoverInline(this);
} else {
consume();
}
setState(166);
((RealIntervalContext)_localctx).lower = expr(0);
setState(167);
match(SEMICOLON);
setState(168);
((RealIntervalContext)_localctx).upper = expr(0);
setState(169);
((RealIntervalContext)_localctx).rightBracket = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==OPEN_SQUARE || _la==CLOSE_SQUARE) ) {
((RealIntervalContext)_localctx).rightBracket = (Token)_errHandler.recoverInline(this);
} else {
consume();
}
}
break;
case 18:
{
_localctx = new TupleTypeContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(171);
match(OPEN_PAREN);
setState(172);
((TupleTypeContext)_localctx).firstarg = expr(0);
setState(173);
match(TUPLE_TYPE);
setState(174);
((TupleTypeContext)_localctx).expr = expr(0);
((TupleTypeContext)_localctx).additionalargs.add(((TupleTypeContext)_localctx).expr);
setState(179);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==TUPLE_TYPE) {
{
{
setState(175);
match(TUPLE_TYPE);
setState(176);
((TupleTypeContext)_localctx).expr = expr(0);
((TupleTypeContext)_localctx).additionalargs.add(((TupleTypeContext)_localctx).expr);
}
}
setState(181);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(182);
match(CLOSE_PAREN);
}
break;
case 19:
{
_localctx = new SymbolContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(184);
expr_symbol();
}
break;
}
_ctx.stop = _input.LT(-1);
setState(245);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,23,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(243);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) {
case 1:
{
_localctx = new ExponentiationContext(new ExprContext(_parentctx, _parentState));
((ExponentiationContext)_localctx).base = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(187);
if (!(precpred(_ctx, 19))) throw new FailedPredicateException(this, "precpred(_ctx, 19)");
setState(188);
match(EXPONENTIATION);
setState(189);
((ExponentiationContext)_localctx).exponent = expr(19);
}
break;
case 2:
{
_localctx = new MultiplicationOrDivisionOrIntegerIntervalContext(new ExprContext(_parentctx, _parentState));
((MultiplicationOrDivisionOrIntegerIntervalContext)_localctx).leftop = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(190);
if (!(precpred(_ctx, 18))) throw new FailedPredicateException(this, "precpred(_ctx, 18)");
setState(191);
((MultiplicationOrDivisionOrIntegerIntervalContext)_localctx).op = _input.LT(1);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << DIVIDE) | (1L << TIMES) | (1L << INTEGER_INTERVAL))) != 0)) ) {
((MultiplicationOrDivisionOrIntegerIntervalContext)_localctx).op = (Token)_errHandler.recoverInline(this);
} else {
consume();
}
setState(192);
((MultiplicationOrDivisionOrIntegerIntervalContext)_localctx).rightop = expr(19);
}
break;
case 3:
{
_localctx = new AdditionOrSubtractionContext(new ExprContext(_parentctx, _parentState));
((AdditionOrSubtractionContext)_localctx).leftop = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(193);
if (!(precpred(_ctx, 17))) throw new FailedPredicateException(this, "precpred(_ctx, 17)");
setState(194);
((AdditionOrSubtractionContext)_localctx).op = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==PLUS || _la==SUBTRACT) ) {
((AdditionOrSubtractionContext)_localctx).op = (Token)_errHandler.recoverInline(this);
} else {
consume();
}
setState(195);
((AdditionOrSubtractionContext)_localctx).rightop = expr(18);
}
break;
case 4:
{
_localctx = new IntersectionContext(new ExprContext(_parentctx, _parentState));
((IntersectionContext)_localctx).leftop = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(196);
if (!(precpred(_ctx, 15))) throw new FailedPredicateException(this, "precpred(_ctx, 15)");
setState(197);
match(INTERSECTION);
setState(198);
((IntersectionContext)_localctx).rightop = expr(16);
}
break;
case 5:
{
_localctx = new UnionContext(new ExprContext(_parentctx, _parentState));
((UnionContext)_localctx).leftop = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(199);
if (!(precpred(_ctx, 14))) throw new FailedPredicateException(this, "precpred(_ctx, 14)");
setState(200);
match(UNION);
setState(201);
((UnionContext)_localctx).rightop = expr(15);
}
break;
case 6:
{
_localctx = new FunctionTypeContext(new ExprContext(_parentctx, _parentState));
((FunctionTypeContext)_localctx).domaintypes.add(_prevctx);
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(202);
if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)");
setState(207);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==TUPLE_TYPE) {
{
{
setState(203);
match(TUPLE_TYPE);
setState(204);
((FunctionTypeContext)_localctx).expr = expr(0);
((FunctionTypeContext)_localctx).domaintypes.add(((FunctionTypeContext)_localctx).expr);
}
}
setState(209);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(210);
match(FUNCTION_TYPE);
setState(211);
((FunctionTypeContext)_localctx).rangetype = expr(13);
}
break;
case 7:
{
_localctx = new InContext(new ExprContext(_parentctx, _parentState));
((InContext)_localctx).leftop = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(212);
if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)");
setState(213);
match(IN);
setState(214);
((InContext)_localctx).rightop = expr(12);
}
break;
case 8:
{
_localctx = new ComparisonContext(new ExprContext(_parentctx, _parentState));
((ComparisonContext)_localctx).leftop = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(215);
if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)");
setState(216);
((ComparisonContext)_localctx).op = _input.LT(1);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LESS_THAN) | (1L << LESS_THAN_EQUAL) | (1L << EQUAL) | (1L << NOT_EQUAL) | (1L << GREATER_THAN_EQUAL) | (1L << GREATER_THAN))) != 0)) ) {
((ComparisonContext)_localctx).op = (Token)_errHandler.recoverInline(this);
} else {
consume();
}
setState(217);
((ComparisonContext)_localctx).rightop = expr(11);
}
break;
case 9:
{
_localctx = new AndContext(new ExprContext(_parentctx, _parentState));
((AndContext)_localctx).leftconj = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(218);
if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)");
setState(219);
match(AND);
setState(220);
((AndContext)_localctx).rightconj = expr(10);
}
break;
case 10:
{
_localctx = new OrContext(new ExprContext(_parentctx, _parentState));
((OrContext)_localctx).leftdisj = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(221);
if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)");
setState(222);
match(OR);
setState(223);
((OrContext)_localctx).rightdisj = expr(9);
}
break;
case 11:
{
_localctx = new ImplicationContext(new ExprContext(_parentctx, _parentState));
((ImplicationContext)_localctx).antecedent = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(224);
if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
setState(225);
match(IMPLICATION);
setState(226);
((ImplicationContext)_localctx).consequent = expr(7);
}
break;
case 12:
{
_localctx = new BiconditionalContext(new ExprContext(_parentctx, _parentState));
((BiconditionalContext)_localctx).leftop = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(227);
if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
setState(228);
match(BICONDITIONAL);
setState(229);
((BiconditionalContext)_localctx).rightop = expr(6);
}
break;
case 13:
{
_localctx = new FunctionApplicationContext(new ExprContext(_parentctx, _parentState));
((FunctionApplicationContext)_localctx).functor = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(230);
if (!(precpred(_ctx, 30))) throw new FailedPredicateException(this, "precpred(_ctx, 30)");
setState(231);
match(OPEN_PAREN);
setState(240);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NOT) | (1L << AND) | (1L << OR) | (1L << FOR) | (1L << ALL) | (1L << THERE) | (1L << EXISTS) | (1L << LAMBDA) | (1L << IF) | (1L << THEN) | (1L << ELSE) | (1L << INTERSECTION) | (1L << UNION) | (1L << ON) | (1L << IN) | (1L << TUPLE_TYPE) | (1L << FUNCTION_TYPE) | (1L << IMPLICATION) | (1L << BICONDITIONAL) | (1L << EXPONENTIATION) | (1L << DIVIDE) | (1L << TIMES) | (1L << PLUS) | (1L << SUBTRACT) | (1L << LESS_THAN) | (1L << LESS_THAN_EQUAL) | (1L << EQUAL) | (1L << NOT_EQUAL) | (1L << GREATER_THAN_EQUAL) | (1L << OPEN_PAREN) | (1L << OPEN_SQUARE) | (1L << CLOSE_SQUARE) | (1L << OPEN_CURLY) | (1L << OPEN_DOUBLE_CURLY) | (1L << COLON) | (1L << VERT_BAR) | (1L << UNDERSCORE) | (1L << PERIOD) | (1L << INTEGER) | (1L << RATIONAL) | (1L << CONSTANT_STR) | (1L << QUOTED_CONSTANT_STR))) != 0)) {
{
setState(232);
((FunctionApplicationContext)_localctx).expr = expr(0);
((FunctionApplicationContext)_localctx).args.add(((FunctionApplicationContext)_localctx).expr);
setState(237);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(233);
match(COMMA);
setState(234);
((FunctionApplicationContext)_localctx).expr = expr(0);
((FunctionApplicationContext)_localctx).args.add(((FunctionApplicationContext)_localctx).expr);
}
}
setState(239);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(242);
match(CLOSE_PAREN);
}
break;
}
}
}
setState(247);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,23,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class Expr_symbolContext extends ParserRuleContext {
public Expr_non_numeric_symbolContext expr_non_numeric_symbol() {
return getRuleContext(Expr_non_numeric_symbolContext.class,0);
}
public Expr_constant_numberContext expr_constant_number() {
return getRuleContext(Expr_constant_numberContext.class,0);
}
public Expr_symbolContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr_symbol; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitExpr_symbol(this);
else return visitor.visitChildren(this);
}
}
public final Expr_symbolContext expr_symbol() throws RecognitionException {
Expr_symbolContext _localctx = new Expr_symbolContext(_ctx, getState());
enterRule(_localctx, 4, RULE_expr_symbol);
try {
setState(250);
switch (_input.LA(1)) {
case NOT:
case AND:
case OR:
case FOR:
case ALL:
case THERE:
case EXISTS:
case LAMBDA:
case IF:
case THEN:
case ELSE:
case INTERSECTION:
case UNION:
case ON:
case IN:
case TUPLE_TYPE:
case FUNCTION_TYPE:
case IMPLICATION:
case BICONDITIONAL:
case EXPONENTIATION:
case DIVIDE:
case TIMES:
case PLUS:
case SUBTRACT:
case LESS_THAN_EQUAL:
case EQUAL:
case NOT_EQUAL:
case GREATER_THAN_EQUAL:
case COLON:
case VERT_BAR:
case UNDERSCORE:
case PERIOD:
case CONSTANT_STR:
case QUOTED_CONSTANT_STR:
enterOuterAlt(_localctx, 1);
{
setState(248);
expr_non_numeric_symbol();
}
break;
case INTEGER:
case RATIONAL:
enterOuterAlt(_localctx, 2);
{
setState(249);
expr_constant_number();
}
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 Expr_non_numeric_symbolContext extends ParserRuleContext {
public Expr_constant_nameContext expr_constant_name() {
return getRuleContext(Expr_constant_nameContext.class,0);
}
public TerminalNode FUNCTION_TYPE() { return getToken(AntlrGrinderParser.FUNCTION_TYPE, 0); }
public TerminalNode IMPLICATION() { return getToken(AntlrGrinderParser.IMPLICATION, 0); }
public TerminalNode BICONDITIONAL() { return getToken(AntlrGrinderParser.BICONDITIONAL, 0); }
public TerminalNode EXPONENTIATION() { return getToken(AntlrGrinderParser.EXPONENTIATION, 0); }
public TerminalNode DIVIDE() { return getToken(AntlrGrinderParser.DIVIDE, 0); }
public TerminalNode TIMES() { return getToken(AntlrGrinderParser.TIMES, 0); }
public TerminalNode PLUS() { return getToken(AntlrGrinderParser.PLUS, 0); }
public TerminalNode SUBTRACT() { return getToken(AntlrGrinderParser.SUBTRACT, 0); }
public TerminalNode LESS_THAN_EQUAL() { return getToken(AntlrGrinderParser.LESS_THAN_EQUAL, 0); }
public TerminalNode EQUAL() { return getToken(AntlrGrinderParser.EQUAL, 0); }
public TerminalNode NOT_EQUAL() { return getToken(AntlrGrinderParser.NOT_EQUAL, 0); }
public TerminalNode GREATER_THAN_EQUAL() { return getToken(AntlrGrinderParser.GREATER_THAN_EQUAL, 0); }
public TerminalNode COLON() { return getToken(AntlrGrinderParser.COLON, 0); }
public TerminalNode VERT_BAR() { return getToken(AntlrGrinderParser.VERT_BAR, 0); }
public TerminalNode UNDERSCORE() { return getToken(AntlrGrinderParser.UNDERSCORE, 0); }
public TerminalNode PERIOD() { return getToken(AntlrGrinderParser.PERIOD, 0); }
public Expr_non_numeric_symbolContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr_non_numeric_symbol; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitExpr_non_numeric_symbol(this);
else return visitor.visitChildren(this);
}
}
public final Expr_non_numeric_symbolContext expr_non_numeric_symbol() throws RecognitionException {
Expr_non_numeric_symbolContext _localctx = new Expr_non_numeric_symbolContext(_ctx, getState());
enterRule(_localctx, 6, RULE_expr_non_numeric_symbol);
try {
setState(269);
switch (_input.LA(1)) {
case NOT:
case AND:
case OR:
case FOR:
case ALL:
case THERE:
case EXISTS:
case LAMBDA:
case IF:
case THEN:
case ELSE:
case INTERSECTION:
case UNION:
case ON:
case IN:
case TUPLE_TYPE:
case CONSTANT_STR:
case QUOTED_CONSTANT_STR:
enterOuterAlt(_localctx, 1);
{
setState(252);
expr_constant_name();
}
break;
case FUNCTION_TYPE:
enterOuterAlt(_localctx, 2);
{
setState(253);
match(FUNCTION_TYPE);
}
break;
case IMPLICATION:
enterOuterAlt(_localctx, 3);
{
setState(254);
match(IMPLICATION);
}
break;
case BICONDITIONAL:
enterOuterAlt(_localctx, 4);
{
setState(255);
match(BICONDITIONAL);
}
break;
case EXPONENTIATION:
enterOuterAlt(_localctx, 5);
{
setState(256);
match(EXPONENTIATION);
}
break;
case DIVIDE:
enterOuterAlt(_localctx, 6);
{
setState(257);
match(DIVIDE);
}
break;
case TIMES:
enterOuterAlt(_localctx, 7);
{
setState(258);
match(TIMES);
}
break;
case PLUS:
enterOuterAlt(_localctx, 8);
{
setState(259);
match(PLUS);
}
break;
case SUBTRACT:
enterOuterAlt(_localctx, 9);
{
setState(260);
match(SUBTRACT);
}
break;
case LESS_THAN_EQUAL:
enterOuterAlt(_localctx, 10);
{
setState(261);
match(LESS_THAN_EQUAL);
}
break;
case EQUAL:
enterOuterAlt(_localctx, 11);
{
setState(262);
match(EQUAL);
}
break;
case NOT_EQUAL:
enterOuterAlt(_localctx, 12);
{
setState(263);
match(NOT_EQUAL);
}
break;
case GREATER_THAN_EQUAL:
enterOuterAlt(_localctx, 13);
{
setState(264);
match(GREATER_THAN_EQUAL);
}
break;
case COLON:
enterOuterAlt(_localctx, 14);
{
setState(265);
match(COLON);
}
break;
case VERT_BAR:
enterOuterAlt(_localctx, 15);
{
setState(266);
match(VERT_BAR);
}
break;
case UNDERSCORE:
enterOuterAlt(_localctx, 16);
{
setState(267);
match(UNDERSCORE);
}
break;
case PERIOD:
enterOuterAlt(_localctx, 17);
{
setState(268);
match(PERIOD);
}
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 Expr_constant_nameContext extends ParserRuleContext {
public TerminalNode CONSTANT_STR() { return getToken(AntlrGrinderParser.CONSTANT_STR, 0); }
public TerminalNode QUOTED_CONSTANT_STR() { return getToken(AntlrGrinderParser.QUOTED_CONSTANT_STR, 0); }
public TerminalNode NOT() { return getToken(AntlrGrinderParser.NOT, 0); }
public TerminalNode AND() { return getToken(AntlrGrinderParser.AND, 0); }
public TerminalNode OR() { return getToken(AntlrGrinderParser.OR, 0); }
public TerminalNode FOR() { return getToken(AntlrGrinderParser.FOR, 0); }
public TerminalNode ALL() { return getToken(AntlrGrinderParser.ALL, 0); }
public TerminalNode THERE() { return getToken(AntlrGrinderParser.THERE, 0); }
public TerminalNode EXISTS() { return getToken(AntlrGrinderParser.EXISTS, 0); }
public TerminalNode LAMBDA() { return getToken(AntlrGrinderParser.LAMBDA, 0); }
public TerminalNode IF() { return getToken(AntlrGrinderParser.IF, 0); }
public TerminalNode THEN() { return getToken(AntlrGrinderParser.THEN, 0); }
public TerminalNode ELSE() { return getToken(AntlrGrinderParser.ELSE, 0); }
public TerminalNode INTERSECTION() { return getToken(AntlrGrinderParser.INTERSECTION, 0); }
public TerminalNode UNION() { return getToken(AntlrGrinderParser.UNION, 0); }
public TerminalNode ON() { return getToken(AntlrGrinderParser.ON, 0); }
public TerminalNode IN() { return getToken(AntlrGrinderParser.IN, 0); }
public TerminalNode TUPLE_TYPE() { return getToken(AntlrGrinderParser.TUPLE_TYPE, 0); }
public Expr_constant_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr_constant_name; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitExpr_constant_name(this);
else return visitor.visitChildren(this);
}
}
public final Expr_constant_nameContext expr_constant_name() throws RecognitionException {
Expr_constant_nameContext _localctx = new Expr_constant_nameContext(_ctx, getState());
enterRule(_localctx, 8, RULE_expr_constant_name);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(271);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NOT) | (1L << AND) | (1L << OR) | (1L << FOR) | (1L << ALL) | (1L << THERE) | (1L << EXISTS) | (1L << LAMBDA) | (1L << IF) | (1L << THEN) | (1L << ELSE) | (1L << INTERSECTION) | (1L << UNION) | (1L << ON) | (1L << IN) | (1L << TUPLE_TYPE) | (1L << CONSTANT_STR) | (1L << QUOTED_CONSTANT_STR))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Expr_constant_numberContext extends ParserRuleContext {
public TerminalNode INTEGER() { return getToken(AntlrGrinderParser.INTEGER, 0); }
public TerminalNode RATIONAL() { return getToken(AntlrGrinderParser.RATIONAL, 0); }
public Expr_constant_numberContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr_constant_number; }
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof AntlrGrinderVisitor ) return ((AntlrGrinderVisitor)visitor).visitExpr_constant_number(this);
else return visitor.visitChildren(this);
}
}
public final Expr_constant_numberContext expr_constant_number() throws RecognitionException {
Expr_constant_numberContext _localctx = new Expr_constant_numberContext(_ctx, getState());
enterRule(_localctx, 10, RULE_expr_constant_number);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(273);
_la = _input.LA(1);
if ( !(_la==INTEGER || _la==RATIONAL) ) {
_errHandler.recoverInline(this);
} else {
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, 19);
case 1:
return precpred(_ctx, 18);
case 2:
return precpred(_ctx, 17);
case 3:
return precpred(_ctx, 15);
case 4:
return precpred(_ctx, 14);
case 5:
return precpred(_ctx, 12);
case 6:
return precpred(_ctx, 11);
case 7:
return precpred(_ctx, 10);
case 8:
return precpred(_ctx, 9);
case 9:
return precpred(_ctx, 8);
case 10:
return precpred(_ctx, 7);
case 11:
return precpred(_ctx, 6);
case 12:
return precpred(_ctx, 30);
}
return true;
}
public static final String _serializedATN =
"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\66\u0116\4\2\t\2"+
"\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\3\2\3\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\7\3!\n\3\f\3\16\3$\13\3\5\3"+
"&\n\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\3\3\3\3\3\3\3\3\3\3\3\7\3D\n\3\f\3\16\3G\13"+
"\3\3\3\3\3\3\3\3\3\3\3\3\3\7\3O\n\3\f\3\16\3R\13\3\5\3T\n\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\7\3d\n\3\f\3\16\3g\13\3"+
"\5\3i\n\3\3\3\5\3l\n\3\3\3\3\3\3\3\5\3q\n\3\3\3\3\3\3\3\3\3\3\3\3\3\3"+
"\3\3\3\7\3{\n\3\f\3\16\3~\13\3\5\3\u0080\n\3\3\3\5\3\u0083\n\3\3\3\3\3"+
"\3\3\5\3\u0088\n\3\3\3\3\3\3\3\3\3\3\3\3\3\7\3\u0090\n\3\f\3\16\3\u0093"+
"\13\3\5\3\u0095\n\3\3\3\3\3\3\3\3\3\3\3\7\3\u009c\n\3\f\3\16\3\u009f\13"+
"\3\5\3\u00a1\n\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\7\3\u00b4\n\3\f\3\16\3\u00b7\13\3\3\3\3\3\3\3\5\3\u00bc"+
"\n\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\7\3\u00d0\n\3\f\3\16\3\u00d3\13\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\3\3\3\3\3"+
"\7\3\u00ee\n\3\f\3\16\3\u00f1\13\3\5\3\u00f3\n\3\3\3\7\3\u00f6\n\3\f\3"+
"\16\3\u00f9\13\3\3\4\3\4\5\4\u00fd\n\4\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5"+
"\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\5\5\u0110\n\5\3\6\3\6\3\7\3\7\3\7"+
"\2\3\4\b\2\4\6\b\n\f\2\b\3\2$%\3\2\27\31\3\2\32\33\3\2\34!\4\2\3\22\62"+
"\63\3\2\60\61\u0154\2\16\3\2\2\2\4\u00bb\3\2\2\2\6\u00fc\3\2\2\2\b\u010f"+
"\3\2\2\2\n\u0111\3\2\2\2\f\u0113\3\2\2\2\16\17\5\4\3\2\17\3\3\2\2\2\20"+
"\21\b\3\1\2\21\22\7\3\2\2\22\u00bc\5\4\3\27\23\24\7\33\2\2\24\u00bc\5"+
"\4\3\26\25\26\7\13\2\2\26\27\5\4\3\2\27\30\7\f\2\2\30\31\5\4\3\2\31\32"+
"\7\r\2\2\32\33\5\4\3\7\33\u00bc\3\2\2\2\34%\7\n\2\2\35\"\5\4\3\2\36\37"+
"\7-\2\2\37!\5\4\3\2 \36\3\2\2\2!$\3\2\2\2\" \3\2\2\2\"#\3\2\2\2#&\3\2"+
"\2\2$\"\3\2\2\2%\35\3\2\2\2%&\3\2\2\2&\'\3\2\2\2\'(\7+\2\2(\u00bc\5\4"+
"\3\6)*\7\6\2\2*+\7\7\2\2+,\5\4\3\2,-\7+\2\2-.\5\4\3\5.\u00bc\3\2\2\2/"+
"\60\7\b\2\2\60\61\7\t\2\2\61\62\5\4\3\2\62\63\7+\2\2\63\64\5\4\3\4\64"+
"\u00bc\3\2\2\2\65\66\7\"\2\2\66\67\5\4\3\2\678\7#\2\28\u00bc\3\2\2\29"+
":\7\34\2\2:;\5\4\3\2;<\7!\2\2<\u00bc\3\2\2\2=>\7\"\2\2>?\5\4\3\2?@\7-"+
"\2\2@E\5\4\3\2AB\7-\2\2BD\5\4\3\2CA\3\2\2\2DG\3\2\2\2EC\3\2\2\2EF\3\2"+
"\2\2FH\3\2\2\2GE\3\2\2\2HI\7#\2\2I\u00bc\3\2\2\2JS\7,\2\2KP\5\4\3\2LM"+
"\7-\2\2MO\5\4\3\2NL\3\2\2\2OR\3\2\2\2PN\3\2\2\2PQ\3\2\2\2QT\3\2\2\2RP"+
"\3\2\2\2SK\3\2\2\2ST\3\2\2\2TU\3\2\2\2UV\7+\2\2VW\5\4\3\2WX\7,\2\2X\u00bc"+
"\3\2\2\2YZ\7,\2\2Z[\5\4\3\2[\\\7,\2\2\\\u00bc\3\2\2\2]k\7&\2\2^_\7\"\2"+
"\2_h\7\20\2\2`e\5\4\3\2ab\7-\2\2bd\5\4\3\2ca\3\2\2\2dg\3\2\2\2ec\3\2\2"+
"\2ef\3\2\2\2fi\3\2\2\2ge\3\2\2\2h`\3\2\2\2hi\3\2\2\2ij\3\2\2\2jl\7#\2"+
"\2k^\3\2\2\2kl\3\2\2\2lm\3\2\2\2mp\5\4\3\2no\7+\2\2oq\5\4\3\2pn\3\2\2"+
"\2pq\3\2\2\2qr\3\2\2\2rs\7\'\2\2s\u00bc\3\2\2\2t\u0082\7(\2\2uv\7\"\2"+
"\2v\177\7\20\2\2w|\5\4\3\2xy\7-\2\2y{\5\4\3\2zx\3\2\2\2{~\3\2\2\2|z\3"+
"\2\2\2|}\3\2\2\2}\u0080\3\2\2\2~|\3\2\2\2\177w\3\2\2\2\177\u0080\3\2\2"+
"\2\u0080\u0081\3\2\2\2\u0081\u0083\7#\2\2\u0082u\3\2\2\2\u0082\u0083\3"+
"\2\2\2\u0083\u0084\3\2\2\2\u0084\u0087\5\4\3\2\u0085\u0086\7+\2\2\u0086"+
"\u0088\5\4\3\2\u0087\u0085\3\2\2\2\u0087\u0088\3\2\2\2\u0088\u0089\3\2"+
"\2\2\u0089\u008a\7)\2\2\u008a\u00bc\3\2\2\2\u008b\u0094\7&\2\2\u008c\u0091"+
"\5\4\3\2\u008d\u008e\7-\2\2\u008e\u0090\5\4\3\2\u008f\u008d\3\2\2\2\u0090"+
"\u0093\3\2\2\2\u0091\u008f\3\2\2\2\u0091\u0092\3\2\2\2\u0092\u0095\3\2"+
"\2\2\u0093\u0091\3\2\2\2\u0094\u008c\3\2\2\2\u0094\u0095\3\2\2\2\u0095"+
"\u0096\3\2\2\2\u0096\u00bc\7\'\2\2\u0097\u00a0\7(\2\2\u0098\u009d\5\4"+
"\3\2\u0099\u009a\7-\2\2\u009a\u009c\5\4\3\2\u009b\u0099\3\2\2\2\u009c"+
"\u009f\3\2\2\2\u009d\u009b\3\2\2\2\u009d\u009e\3\2\2\2\u009e\u00a1\3\2"+
"\2\2\u009f\u009d\3\2\2\2\u00a0\u0098\3\2\2\2\u00a0\u00a1\3\2\2\2\u00a1"+
"\u00a2\3\2\2\2\u00a2\u00bc\7)\2\2\u00a3\u00a4\7$\2\2\u00a4\u00a5\5\4\3"+
"\2\u00a5\u00a6\7%\2\2\u00a6\u00bc\3\2\2\2\u00a7\u00a8\t\2\2\2\u00a8\u00a9"+
"\5\4\3\2\u00a9\u00aa\7*\2\2\u00aa\u00ab\5\4\3\2\u00ab\u00ac\t\2\2\2\u00ac"+
"\u00bc\3\2\2\2\u00ad\u00ae\7\"\2\2\u00ae\u00af\5\4\3\2\u00af\u00b0\7\22"+
"\2\2\u00b0\u00b5\5\4\3\2\u00b1\u00b2\7\22\2\2\u00b2\u00b4\5\4\3\2\u00b3"+
"\u00b1\3\2\2\2\u00b4\u00b7\3\2\2\2\u00b5\u00b3\3\2\2\2\u00b5\u00b6\3\2"+
"\2\2\u00b6\u00b8\3\2\2\2\u00b7\u00b5\3\2\2\2\u00b8\u00b9\7#\2\2\u00b9"+
"\u00bc\3\2\2\2\u00ba\u00bc\5\6\4\2\u00bb\20\3\2\2\2\u00bb\23\3\2\2\2\u00bb"+
"\25\3\2\2\2\u00bb\34\3\2\2\2\u00bb)\3\2\2\2\u00bb/\3\2\2\2\u00bb\65\3"+
"\2\2\2\u00bb9\3\2\2\2\u00bb=\3\2\2\2\u00bbJ\3\2\2\2\u00bbY\3\2\2\2\u00bb"+
"]\3\2\2\2\u00bbt\3\2\2\2\u00bb\u008b\3\2\2\2\u00bb\u0097\3\2\2\2\u00bb"+
"\u00a3\3\2\2\2\u00bb\u00a7\3\2\2\2\u00bb\u00ad\3\2\2\2\u00bb\u00ba\3\2"+
"\2\2\u00bc\u00f7\3\2\2\2\u00bd\u00be\f\25\2\2\u00be\u00bf\7\26\2\2\u00bf"+
"\u00f6\5\4\3\25\u00c0\u00c1\f\24\2\2\u00c1\u00c2\t\3\2\2\u00c2\u00f6\5"+
"\4\3\25\u00c3\u00c4\f\23\2\2\u00c4\u00c5\t\4\2\2\u00c5\u00f6\5\4\3\24"+
"\u00c6\u00c7\f\21\2\2\u00c7\u00c8\7\16\2\2\u00c8\u00f6\5\4\3\22\u00c9"+
"\u00ca\f\20\2\2\u00ca\u00cb\7\17\2\2\u00cb\u00f6\5\4\3\21\u00cc\u00d1"+
"\f\16\2\2\u00cd\u00ce\7\22\2\2\u00ce\u00d0\5\4\3\2\u00cf\u00cd\3\2\2\2"+
"\u00d0\u00d3\3\2\2\2\u00d1\u00cf\3\2\2\2\u00d1\u00d2\3\2\2\2\u00d2\u00d4"+
"\3\2\2\2\u00d3\u00d1\3\2\2\2\u00d4\u00d5\7\23\2\2\u00d5\u00f6\5\4\3\17"+
"\u00d6\u00d7\f\r\2\2\u00d7\u00d8\7\21\2\2\u00d8\u00f6\5\4\3\16\u00d9\u00da"+
"\f\f\2\2\u00da\u00db\t\5\2\2\u00db\u00f6\5\4\3\r\u00dc\u00dd\f\13\2\2"+
"\u00dd\u00de\7\4\2\2\u00de\u00f6\5\4\3\f\u00df\u00e0\f\n\2\2\u00e0\u00e1"+
"\7\5\2\2\u00e1\u00f6\5\4\3\13\u00e2\u00e3\f\t\2\2\u00e3\u00e4\7\24\2\2"+
"\u00e4\u00f6\5\4\3\t\u00e5\u00e6\f\b\2\2\u00e6\u00e7\7\25\2\2\u00e7\u00f6"+
"\5\4\3\b\u00e8\u00e9\f \2\2\u00e9\u00f2\7\"\2\2\u00ea\u00ef\5\4\3\2\u00eb"+
"\u00ec\7-\2\2\u00ec\u00ee\5\4\3\2\u00ed\u00eb\3\2\2\2\u00ee\u00f1\3\2"+
"\2\2\u00ef\u00ed\3\2\2\2\u00ef\u00f0\3\2\2\2\u00f0\u00f3\3\2\2\2\u00f1"+
"\u00ef\3\2\2\2\u00f2\u00ea\3\2\2\2\u00f2\u00f3\3\2\2\2\u00f3\u00f4\3\2"+
"\2\2\u00f4\u00f6\7#\2\2\u00f5\u00bd\3\2\2\2\u00f5\u00c0\3\2\2\2\u00f5"+
"\u00c3\3\2\2\2\u00f5\u00c6\3\2\2\2\u00f5\u00c9\3\2\2\2\u00f5\u00cc\3\2"+
"\2\2\u00f5\u00d6\3\2\2\2\u00f5\u00d9\3\2\2\2\u00f5\u00dc\3\2\2\2\u00f5"+
"\u00df\3\2\2\2\u00f5\u00e2\3\2\2\2\u00f5\u00e5\3\2\2\2\u00f5\u00e8\3\2"+
"\2\2\u00f6\u00f9\3\2\2\2\u00f7\u00f5\3\2\2\2\u00f7\u00f8\3\2\2\2\u00f8"+
"\5\3\2\2\2\u00f9\u00f7\3\2\2\2\u00fa\u00fd\5\b\5\2\u00fb\u00fd\5\f\7\2"+
"\u00fc\u00fa\3\2\2\2\u00fc\u00fb\3\2\2\2\u00fd\7\3\2\2\2\u00fe\u0110\5"+
"\n\6\2\u00ff\u0110\7\23\2\2\u0100\u0110\7\24\2\2\u0101\u0110\7\25\2\2"+
"\u0102\u0110\7\26\2\2\u0103\u0110\7\27\2\2\u0104\u0110\7\30\2\2\u0105"+
"\u0110\7\32\2\2\u0106\u0110\7\33\2\2\u0107\u0110\7\35\2\2\u0108\u0110"+
"\7\36\2\2\u0109\u0110\7\37\2\2\u010a\u0110\7 \2\2\u010b\u0110\7+\2\2\u010c"+
"\u0110\7,\2\2\u010d\u0110\7.\2\2\u010e\u0110\7/\2\2\u010f\u00fe\3\2\2"+
"\2\u010f\u00ff\3\2\2\2\u010f\u0100\3\2\2\2\u010f\u0101\3\2\2\2\u010f\u0102"+
"\3\2\2\2\u010f\u0103\3\2\2\2\u010f\u0104\3\2\2\2\u010f\u0105\3\2\2\2\u010f"+
"\u0106\3\2\2\2\u010f\u0107\3\2\2\2\u010f\u0108\3\2\2\2\u010f\u0109\3\2"+
"\2\2\u010f\u010a\3\2\2\2\u010f\u010b\3\2\2\2\u010f\u010c\3\2\2\2\u010f"+
"\u010d\3\2\2\2\u010f\u010e\3\2\2\2\u0110\t\3\2\2\2\u0111\u0112\t\6\2\2"+
"\u0112\13\3\2\2\2\u0113\u0114\t\7\2\2\u0114\r\3\2\2\2\34\"%EPSehkp|\177"+
"\u0082\u0087\u0091\u0094\u009d\u00a0\u00b5\u00bb\u00d1\u00ef\u00f2\u00f5"+
"\u00f7\u00fc\u010f";
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