hu.bme.mit.theta.cat.dsl.gen.CatParser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of theta-cat Show documentation
Show all versions of theta-cat Show documentation
Cat subproject in the Theta model checking framework
// Generated from Cat.g4 by ANTLR 4.9.2
package hu.bme.mit.theta.cat.dsl.gen;
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 CatParser extends Parser {
static { RuntimeMetaData.checkVersion("4.9.2", 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, LET=4, REC=5, AND=6, AS=7, TRY=8, WITH=9, CALL=10,
PROCEDURE=11, END=12, INCLUDE=13, ACYCLIC=14, IRREFLEXIVE=15, EMPTY=16,
DOMAIN=17, RANGE=18, EQ=19, STAR=20, PLUS=21, OPT=22, INV=23, NOT=24,
AMP=25, BAR=26, SEMI=27, BSLASH=28, POW=29, LPAR=30, RPAR=31, LBRAC=32,
RBRAC=33, COMMA=34, QUOT=35, NAME=36, LINE_COMMENT=37, BLOCK_COMMENT=38,
WS=39, SHOW=40;
public static final int
RULE_mcm = 0, RULE_name = 1, RULE_scopeBody = 2, RULE_procCall = 3, RULE_functionDef = 4,
RULE_procDef = 5, RULE_includeFile = 6, RULE_definition = 7, RULE_axiomDefinition = 8,
RULE_letDefinition = 9, RULE_letAndDefinition = 10, RULE_expression = 11;
private static String[] makeRuleNames() {
return new String[] {
"mcm", "name", "scopeBody", "procCall", "functionDef", "procDef", "includeFile",
"definition", "axiomDefinition", "letDefinition", "letAndDefinition",
"expression"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, "'0'", "'{'", "'}'", "'let'", "'rec'", "'and'", "'as'", "'try'",
"'with'", "'call'", "'procedure'", "'end'", "'include'", "'acyclic'",
"'irreflexive'", "'empty'", "'domain'", "'range'", "'='", "'*'", "'+'",
"'?'", "'-1'", "'~'", "'&'", "'|'", "';'", "'\\'", null, "'('", "')'",
"'['", "']'", "','", "'\"'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, null, null, null, "LET", "REC", "AND", "AS", "TRY", "WITH", "CALL",
"PROCEDURE", "END", "INCLUDE", "ACYCLIC", "IRREFLEXIVE", "EMPTY", "DOMAIN",
"RANGE", "EQ", "STAR", "PLUS", "OPT", "INV", "NOT", "AMP", "BAR", "SEMI",
"BSLASH", "POW", "LPAR", "RPAR", "LBRAC", "RBRAC", "COMMA", "QUOT", "NAME",
"LINE_COMMENT", "BLOCK_COMMENT", "WS", "SHOW"
};
}
private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
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 "Cat.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public CatParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class McmContext extends ParserRuleContext {
public ScopeBodyContext scopeBody() {
return getRuleContext(ScopeBodyContext.class,0);
}
public TerminalNode EOF() { return getToken(CatParser.EOF, 0); }
public NameContext name() {
return getRuleContext(NameContext.class,0);
}
public McmContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_mcm; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterMcm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitMcm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitMcm(this);
else return visitor.visitChildren(this);
}
}
public final McmContext mcm() throws RecognitionException {
McmContext _localctx = new McmContext(_ctx, getState());
enterRule(_localctx, 0, RULE_mcm);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(25);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==QUOT || _la==NAME) {
{
setState(24);
name();
}
}
setState(27);
scopeBody();
setState(28);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NameContext extends ParserRuleContext {
public List QUOT() { return getTokens(CatParser.QUOT); }
public TerminalNode QUOT(int i) {
return getToken(CatParser.QUOT, i);
}
public List NAME() { return getTokens(CatParser.NAME); }
public TerminalNode NAME(int i) {
return getToken(CatParser.NAME, i);
}
public NameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitName(this);
else return visitor.visitChildren(this);
}
}
public final NameContext name() throws RecognitionException {
NameContext _localctx = new NameContext(_ctx, getState());
enterRule(_localctx, 2, RULE_name);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
{
setState(31);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==QUOT) {
{
setState(30);
match(QUOT);
}
}
setState(34);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(33);
match(NAME);
}
}
setState(36);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==NAME );
setState(39);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==QUOT) {
{
setState(38);
match(QUOT);
}
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ScopeBodyContext extends ParserRuleContext {
public List procCall() {
return getRuleContexts(ProcCallContext.class);
}
public ProcCallContext procCall(int i) {
return getRuleContext(ProcCallContext.class,i);
}
public List functionDef() {
return getRuleContexts(FunctionDefContext.class);
}
public FunctionDefContext functionDef(int i) {
return getRuleContext(FunctionDefContext.class,i);
}
public List procDef() {
return getRuleContexts(ProcDefContext.class);
}
public ProcDefContext procDef(int i) {
return getRuleContext(ProcDefContext.class,i);
}
public List definition() {
return getRuleContexts(DefinitionContext.class);
}
public DefinitionContext definition(int i) {
return getRuleContext(DefinitionContext.class,i);
}
public List includeFile() {
return getRuleContexts(IncludeFileContext.class);
}
public IncludeFileContext includeFile(int i) {
return getRuleContext(IncludeFileContext.class,i);
}
public ScopeBodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_scopeBody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterScopeBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitScopeBody(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitScopeBody(this);
else return visitor.visitChildren(this);
}
}
public final ScopeBodyContext scopeBody() throws RecognitionException {
ScopeBodyContext _localctx = new ScopeBodyContext(_ctx, getState());
enterRule(_localctx, 4, RULE_scopeBody);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(48);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LET) | (1L << CALL) | (1L << PROCEDURE) | (1L << INCLUDE) | (1L << ACYCLIC) | (1L << IRREFLEXIVE) | (1L << EMPTY) | (1L << NOT))) != 0)) {
{
setState(46);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
case 1:
{
setState(41);
procCall();
}
break;
case 2:
{
setState(42);
functionDef();
}
break;
case 3:
{
setState(43);
procDef();
}
break;
case 4:
{
setState(44);
definition();
}
break;
case 5:
{
setState(45);
includeFile();
}
break;
}
}
setState(50);
_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 ProcCallContext extends ParserRuleContext {
public Token proc;
public ExpressionContext expression;
public List params = new ArrayList();
public TerminalNode CALL() { return getToken(CatParser.CALL, 0); }
public TerminalNode LPAR() { return getToken(CatParser.LPAR, 0); }
public TerminalNode RPAR() { return getToken(CatParser.RPAR, 0); }
public TerminalNode NAME() { return getToken(CatParser.NAME, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List COMMA() { return getTokens(CatParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(CatParser.COMMA, i);
}
public ProcCallContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_procCall; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterProcCall(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitProcCall(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitProcCall(this);
else return visitor.visitChildren(this);
}
}
public final ProcCallContext procCall() throws RecognitionException {
ProcCallContext _localctx = new ProcCallContext(_ctx, getState());
enterRule(_localctx, 6, RULE_procCall);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(51);
match(CALL);
setState(52);
((ProcCallContext)_localctx).proc = match(NAME);
setState(53);
match(LPAR);
setState(54);
((ProcCallContext)_localctx).expression = expression(0);
((ProcCallContext)_localctx).params.add(((ProcCallContext)_localctx).expression);
setState(59);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(55);
match(COMMA);
setState(56);
((ProcCallContext)_localctx).expression = expression(0);
((ProcCallContext)_localctx).params.add(((ProcCallContext)_localctx).expression);
}
}
setState(61);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(62);
match(RPAR);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FunctionDefContext extends ParserRuleContext {
public Token n;
public Token NAME;
public List params = new ArrayList();
public ExpressionContext e;
public TerminalNode LET() { return getToken(CatParser.LET, 0); }
public TerminalNode LPAR() { return getToken(CatParser.LPAR, 0); }
public TerminalNode RPAR() { return getToken(CatParser.RPAR, 0); }
public TerminalNode EQ() { return getToken(CatParser.EQ, 0); }
public List NAME() { return getTokens(CatParser.NAME); }
public TerminalNode NAME(int i) {
return getToken(CatParser.NAME, i);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public List COMMA() { return getTokens(CatParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(CatParser.COMMA, i);
}
public FunctionDefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionDef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterFunctionDef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitFunctionDef(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitFunctionDef(this);
else return visitor.visitChildren(this);
}
}
public final FunctionDefContext functionDef() throws RecognitionException {
FunctionDefContext _localctx = new FunctionDefContext(_ctx, getState());
enterRule(_localctx, 8, RULE_functionDef);
int _la;
try {
setState(87);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(64);
match(LET);
setState(65);
((FunctionDefContext)_localctx).n = match(NAME);
setState(66);
match(LPAR);
setState(67);
((FunctionDefContext)_localctx).NAME = match(NAME);
((FunctionDefContext)_localctx).params.add(((FunctionDefContext)_localctx).NAME);
setState(72);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(68);
match(COMMA);
setState(69);
((FunctionDefContext)_localctx).NAME = match(NAME);
((FunctionDefContext)_localctx).params.add(((FunctionDefContext)_localctx).NAME);
}
}
setState(74);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(75);
match(RPAR);
setState(76);
match(EQ);
setState(77);
((FunctionDefContext)_localctx).e = expression(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(78);
match(LET);
setState(79);
((FunctionDefContext)_localctx).n = match(NAME);
setState(81);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(80);
((FunctionDefContext)_localctx).NAME = match(NAME);
((FunctionDefContext)_localctx).params.add(((FunctionDefContext)_localctx).NAME);
}
}
setState(83);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==NAME );
setState(85);
match(EQ);
setState(86);
((FunctionDefContext)_localctx).e = expression(0);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ProcDefContext extends ParserRuleContext {
public Token n;
public Token NAME;
public List params = new ArrayList();
public ScopeBodyContext body;
public TerminalNode PROCEDURE() { return getToken(CatParser.PROCEDURE, 0); }
public TerminalNode LPAR() { return getToken(CatParser.LPAR, 0); }
public TerminalNode RPAR() { return getToken(CatParser.RPAR, 0); }
public TerminalNode EQ() { return getToken(CatParser.EQ, 0); }
public TerminalNode END() { return getToken(CatParser.END, 0); }
public List NAME() { return getTokens(CatParser.NAME); }
public TerminalNode NAME(int i) {
return getToken(CatParser.NAME, i);
}
public ScopeBodyContext scopeBody() {
return getRuleContext(ScopeBodyContext.class,0);
}
public List COMMA() { return getTokens(CatParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(CatParser.COMMA, i);
}
public ProcDefContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_procDef; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterProcDef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitProcDef(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitProcDef(this);
else return visitor.visitChildren(this);
}
}
public final ProcDefContext procDef() throws RecognitionException {
ProcDefContext _localctx = new ProcDefContext(_ctx, getState());
enterRule(_localctx, 10, RULE_procDef);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(89);
match(PROCEDURE);
setState(90);
((ProcDefContext)_localctx).n = match(NAME);
setState(91);
match(LPAR);
setState(92);
((ProcDefContext)_localctx).NAME = match(NAME);
((ProcDefContext)_localctx).params.add(((ProcDefContext)_localctx).NAME);
setState(97);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(93);
match(COMMA);
setState(94);
((ProcDefContext)_localctx).NAME = match(NAME);
((ProcDefContext)_localctx).params.add(((ProcDefContext)_localctx).NAME);
}
}
setState(99);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(100);
match(RPAR);
setState(101);
match(EQ);
setState(102);
((ProcDefContext)_localctx).body = scopeBody();
setState(103);
match(END);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IncludeFileContext extends ParserRuleContext {
public Token file;
public TerminalNode INCLUDE() { return getToken(CatParser.INCLUDE, 0); }
public List QUOT() { return getTokens(CatParser.QUOT); }
public TerminalNode QUOT(int i) {
return getToken(CatParser.QUOT, i);
}
public TerminalNode NAME() { return getToken(CatParser.NAME, 0); }
public IncludeFileContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_includeFile; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterIncludeFile(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitIncludeFile(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitIncludeFile(this);
else return visitor.visitChildren(this);
}
}
public final IncludeFileContext includeFile() throws RecognitionException {
IncludeFileContext _localctx = new IncludeFileContext(_ctx, getState());
enterRule(_localctx, 12, RULE_includeFile);
try {
enterOuterAlt(_localctx, 1);
{
setState(105);
match(INCLUDE);
setState(106);
match(QUOT);
setState(107);
((IncludeFileContext)_localctx).file = match(NAME);
setState(108);
match(QUOT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DefinitionContext extends ParserRuleContext {
public AxiomDefinitionContext axiomDefinition() {
return getRuleContext(AxiomDefinitionContext.class,0);
}
public LetDefinitionContext letDefinition() {
return getRuleContext(LetDefinitionContext.class,0);
}
public DefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_definition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitDefinition(this);
else return visitor.visitChildren(this);
}
}
public final DefinitionContext definition() throws RecognitionException {
DefinitionContext _localctx = new DefinitionContext(_ctx, getState());
enterRule(_localctx, 14, RULE_definition);
try {
setState(112);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ACYCLIC:
case IRREFLEXIVE:
case EMPTY:
case NOT:
enterOuterAlt(_localctx, 1);
{
setState(110);
axiomDefinition();
}
break;
case LET:
enterOuterAlt(_localctx, 2);
{
setState(111);
letDefinition();
}
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 AxiomDefinitionContext extends ParserRuleContext {
public AxiomDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_axiomDefinition; }
public AxiomDefinitionContext() { }
public void copyFrom(AxiomDefinitionContext ctx) {
super.copyFrom(ctx);
}
}
public static class AcyclicDefinitionContext extends AxiomDefinitionContext {
public Token negate;
public ExpressionContext e;
public TerminalNode ACYCLIC() { return getToken(CatParser.ACYCLIC, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode AS() { return getToken(CatParser.AS, 0); }
public TerminalNode NAME() { return getToken(CatParser.NAME, 0); }
public TerminalNode NOT() { return getToken(CatParser.NOT, 0); }
public AcyclicDefinitionContext(AxiomDefinitionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterAcyclicDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitAcyclicDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitAcyclicDefinition(this);
else return visitor.visitChildren(this);
}
}
public static class EmptyDefinitionContext extends AxiomDefinitionContext {
public Token negate;
public ExpressionContext e;
public TerminalNode EMPTY() { return getToken(CatParser.EMPTY, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode AS() { return getToken(CatParser.AS, 0); }
public TerminalNode NAME() { return getToken(CatParser.NAME, 0); }
public TerminalNode NOT() { return getToken(CatParser.NOT, 0); }
public EmptyDefinitionContext(AxiomDefinitionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterEmptyDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitEmptyDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitEmptyDefinition(this);
else return visitor.visitChildren(this);
}
}
public static class IrreflexiveDefinitionContext extends AxiomDefinitionContext {
public Token negate;
public ExpressionContext e;
public TerminalNode IRREFLEXIVE() { return getToken(CatParser.IRREFLEXIVE, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode AS() { return getToken(CatParser.AS, 0); }
public TerminalNode NAME() { return getToken(CatParser.NAME, 0); }
public TerminalNode NOT() { return getToken(CatParser.NOT, 0); }
public IrreflexiveDefinitionContext(AxiomDefinitionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterIrreflexiveDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitIrreflexiveDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitIrreflexiveDefinition(this);
else return visitor.visitChildren(this);
}
}
public final AxiomDefinitionContext axiomDefinition() throws RecognitionException {
AxiomDefinitionContext _localctx = new AxiomDefinitionContext(_ctx, getState());
enterRule(_localctx, 16, RULE_axiomDefinition);
int _la;
try {
setState(141);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
case 1:
_localctx = new AcyclicDefinitionContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(115);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(114);
((AcyclicDefinitionContext)_localctx).negate = match(NOT);
}
}
setState(117);
match(ACYCLIC);
setState(118);
((AcyclicDefinitionContext)_localctx).e = expression(0);
setState(121);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(119);
match(AS);
setState(120);
match(NAME);
}
}
}
break;
case 2:
_localctx = new IrreflexiveDefinitionContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(124);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(123);
((IrreflexiveDefinitionContext)_localctx).negate = match(NOT);
}
}
setState(126);
match(IRREFLEXIVE);
setState(127);
((IrreflexiveDefinitionContext)_localctx).e = expression(0);
setState(130);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(128);
match(AS);
setState(129);
match(NAME);
}
}
}
break;
case 3:
_localctx = new EmptyDefinitionContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(133);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==NOT) {
{
setState(132);
((EmptyDefinitionContext)_localctx).negate = match(NOT);
}
}
setState(135);
match(EMPTY);
setState(136);
((EmptyDefinitionContext)_localctx).e = expression(0);
setState(139);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==AS) {
{
setState(137);
match(AS);
setState(138);
match(NAME);
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LetDefinitionContext extends ParserRuleContext {
public Token n;
public ExpressionContext e;
public TerminalNode LET() { return getToken(CatParser.LET, 0); }
public TerminalNode EQ() { return getToken(CatParser.EQ, 0); }
public TerminalNode NAME() { return getToken(CatParser.NAME, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode REC() { return getToken(CatParser.REC, 0); }
public List letAndDefinition() {
return getRuleContexts(LetAndDefinitionContext.class);
}
public LetAndDefinitionContext letAndDefinition(int i) {
return getRuleContext(LetAndDefinitionContext.class,i);
}
public LetDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_letDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterLetDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitLetDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitLetDefinition(this);
else return visitor.visitChildren(this);
}
}
public final LetDefinitionContext letDefinition() throws RecognitionException {
LetDefinitionContext _localctx = new LetDefinitionContext(_ctx, getState());
enterRule(_localctx, 18, RULE_letDefinition);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(143);
match(LET);
setState(145);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==REC) {
{
setState(144);
match(REC);
}
}
setState(147);
((LetDefinitionContext)_localctx).n = match(NAME);
setState(148);
match(EQ);
setState(149);
((LetDefinitionContext)_localctx).e = expression(0);
setState(153);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AND) {
{
{
setState(150);
letAndDefinition();
}
}
setState(155);
_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 LetAndDefinitionContext extends ParserRuleContext {
public Token n;
public ExpressionContext e;
public TerminalNode AND() { return getToken(CatParser.AND, 0); }
public TerminalNode EQ() { return getToken(CatParser.EQ, 0); }
public TerminalNode NAME() { return getToken(CatParser.NAME, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public LetAndDefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_letAndDefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterLetAndDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitLetAndDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitLetAndDefinition(this);
else return visitor.visitChildren(this);
}
}
public final LetAndDefinitionContext letAndDefinition() throws RecognitionException {
LetAndDefinitionContext _localctx = new LetAndDefinitionContext(_ctx, getState());
enterRule(_localctx, 20, RULE_letAndDefinition);
try {
enterOuterAlt(_localctx, 1);
{
setState(156);
match(AND);
setState(157);
((LetAndDefinitionContext)_localctx).n = match(NAME);
setState(158);
match(EQ);
setState(159);
((LetAndDefinitionContext)_localctx).e = expression(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionContext extends ParserRuleContext {
public ExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expression; }
public ExpressionContext() { }
public void copyFrom(ExpressionContext ctx) {
super.copyFrom(ctx);
}
}
public static class ExprCartesianContext extends ExpressionContext {
public ExpressionContext e1;
public ExpressionContext e2;
public TerminalNode STAR() { return getToken(CatParser.STAR, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public ExprCartesianContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterExprCartesian(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitExprCartesian(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitExprCartesian(this);
else return visitor.visitChildren(this);
}
}
public static class ExprToidContext extends ExpressionContext {
public ExpressionContext e;
public TerminalNode LBRAC() { return getToken(CatParser.LBRAC, 0); }
public TerminalNode RBRAC() { return getToken(CatParser.RBRAC, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ExprToidContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterExprToid(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitExprToid(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitExprToid(this);
else return visitor.visitChildren(this);
}
}
public static class ExprBasicContext extends ExpressionContext {
public Token n;
public TerminalNode NAME() { return getToken(CatParser.NAME, 0); }
public ExprBasicContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterExprBasic(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitExprBasic(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitExprBasic(this);
else return visitor.visitChildren(this);
}
}
public static class ExprMinusContext extends ExpressionContext {
public ExpressionContext e1;
public ExpressionContext e2;
public TerminalNode BSLASH() { return getToken(CatParser.BSLASH, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public ExprMinusContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterExprMinus(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitExprMinus(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitExprMinus(this);
else return visitor.visitChildren(this);
}
}
public static class ExprRangeContext extends ExpressionContext {
public ExpressionContext e;
public TerminalNode RANGE() { return getToken(CatParser.RANGE, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ExprRangeContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterExprRange(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitExprRange(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitExprRange(this);
else return visitor.visitChildren(this);
}
}
public static class ExprTryWithContext extends ExpressionContext {
public ExpressionContext e;
public TerminalNode TRY() { return getToken(CatParser.TRY, 0); }
public TerminalNode WITH() { return getToken(CatParser.WITH, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public ExprTryWithContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterExprTryWith(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitExprTryWith(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitExprTryWith(this);
else return visitor.visitChildren(this);
}
}
public static class ExprDomainContext extends ExpressionContext {
public ExpressionContext e;
public TerminalNode DOMAIN() { return getToken(CatParser.DOMAIN, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ExprDomainContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterExprDomain(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitExprDomain(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitExprDomain(this);
else return visitor.visitChildren(this);
}
}
public static class ExprUnionContext extends ExpressionContext {
public ExpressionContext e1;
public ExpressionContext e2;
public TerminalNode BAR() { return getToken(CatParser.BAR, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public ExprUnionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterExprUnion(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitExprUnion(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitExprUnion(this);
else return visitor.visitChildren(this);
}
}
public static class ExprCompositionContext extends ExpressionContext {
public ExpressionContext e1;
public ExpressionContext e2;
public TerminalNode SEMI() { return getToken(CatParser.SEMI, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public ExprCompositionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterExprComposition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitExprComposition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitExprComposition(this);
else return visitor.visitChildren(this);
}
}
public static class ExprIntersectionContext extends ExpressionContext {
public ExpressionContext e1;
public ExpressionContext e2;
public TerminalNode AMP() { return getToken(CatParser.AMP, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public ExprIntersectionContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterExprIntersection(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitExprIntersection(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitExprIntersection(this);
else return visitor.visitChildren(this);
}
}
public static class ExprNullContext extends ExpressionContext {
public ExprNullContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterExprNull(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitExprNull(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitExprNull(this);
else return visitor.visitChildren(this);
}
}
public static class ExprTransitiveContext extends ExpressionContext {
public ExpressionContext e;
public TerminalNode PLUS() { return getToken(CatParser.PLUS, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode POW() { return getToken(CatParser.POW, 0); }
public ExprTransitiveContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterExprTransitive(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitExprTransitive(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitExprTransitive(this);
else return visitor.visitChildren(this);
}
}
public static class ExprComplementContext extends ExpressionContext {
public ExpressionContext e;
public TerminalNode NOT() { return getToken(CatParser.NOT, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ExprComplementContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterExprComplement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitExprComplement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitExprComplement(this);
else return visitor.visitChildren(this);
}
}
public static class ExprInverseContext extends ExpressionContext {
public ExpressionContext e;
public TerminalNode INV() { return getToken(CatParser.INV, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode POW() { return getToken(CatParser.POW, 0); }
public ExprInverseContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterExprInverse(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitExprInverse(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitExprInverse(this);
else return visitor.visitChildren(this);
}
}
public static class ExprTransRefContext extends ExpressionContext {
public ExpressionContext e;
public TerminalNode STAR() { return getToken(CatParser.STAR, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode POW() { return getToken(CatParser.POW, 0); }
public ExprTransRefContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterExprTransRef(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitExprTransRef(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitExprTransRef(this);
else return visitor.visitChildren(this);
}
}
public static class ExprContext extends ExpressionContext {
public ExpressionContext e;
public TerminalNode LPAR() { return getToken(CatParser.LPAR, 0); }
public TerminalNode RPAR() { return getToken(CatParser.RPAR, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ExprContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitExpr(this);
else return visitor.visitChildren(this);
}
}
public static class ExprOptionalContext extends ExpressionContext {
public ExpressionContext e;
public TerminalNode OPT() { return getToken(CatParser.OPT, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ExprOptionalContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterExprOptional(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitExprOptional(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitExprOptional(this);
else return visitor.visitChildren(this);
}
}
public static class ExprFunctionCallContext extends ExpressionContext {
public Token fun;
public ExpressionContext expression;
public List e = new ArrayList();
public TerminalNode LPAR() { return getToken(CatParser.LPAR, 0); }
public TerminalNode RPAR() { return getToken(CatParser.RPAR, 0); }
public TerminalNode NAME() { return getToken(CatParser.NAME, 0); }
public List expression() {
return getRuleContexts(ExpressionContext.class);
}
public ExpressionContext expression(int i) {
return getRuleContext(ExpressionContext.class,i);
}
public List COMMA() { return getTokens(CatParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(CatParser.COMMA, i);
}
public ExprFunctionCallContext(ExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).enterExprFunctionCall(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CatListener ) ((CatListener)listener).exitExprFunctionCall(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CatVisitor ) return ((CatVisitor)visitor).visitExprFunctionCall(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionContext expression() throws RecognitionException {
return expression(0);
}
private ExpressionContext expression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState);
ExpressionContext _prevctx = _localctx;
int _startState = 22;
enterRecursionRule(_localctx, 22, RULE_expression, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(201);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
case 1:
{
_localctx = new ExprComplementContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(162);
match(NOT);
setState(163);
((ExprComplementContext)_localctx).e = expression(13);
}
break;
case 2:
{
_localctx = new ExprFunctionCallContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(164);
((ExprFunctionCallContext)_localctx).fun = match(NAME);
setState(165);
match(LPAR);
setState(166);
((ExprFunctionCallContext)_localctx).expression = expression(0);
((ExprFunctionCallContext)_localctx).e.add(((ExprFunctionCallContext)_localctx).expression);
setState(171);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(167);
match(COMMA);
setState(168);
((ExprFunctionCallContext)_localctx).expression = expression(0);
((ExprFunctionCallContext)_localctx).e.add(((ExprFunctionCallContext)_localctx).expression);
}
}
setState(173);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(174);
match(RPAR);
}
break;
case 3:
{
_localctx = new ExprDomainContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(176);
match(DOMAIN);
setState(177);
((ExprDomainContext)_localctx).e = expression(7);
}
break;
case 4:
{
_localctx = new ExprRangeContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(178);
match(RANGE);
setState(179);
((ExprRangeContext)_localctx).e = expression(6);
}
break;
case 5:
{
_localctx = new ExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(180);
match(LPAR);
setState(181);
((ExprContext)_localctx).e = expression(0);
setState(182);
match(RPAR);
}
break;
case 6:
{
_localctx = new ExprBasicContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(184);
((ExprBasicContext)_localctx).n = match(NAME);
}
break;
case 7:
{
_localctx = new ExprTryWithContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(185);
match(TRY);
setState(186);
((ExprTryWithContext)_localctx).e = expression(0);
setState(187);
match(WITH);
setState(190);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) {
case 1:
{
setState(188);
match(T__0);
}
break;
case 2:
{
setState(189);
expression(0);
}
break;
}
}
break;
case 8:
{
_localctx = new ExprNullContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(195);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__0:
{
setState(192);
match(T__0);
}
break;
case T__1:
{
setState(193);
match(T__1);
setState(194);
match(T__2);
}
break;
default:
throw new NoViableAltException(this);
}
}
break;
case 9:
{
_localctx = new ExprToidContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(197);
match(LBRAC);
setState(198);
((ExprToidContext)_localctx).e = expression(0);
setState(199);
match(RBRAC);
}
break;
}
_ctx.stop = _input.LT(-1);
setState(237);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,29,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(235);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,28,_ctx) ) {
case 1:
{
_localctx = new ExprCartesianContext(new ExpressionContext(_parentctx, _parentState));
((ExprCartesianContext)_localctx).e1 = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(203);
if (!(precpred(_ctx, 18))) throw new FailedPredicateException(this, "precpred(_ctx, 18)");
setState(204);
match(STAR);
setState(205);
((ExprCartesianContext)_localctx).e2 = expression(19);
}
break;
case 2:
{
_localctx = new ExprCompositionContext(new ExpressionContext(_parentctx, _parentState));
((ExprCompositionContext)_localctx).e1 = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(206);
if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)");
setState(207);
match(SEMI);
setState(208);
((ExprCompositionContext)_localctx).e2 = expression(13);
}
break;
case 3:
{
_localctx = new ExprUnionContext(new ExpressionContext(_parentctx, _parentState));
((ExprUnionContext)_localctx).e1 = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(209);
if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)");
setState(210);
match(BAR);
setState(211);
((ExprUnionContext)_localctx).e2 = expression(12);
}
break;
case 4:
{
_localctx = new ExprMinusContext(new ExpressionContext(_parentctx, _parentState));
((ExprMinusContext)_localctx).e1 = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(212);
if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)");
setState(213);
match(BSLASH);
setState(214);
((ExprMinusContext)_localctx).e2 = expression(11);
}
break;
case 5:
{
_localctx = new ExprIntersectionContext(new ExpressionContext(_parentctx, _parentState));
((ExprIntersectionContext)_localctx).e1 = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(215);
if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)");
setState(216);
match(AMP);
setState(217);
((ExprIntersectionContext)_localctx).e2 = expression(10);
}
break;
case 6:
{
_localctx = new ExprTransRefContext(new ExpressionContext(_parentctx, _parentState));
((ExprTransRefContext)_localctx).e = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(218);
if (!(precpred(_ctx, 17))) throw new FailedPredicateException(this, "precpred(_ctx, 17)");
setState(220);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==POW) {
{
setState(219);
match(POW);
}
}
setState(222);
match(STAR);
}
break;
case 7:
{
_localctx = new ExprTransitiveContext(new ExpressionContext(_parentctx, _parentState));
((ExprTransitiveContext)_localctx).e = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(223);
if (!(precpred(_ctx, 16))) throw new FailedPredicateException(this, "precpred(_ctx, 16)");
setState(225);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==POW) {
{
setState(224);
match(POW);
}
}
setState(227);
match(PLUS);
}
break;
case 8:
{
_localctx = new ExprInverseContext(new ExpressionContext(_parentctx, _parentState));
((ExprInverseContext)_localctx).e = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(228);
if (!(precpred(_ctx, 15))) throw new FailedPredicateException(this, "precpred(_ctx, 15)");
setState(230);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==POW) {
{
setState(229);
match(POW);
}
}
setState(232);
match(INV);
}
break;
case 9:
{
_localctx = new ExprOptionalContext(new ExpressionContext(_parentctx, _parentState));
((ExprOptionalContext)_localctx).e = _prevctx;
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(233);
if (!(precpred(_ctx, 14))) throw new FailedPredicateException(this, "precpred(_ctx, 14)");
setState(234);
match(OPT);
}
break;
}
}
}
setState(239);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,29,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
switch (ruleIndex) {
case 11:
return expression_sempred((ExpressionContext)_localctx, predIndex);
}
return true;
}
private boolean expression_sempred(ExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return precpred(_ctx, 18);
case 1:
return precpred(_ctx, 12);
case 2:
return precpred(_ctx, 11);
case 3:
return precpred(_ctx, 10);
case 4:
return precpred(_ctx, 9);
case 5:
return precpred(_ctx, 17);
case 6:
return precpred(_ctx, 16);
case 7:
return precpred(_ctx, 15);
case 8:
return precpred(_ctx, 14);
}
return true;
}
public static final String _serializedATN =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3*\u00f3\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\4\13\t"+
"\13\4\f\t\f\4\r\t\r\3\2\5\2\34\n\2\3\2\3\2\3\2\3\3\5\3\"\n\3\3\3\6\3%"+
"\n\3\r\3\16\3&\3\3\5\3*\n\3\3\4\3\4\3\4\3\4\3\4\7\4\61\n\4\f\4\16\4\64"+
"\13\4\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\6\3\6"+
"\3\6\3\6\3\6\3\6\7\6I\n\6\f\6\16\6L\13\6\3\6\3\6\3\6\3\6\3\6\3\6\6\6T"+
"\n\6\r\6\16\6U\3\6\3\6\5\6Z\n\6\3\7\3\7\3\7\3\7\3\7\3\7\7\7b\n\7\f\7\16"+
"\7e\13\7\3\7\3\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b\3\b\3\t\3\t\5\ts\n\t\3\n"+
"\5\nv\n\n\3\n\3\n\3\n\3\n\5\n|\n\n\3\n\5\n\177\n\n\3\n\3\n\3\n\3\n\5\n"+
"\u0085\n\n\3\n\5\n\u0088\n\n\3\n\3\n\3\n\3\n\5\n\u008e\n\n\5\n\u0090\n"+
"\n\3\13\3\13\5\13\u0094\n\13\3\13\3\13\3\13\3\13\7\13\u009a\n\13\f\13"+
"\16\13\u009d\13\13\3\f\3\f\3\f\3\f\3\f\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r"+
"\7\r\u00ac\n\r\f\r\16\r\u00af\13\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r"+
"\3\r\3\r\3\r\3\r\3\r\3\r\3\r\5\r\u00c1\n\r\3\r\3\r\3\r\5\r\u00c6\n\r\3"+
"\r\3\r\3\r\3\r\5\r\u00cc\n\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3"+
"\r\3\r\3\r\3\r\3\r\3\r\3\r\5\r\u00df\n\r\3\r\3\r\3\r\5\r\u00e4\n\r\3\r"+
"\3\r\3\r\5\r\u00e9\n\r\3\r\3\r\3\r\7\r\u00ee\n\r\f\r\16\r\u00f1\13\r\3"+
"\r\2\3\30\16\2\4\6\b\n\f\16\20\22\24\26\30\2\2\2\u0116\2\33\3\2\2\2\4"+
"!\3\2\2\2\6\62\3\2\2\2\b\65\3\2\2\2\nY\3\2\2\2\f[\3\2\2\2\16k\3\2\2\2"+
"\20r\3\2\2\2\22\u008f\3\2\2\2\24\u0091\3\2\2\2\26\u009e\3\2\2\2\30\u00cb"+
"\3\2\2\2\32\34\5\4\3\2\33\32\3\2\2\2\33\34\3\2\2\2\34\35\3\2\2\2\35\36"+
"\5\6\4\2\36\37\7\2\2\3\37\3\3\2\2\2 \"\7%\2\2! \3\2\2\2!\"\3\2\2\2\"$"+
"\3\2\2\2#%\7&\2\2$#\3\2\2\2%&\3\2\2\2&$\3\2\2\2&\'\3\2\2\2\')\3\2\2\2"+
"(*\7%\2\2)(\3\2\2\2)*\3\2\2\2*\5\3\2\2\2+\61\5\b\5\2,\61\5\n\6\2-\61\5"+
"\f\7\2.\61\5\20\t\2/\61\5\16\b\2\60+\3\2\2\2\60,\3\2\2\2\60-\3\2\2\2\60"+
".\3\2\2\2\60/\3\2\2\2\61\64\3\2\2\2\62\60\3\2\2\2\62\63\3\2\2\2\63\7\3"+
"\2\2\2\64\62\3\2\2\2\65\66\7\f\2\2\66\67\7&\2\2\678\7 \2\28=\5\30\r\2"+
"9:\7$\2\2:<\5\30\r\2;9\3\2\2\2\3\2\2\2>@\3\2\2\2"+
"?=\3\2\2\2@A\7!\2\2A\t\3\2\2\2BC\7\6\2\2CD\7&\2\2DE\7 \2\2EJ\7&\2\2FG"+
"\7$\2\2GI\7&\2\2HF\3\2\2\2IL\3\2\2\2JH\3\2\2\2JK\3\2\2\2KM\3\2\2\2LJ\3"+
"\2\2\2MN\7!\2\2NO\7\25\2\2OZ\5\30\r\2PQ\7\6\2\2QS\7&\2\2RT\7&\2\2SR\3"+
"\2\2\2TU\3\2\2\2US\3\2\2\2UV\3\2\2\2VW\3\2\2\2WX\7\25\2\2XZ\5\30\r\2Y"+
"B\3\2\2\2YP\3\2\2\2Z\13\3\2\2\2[\\\7\r\2\2\\]\7&\2\2]^\7 \2\2^c\7&\2\2"+
"_`\7$\2\2`b\7&\2\2a_\3\2\2\2be\3\2\2\2ca\3\2\2\2cd\3\2\2\2df\3\2\2\2e"+
"c\3\2\2\2fg\7!\2\2gh\7\25\2\2hi\5\6\4\2ij\7\16\2\2j\r\3\2\2\2kl\7\17\2"+
"\2lm\7%\2\2mn\7&\2\2no\7%\2\2o\17\3\2\2\2ps\5\22\n\2qs\5\24\13\2rp\3\2"+
"\2\2rq\3\2\2\2s\21\3\2\2\2tv\7\32\2\2ut\3\2\2\2uv\3\2\2\2vw\3\2\2\2wx"+
"\7\20\2\2x{\5\30\r\2yz\7\t\2\2z|\7&\2\2{y\3\2\2\2{|\3\2\2\2|\u0090\3\2"+
"\2\2}\177\7\32\2\2~}\3\2\2\2~\177\3\2\2\2\177\u0080\3\2\2\2\u0080\u0081"+
"\7\21\2\2\u0081\u0084\5\30\r\2\u0082\u0083\7\t\2\2\u0083\u0085\7&\2\2"+
"\u0084\u0082\3\2\2\2\u0084\u0085\3\2\2\2\u0085\u0090\3\2\2\2\u0086\u0088"+
"\7\32\2\2\u0087\u0086\3\2\2\2\u0087\u0088\3\2\2\2\u0088\u0089\3\2\2\2"+
"\u0089\u008a\7\22\2\2\u008a\u008d\5\30\r\2\u008b\u008c\7\t\2\2\u008c\u008e"+
"\7&\2\2\u008d\u008b\3\2\2\2\u008d\u008e\3\2\2\2\u008e\u0090\3\2\2\2\u008f"+
"u\3\2\2\2\u008f~\3\2\2\2\u008f\u0087\3\2\2\2\u0090\23\3\2\2\2\u0091\u0093"+
"\7\6\2\2\u0092\u0094\7\7\2\2\u0093\u0092\3\2\2\2\u0093\u0094\3\2\2\2\u0094"+
"\u0095\3\2\2\2\u0095\u0096\7&\2\2\u0096\u0097\7\25\2\2\u0097\u009b\5\30"+
"\r\2\u0098\u009a\5\26\f\2\u0099\u0098\3\2\2\2\u009a\u009d\3\2\2\2\u009b"+
"\u0099\3\2\2\2\u009b\u009c\3\2\2\2\u009c\25\3\2\2\2\u009d\u009b\3\2\2"+
"\2\u009e\u009f\7\b\2\2\u009f\u00a0\7&\2\2\u00a0\u00a1\7\25\2\2\u00a1\u00a2"+
"\5\30\r\2\u00a2\27\3\2\2\2\u00a3\u00a4\b\r\1\2\u00a4\u00a5\7\32\2\2\u00a5"+
"\u00cc\5\30\r\17\u00a6\u00a7\7&\2\2\u00a7\u00a8\7 \2\2\u00a8\u00ad\5\30"+
"\r\2\u00a9\u00aa\7$\2\2\u00aa\u00ac\5\30\r\2\u00ab\u00a9\3\2\2\2\u00ac"+
"\u00af\3\2\2\2\u00ad\u00ab\3\2\2\2\u00ad\u00ae\3\2\2\2\u00ae\u00b0\3\2"+
"\2\2\u00af\u00ad\3\2\2\2\u00b0\u00b1\7!\2\2\u00b1\u00cc\3\2\2\2\u00b2"+
"\u00b3\7\23\2\2\u00b3\u00cc\5\30\r\t\u00b4\u00b5\7\24\2\2\u00b5\u00cc"+
"\5\30\r\b\u00b6\u00b7\7 \2\2\u00b7\u00b8\5\30\r\2\u00b8\u00b9\7!\2\2\u00b9"+
"\u00cc\3\2\2\2\u00ba\u00cc\7&\2\2\u00bb\u00bc\7\n\2\2\u00bc\u00bd\5\30"+
"\r\2\u00bd\u00c0\7\13\2\2\u00be\u00c1\7\3\2\2\u00bf\u00c1\5\30\r\2\u00c0"+
"\u00be\3\2\2\2\u00c0\u00bf\3\2\2\2\u00c1\u00cc\3\2\2\2\u00c2\u00c6\7\3"+
"\2\2\u00c3\u00c4\7\4\2\2\u00c4\u00c6\7\5\2\2\u00c5\u00c2\3\2\2\2\u00c5"+
"\u00c3\3\2\2\2\u00c6\u00cc\3\2\2\2\u00c7\u00c8\7\"\2\2\u00c8\u00c9\5\30"+
"\r\2\u00c9\u00ca\7#\2\2\u00ca\u00cc\3\2\2\2\u00cb\u00a3\3\2\2\2\u00cb"+
"\u00a6\3\2\2\2\u00cb\u00b2\3\2\2\2\u00cb\u00b4\3\2\2\2\u00cb\u00b6\3\2"+
"\2\2\u00cb\u00ba\3\2\2\2\u00cb\u00bb\3\2\2\2\u00cb\u00c5\3\2\2\2\u00cb"+
"\u00c7\3\2\2\2\u00cc\u00ef\3\2\2\2\u00cd\u00ce\f\24\2\2\u00ce\u00cf\7"+
"\26\2\2\u00cf\u00ee\5\30\r\25\u00d0\u00d1\f\16\2\2\u00d1\u00d2\7\35\2"+
"\2\u00d2\u00ee\5\30\r\17\u00d3\u00d4\f\r\2\2\u00d4\u00d5\7\34\2\2\u00d5"+
"\u00ee\5\30\r\16\u00d6\u00d7\f\f\2\2\u00d7\u00d8\7\36\2\2\u00d8\u00ee"+
"\5\30\r\r\u00d9\u00da\f\13\2\2\u00da\u00db\7\33\2\2\u00db\u00ee\5\30\r"+
"\f\u00dc\u00de\f\23\2\2\u00dd\u00df\7\37\2\2\u00de\u00dd\3\2\2\2\u00de"+
"\u00df\3\2\2\2\u00df\u00e0\3\2\2\2\u00e0\u00ee\7\26\2\2\u00e1\u00e3\f"+
"\22\2\2\u00e2\u00e4\7\37\2\2\u00e3\u00e2\3\2\2\2\u00e3\u00e4\3\2\2\2\u00e4"+
"\u00e5\3\2\2\2\u00e5\u00ee\7\27\2\2\u00e6\u00e8\f\21\2\2\u00e7\u00e9\7"+
"\37\2\2\u00e8\u00e7\3\2\2\2\u00e8\u00e9\3\2\2\2\u00e9\u00ea\3\2\2\2\u00ea"+
"\u00ee\7\31\2\2\u00eb\u00ec\f\20\2\2\u00ec\u00ee\7\30\2\2\u00ed\u00cd"+
"\3\2\2\2\u00ed\u00d0\3\2\2\2\u00ed\u00d3\3\2\2\2\u00ed\u00d6\3\2\2\2\u00ed"+
"\u00d9\3\2\2\2\u00ed\u00dc\3\2\2\2\u00ed\u00e1\3\2\2\2\u00ed\u00e6\3\2"+
"\2\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\31\3\2\2\2\u00f1\u00ef\3\2\2\2 \33!&)\60\62=JUYc"+
"ru{~\u0084\u0087\u008d\u008f\u0093\u009b\u00ad\u00c0\u00c5\u00cb\u00de"+
"\u00e3\u00e8\u00ed\u00ef";
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);
}
}
}