hu.bme.mit.theta.cfa.dsl.gen.CfaDslParser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of theta-cfa Show documentation
Show all versions of theta-cfa Show documentation
Cfa subproject in the Theta model checking framework
// Generated from CfaDsl.g4 by ANTLR 4.9.2
package hu.bme.mit.theta.cfa.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 CfaDslParser 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
VAR=1, MAIN=2, PROCESS=3, INIT=4, FINAL=5, ERROR=6, LOC=7, BOOLTYPE=8,
INTTYPE=9, RATTYPE=10, BVTYPE=11, FPTYPE=12, IF=13, THEN=14, ELSE=15,
IFF=16, IMPLY=17, FORALL=18, EXISTS=19, OR=20, AND=21, XOR=22, NOT=23,
EQ=24, NEQ=25, LT=26, LEQ=27, GT=28, GEQ=29, PLUS=30, MINUS=31, MUL=32,
DIV=33, MOD=34, REM=35, PERCENT=36, BV_CONCAT=37, BV_ZERO_EXTEND=38, BV_SIGN_EXTEND=39,
BV_ADD=40, BV_SUB=41, BV_POS=42, BV_NEG=43, BV_MUL=44, BV_UDIV=45, BV_SDIV=46,
BV_SMOD=47, BV_UREM=48, BV_SREM=49, BV_OR=50, BV_AND=51, BV_XOR=52, BV_NOT=53,
BV_SHL=54, BV_ASHR=55, BV_LSHR=56, BV_ROL=57, BV_ROR=58, BV_ULT=59, BV_ULE=60,
BV_UGT=61, BV_UGE=62, BV_SLT=63, BV_SLE=64, BV_SGT=65, BV_SGE=66, FP_ABS=67,
FP_FROM_BV=68, FP_IS_NAN=69, FPMAX=70, FPMIN=71, FPREM=72, FPROUNDTOINT=73,
FPSQRT=74, FPTOBV=75, FPTOFP=76, FPSUB=77, FPADD=78, FPMUL=79, FPDIV=80,
FPPOS=81, FPNEG=82, TRUE=83, BV_TYPE_DECL=84, SIGNEDNESS=85, FP_TYPE_DECL=86,
FP_ROUNDINGMODE=87, FALSE=88, DEFAULT=89, ASSIGN=90, HAVOC=91, ASSUME=92,
RETURN=93, BV=94, INT=95, NAT=96, SIGN=97, DOT=98, ID=99, UNDERSCORE=100,
DIGIT=101, LETTER=102, LPAREN=103, RPAREN=104, LBRACK=105, RBRACK=106,
LBRAC=107, RBRAC=108, COMMA=109, COLON=110, SEMICOLON=111, QUOT=112, LARROW=113,
RARROW=114, WS=115, COMMENT=116, LINE_COMMENT=117;
public static final int
RULE_spec = 0, RULE_varDecl = 1, RULE_procDecl = 2, RULE_loc = 3, RULE_edge = 4,
RULE_decl = 5, RULE_declList = 6, RULE_type = 7, RULE_typeList = 8, RULE_boolType = 9,
RULE_intType = 10, RULE_ratType = 11, RULE_funcType = 12, RULE_arrayType = 13,
RULE_bvType = 14, RULE_fpType = 15, RULE_expr = 16, RULE_exprList = 17,
RULE_funcLitExpr = 18, RULE_iteExpr = 19, RULE_iffExpr = 20, RULE_implyExpr = 21,
RULE_quantifiedExpr = 22, RULE_forallExpr = 23, RULE_existsExpr = 24,
RULE_fpFuncExpr = 25, RULE_orExpr = 26, RULE_xorExpr = 27, RULE_andExpr = 28,
RULE_notExpr = 29, RULE_equalityExpr = 30, RULE_relationExpr = 31, RULE_bitwiseOrExpr = 32,
RULE_bitwiseXorExpr = 33, RULE_bitwiseAndExpr = 34, RULE_bitwiseShiftExpr = 35,
RULE_additiveExpr = 36, RULE_multiplicativeExpr = 37, RULE_bvConcatExpr = 38,
RULE_bvExtendExpr = 39, RULE_unaryExpr = 40, RULE_bitwiseNotExpr = 41,
RULE_accessorExpr = 42, RULE_access = 43, RULE_funcAccess = 44, RULE_arrayReadAccess = 45,
RULE_arrayWriteAccess = 46, RULE_primeAccess = 47, RULE_bvExtractAccess = 48,
RULE_primaryExpr = 49, RULE_trueExpr = 50, RULE_falseExpr = 51, RULE_intLitExpr = 52,
RULE_ratLitExpr = 53, RULE_arrLitExpr = 54, RULE_bvLitExpr = 55, RULE_fpLitExpr = 56,
RULE_idExpr = 57, RULE_parenExpr = 58, RULE_stmt = 59, RULE_stmtList = 60,
RULE_assignStmt = 61, RULE_havocStmt = 62, RULE_assumeStmt = 63, RULE_returnStmt = 64;
private static String[] makeRuleNames() {
return new String[] {
"spec", "varDecl", "procDecl", "loc", "edge", "decl", "declList", "type",
"typeList", "boolType", "intType", "ratType", "funcType", "arrayType",
"bvType", "fpType", "expr", "exprList", "funcLitExpr", "iteExpr", "iffExpr",
"implyExpr", "quantifiedExpr", "forallExpr", "existsExpr", "fpFuncExpr",
"orExpr", "xorExpr", "andExpr", "notExpr", "equalityExpr", "relationExpr",
"bitwiseOrExpr", "bitwiseXorExpr", "bitwiseAndExpr", "bitwiseShiftExpr",
"additiveExpr", "multiplicativeExpr", "bvConcatExpr", "bvExtendExpr",
"unaryExpr", "bitwiseNotExpr", "accessorExpr", "access", "funcAccess",
"arrayReadAccess", "arrayWriteAccess", "primeAccess", "bvExtractAccess",
"primaryExpr", "trueExpr", "falseExpr", "intLitExpr", "ratLitExpr", "arrLitExpr",
"bvLitExpr", "fpLitExpr", "idExpr", "parenExpr", "stmt", "stmtList",
"assignStmt", "havocStmt", "assumeStmt", "returnStmt"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, "'var'", "'main'", "'process'", "'init'", "'final'", "'error'",
"'loc'", "'bool'", "'int'", "'rat'", "'bv'", "'fp'", "'if'", "'then'",
"'else'", "'iff'", "'imply'", "'forall'", "'exists'", "'or'", "'and'",
"'xor'", "'not'", "'='", "'/='", "'<'", "'<='", "'>'", "'>='", "'+'",
"'-'", "'*'", "'/'", "'mod'", "'rem'", "'%'", null, "'bv_zero_extend'",
"'bv_sign_extend'", "'bvadd'", "'bvsub'", "'bvpos'", "'bvneg'", "'bvmul'",
"'bvudiv'", "'bvsdiv'", "'bvsmod'", "'bvurem'", "'bvsrem'", "'bvor'",
"'bvand'", "'bvxor'", "'bvnot'", "'bvshl'", "'bvashr'", "'bvlshr'", "'bvrol'",
"'bvror'", "'bvult'", "'bvule'", "'bvugt'", "'bvuge'", "'bvslt'", "'bvsle'",
"'bvsgt'", "'bvsge'", "'fpabs'", null, "'fpisnan'", "'fpmax'", "'fpmin'",
"'fprem'", null, null, null, null, null, null, null, null, null, null,
"'true'", null, null, null, null, "'false'", "'default'", "':='", "'havoc'",
"'assume'", "'return'", null, null, null, null, "'.'", null, "'_'", null,
null, "'('", "')'", "'['", "']'", "'{'", "'}'", "','", "':'", "';'",
"'''", "'<-'", "'->'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, "VAR", "MAIN", "PROCESS", "INIT", "FINAL", "ERROR", "LOC", "BOOLTYPE",
"INTTYPE", "RATTYPE", "BVTYPE", "FPTYPE", "IF", "THEN", "ELSE", "IFF",
"IMPLY", "FORALL", "EXISTS", "OR", "AND", "XOR", "NOT", "EQ", "NEQ",
"LT", "LEQ", "GT", "GEQ", "PLUS", "MINUS", "MUL", "DIV", "MOD", "REM",
"PERCENT", "BV_CONCAT", "BV_ZERO_EXTEND", "BV_SIGN_EXTEND", "BV_ADD",
"BV_SUB", "BV_POS", "BV_NEG", "BV_MUL", "BV_UDIV", "BV_SDIV", "BV_SMOD",
"BV_UREM", "BV_SREM", "BV_OR", "BV_AND", "BV_XOR", "BV_NOT", "BV_SHL",
"BV_ASHR", "BV_LSHR", "BV_ROL", "BV_ROR", "BV_ULT", "BV_ULE", "BV_UGT",
"BV_UGE", "BV_SLT", "BV_SLE", "BV_SGT", "BV_SGE", "FP_ABS", "FP_FROM_BV",
"FP_IS_NAN", "FPMAX", "FPMIN", "FPREM", "FPROUNDTOINT", "FPSQRT", "FPTOBV",
"FPTOFP", "FPSUB", "FPADD", "FPMUL", "FPDIV", "FPPOS", "FPNEG", "TRUE",
"BV_TYPE_DECL", "SIGNEDNESS", "FP_TYPE_DECL", "FP_ROUNDINGMODE", "FALSE",
"DEFAULT", "ASSIGN", "HAVOC", "ASSUME", "RETURN", "BV", "INT", "NAT",
"SIGN", "DOT", "ID", "UNDERSCORE", "DIGIT", "LETTER", "LPAREN", "RPAREN",
"LBRACK", "RBRACK", "LBRAC", "RBRAC", "COMMA", "COLON", "SEMICOLON",
"QUOT", "LARROW", "RARROW", "WS", "COMMENT", "LINE_COMMENT"
};
}
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 "CfaDsl.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public CfaDslParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class SpecContext extends ParserRuleContext {
public VarDeclContext varDecl;
public List varDecls = new ArrayList();
public ProcDeclContext procDecl;
public List procDecls = new ArrayList();
public List varDecl() {
return getRuleContexts(VarDeclContext.class);
}
public VarDeclContext varDecl(int i) {
return getRuleContext(VarDeclContext.class,i);
}
public List procDecl() {
return getRuleContexts(ProcDeclContext.class);
}
public ProcDeclContext procDecl(int i) {
return getRuleContext(ProcDeclContext.class,i);
}
public SpecContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_spec; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterSpec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitSpec(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitSpec(this);
else return visitor.visitChildren(this);
}
}
public final SpecContext spec() throws RecognitionException {
SpecContext _localctx = new SpecContext(_ctx, getState());
enterRule(_localctx, 0, RULE_spec);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(134);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << VAR) | (1L << MAIN) | (1L << PROCESS))) != 0)) {
{
setState(132);
_errHandler.sync(this);
switch (_input.LA(1)) {
case VAR:
{
setState(130);
((SpecContext)_localctx).varDecl = varDecl();
((SpecContext)_localctx).varDecls.add(((SpecContext)_localctx).varDecl);
}
break;
case MAIN:
case PROCESS:
{
setState(131);
((SpecContext)_localctx).procDecl = procDecl();
((SpecContext)_localctx).procDecls.add(((SpecContext)_localctx).procDecl);
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(136);
_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 VarDeclContext extends ParserRuleContext {
public DeclContext ddecl;
public TerminalNode VAR() { return getToken(CfaDslParser.VAR, 0); }
public DeclContext decl() {
return getRuleContext(DeclContext.class,0);
}
public VarDeclContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_varDecl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterVarDecl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitVarDecl(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitVarDecl(this);
else return visitor.visitChildren(this);
}
}
public final VarDeclContext varDecl() throws RecognitionException {
VarDeclContext _localctx = new VarDeclContext(_ctx, getState());
enterRule(_localctx, 2, RULE_varDecl);
try {
enterOuterAlt(_localctx, 1);
{
setState(137);
match(VAR);
setState(138);
((VarDeclContext)_localctx).ddecl = decl();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ProcDeclContext extends ParserRuleContext {
public Token main;
public Token id;
public DeclListContext paramDecls;
public VarDeclContext varDecl;
public List varDecls = new ArrayList();
public LocContext loc;
public List locs = new ArrayList();
public EdgeContext edge;
public List edges = new ArrayList();
public TerminalNode PROCESS() { return getToken(CfaDslParser.PROCESS, 0); }
public TerminalNode LBRAC() { return getToken(CfaDslParser.LBRAC, 0); }
public TerminalNode RBRAC() { return getToken(CfaDslParser.RBRAC, 0); }
public TerminalNode ID() { return getToken(CfaDslParser.ID, 0); }
public TerminalNode LPAREN() { return getToken(CfaDslParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(CfaDslParser.RPAREN, 0); }
public TerminalNode MAIN() { return getToken(CfaDslParser.MAIN, 0); }
public List varDecl() {
return getRuleContexts(VarDeclContext.class);
}
public VarDeclContext varDecl(int i) {
return getRuleContext(VarDeclContext.class,i);
}
public List loc() {
return getRuleContexts(LocContext.class);
}
public LocContext loc(int i) {
return getRuleContext(LocContext.class,i);
}
public List edge() {
return getRuleContexts(EdgeContext.class);
}
public EdgeContext edge(int i) {
return getRuleContext(EdgeContext.class,i);
}
public DeclListContext declList() {
return getRuleContext(DeclListContext.class,0);
}
public ProcDeclContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_procDecl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterProcDecl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitProcDecl(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitProcDecl(this);
else return visitor.visitChildren(this);
}
}
public final ProcDeclContext procDecl() throws RecognitionException {
ProcDeclContext _localctx = new ProcDeclContext(_ctx, getState());
enterRule(_localctx, 4, RULE_procDecl);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(141);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==MAIN) {
{
setState(140);
((ProcDeclContext)_localctx).main = match(MAIN);
}
}
setState(143);
match(PROCESS);
setState(144);
((ProcDeclContext)_localctx).id = match(ID);
setState(150);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LPAREN) {
{
setState(145);
match(LPAREN);
setState(147);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ID) {
{
setState(146);
((ProcDeclContext)_localctx).paramDecls = declList();
}
}
setState(149);
match(RPAREN);
}
}
setState(152);
match(LBRAC);
setState(158);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << VAR) | (1L << INIT) | (1L << FINAL) | (1L << ERROR) | (1L << LOC))) != 0) || _la==ID) {
{
setState(156);
_errHandler.sync(this);
switch (_input.LA(1)) {
case VAR:
{
setState(153);
((ProcDeclContext)_localctx).varDecl = varDecl();
((ProcDeclContext)_localctx).varDecls.add(((ProcDeclContext)_localctx).varDecl);
}
break;
case INIT:
case FINAL:
case ERROR:
case LOC:
{
setState(154);
((ProcDeclContext)_localctx).loc = loc();
((ProcDeclContext)_localctx).locs.add(((ProcDeclContext)_localctx).loc);
}
break;
case ID:
{
setState(155);
((ProcDeclContext)_localctx).edge = edge();
((ProcDeclContext)_localctx).edges.add(((ProcDeclContext)_localctx).edge);
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(160);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(161);
match(RBRAC);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LocContext extends ParserRuleContext {
public Token init;
public Token finall;
public Token error;
public Token id;
public TerminalNode LOC() { return getToken(CfaDslParser.LOC, 0); }
public TerminalNode ID() { return getToken(CfaDslParser.ID, 0); }
public TerminalNode INIT() { return getToken(CfaDslParser.INIT, 0); }
public TerminalNode FINAL() { return getToken(CfaDslParser.FINAL, 0); }
public TerminalNode ERROR() { return getToken(CfaDslParser.ERROR, 0); }
public LocContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_loc; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterLoc(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitLoc(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitLoc(this);
else return visitor.visitChildren(this);
}
}
public final LocContext loc() throws RecognitionException {
LocContext _localctx = new LocContext(_ctx, getState());
enterRule(_localctx, 6, RULE_loc);
try {
enterOuterAlt(_localctx, 1);
{
setState(166);
_errHandler.sync(this);
switch (_input.LA(1)) {
case INIT:
{
setState(163);
((LocContext)_localctx).init = match(INIT);
}
break;
case FINAL:
{
setState(164);
((LocContext)_localctx).finall = match(FINAL);
}
break;
case ERROR:
{
setState(165);
((LocContext)_localctx).error = match(ERROR);
}
break;
case LOC:
break;
default:
break;
}
setState(168);
match(LOC);
setState(169);
((LocContext)_localctx).id = match(ID);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EdgeContext extends ParserRuleContext {
public Token source;
public Token target;
public StmtContext stmt;
public List stmts = new ArrayList();
public TerminalNode RARROW() { return getToken(CfaDslParser.RARROW, 0); }
public List ID() { return getTokens(CfaDslParser.ID); }
public TerminalNode ID(int i) {
return getToken(CfaDslParser.ID, i);
}
public TerminalNode LBRAC() { return getToken(CfaDslParser.LBRAC, 0); }
public TerminalNode RBRAC() { return getToken(CfaDslParser.RBRAC, 0); }
public List stmt() {
return getRuleContexts(StmtContext.class);
}
public StmtContext stmt(int i) {
return getRuleContext(StmtContext.class,i);
}
public EdgeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_edge; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterEdge(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitEdge(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitEdge(this);
else return visitor.visitChildren(this);
}
}
public final EdgeContext edge() throws RecognitionException {
EdgeContext _localctx = new EdgeContext(_ctx, getState());
enterRule(_localctx, 8, RULE_edge);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(171);
((EdgeContext)_localctx).source = match(ID);
setState(172);
match(RARROW);
setState(173);
((EdgeContext)_localctx).target = match(ID);
setState(182);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LBRAC) {
{
setState(174);
match(LBRAC);
setState(178);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 91)) & ~0x3f) == 0 && ((1L << (_la - 91)) & ((1L << (HAVOC - 91)) | (1L << (ASSUME - 91)) | (1L << (RETURN - 91)) | (1L << (ID - 91)))) != 0)) {
{
{
setState(175);
((EdgeContext)_localctx).stmt = stmt();
((EdgeContext)_localctx).stmts.add(((EdgeContext)_localctx).stmt);
}
}
setState(180);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(181);
match(RBRAC);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeclContext extends ParserRuleContext {
public Token name;
public TypeContext ttype;
public TerminalNode COLON() { return getToken(CfaDslParser.COLON, 0); }
public TerminalNode ID() { return getToken(CfaDslParser.ID, 0); }
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public DeclContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_decl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterDecl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitDecl(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitDecl(this);
else return visitor.visitChildren(this);
}
}
public final DeclContext decl() throws RecognitionException {
DeclContext _localctx = new DeclContext(_ctx, getState());
enterRule(_localctx, 10, RULE_decl);
try {
enterOuterAlt(_localctx, 1);
{
setState(184);
((DeclContext)_localctx).name = match(ID);
setState(185);
match(COLON);
setState(186);
((DeclContext)_localctx).ttype = type();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeclListContext extends ParserRuleContext {
public DeclContext decl;
public List decls = new ArrayList();
public List decl() {
return getRuleContexts(DeclContext.class);
}
public DeclContext decl(int i) {
return getRuleContext(DeclContext.class,i);
}
public List COMMA() { return getTokens(CfaDslParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(CfaDslParser.COMMA, i);
}
public DeclListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterDeclList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitDeclList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitDeclList(this);
else return visitor.visitChildren(this);
}
}
public final DeclListContext declList() throws RecognitionException {
DeclListContext _localctx = new DeclListContext(_ctx, getState());
enterRule(_localctx, 12, RULE_declList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
{
setState(188);
((DeclListContext)_localctx).decl = decl();
((DeclListContext)_localctx).decls.add(((DeclListContext)_localctx).decl);
}
setState(193);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(189);
match(COMMA);
setState(190);
((DeclListContext)_localctx).decl = decl();
((DeclListContext)_localctx).decls.add(((DeclListContext)_localctx).decl);
}
}
setState(195);
_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 TypeContext extends ParserRuleContext {
public BoolTypeContext boolType() {
return getRuleContext(BoolTypeContext.class,0);
}
public IntTypeContext intType() {
return getRuleContext(IntTypeContext.class,0);
}
public RatTypeContext ratType() {
return getRuleContext(RatTypeContext.class,0);
}
public FuncTypeContext funcType() {
return getRuleContext(FuncTypeContext.class,0);
}
public ArrayTypeContext arrayType() {
return getRuleContext(ArrayTypeContext.class,0);
}
public BvTypeContext bvType() {
return getRuleContext(BvTypeContext.class,0);
}
public FpTypeContext fpType() {
return getRuleContext(FpTypeContext.class,0);
}
public TypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_type; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitType(this);
else return visitor.visitChildren(this);
}
}
public final TypeContext type() throws RecognitionException {
TypeContext _localctx = new TypeContext(_ctx, getState());
enterRule(_localctx, 14, RULE_type);
try {
setState(203);
_errHandler.sync(this);
switch (_input.LA(1)) {
case BOOLTYPE:
enterOuterAlt(_localctx, 1);
{
setState(196);
boolType();
}
break;
case INTTYPE:
enterOuterAlt(_localctx, 2);
{
setState(197);
intType();
}
break;
case RATTYPE:
enterOuterAlt(_localctx, 3);
{
setState(198);
ratType();
}
break;
case LPAREN:
enterOuterAlt(_localctx, 4);
{
setState(199);
funcType();
}
break;
case LBRACK:
enterOuterAlt(_localctx, 5);
{
setState(200);
arrayType();
}
break;
case BVTYPE:
enterOuterAlt(_localctx, 6);
{
setState(201);
bvType();
}
break;
case FPTYPE:
enterOuterAlt(_localctx, 7);
{
setState(202);
fpType();
}
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 TypeListContext extends ParserRuleContext {
public TypeContext type;
public List types = new ArrayList();
public List type() {
return getRuleContexts(TypeContext.class);
}
public TypeContext type(int i) {
return getRuleContext(TypeContext.class,i);
}
public List COMMA() { return getTokens(CfaDslParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(CfaDslParser.COMMA, i);
}
public TypeListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterTypeList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitTypeList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitTypeList(this);
else return visitor.visitChildren(this);
}
}
public final TypeListContext typeList() throws RecognitionException {
TypeListContext _localctx = new TypeListContext(_ctx, getState());
enterRule(_localctx, 16, RULE_typeList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
{
setState(205);
((TypeListContext)_localctx).type = type();
((TypeListContext)_localctx).types.add(((TypeListContext)_localctx).type);
}
setState(210);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(206);
match(COMMA);
setState(207);
((TypeListContext)_localctx).type = type();
((TypeListContext)_localctx).types.add(((TypeListContext)_localctx).type);
}
}
setState(212);
_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 BoolTypeContext extends ParserRuleContext {
public TerminalNode BOOLTYPE() { return getToken(CfaDslParser.BOOLTYPE, 0); }
public BoolTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_boolType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterBoolType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitBoolType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitBoolType(this);
else return visitor.visitChildren(this);
}
}
public final BoolTypeContext boolType() throws RecognitionException {
BoolTypeContext _localctx = new BoolTypeContext(_ctx, getState());
enterRule(_localctx, 18, RULE_boolType);
try {
enterOuterAlt(_localctx, 1);
{
setState(213);
match(BOOLTYPE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IntTypeContext extends ParserRuleContext {
public TerminalNode INTTYPE() { return getToken(CfaDslParser.INTTYPE, 0); }
public IntTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_intType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterIntType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitIntType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitIntType(this);
else return visitor.visitChildren(this);
}
}
public final IntTypeContext intType() throws RecognitionException {
IntTypeContext _localctx = new IntTypeContext(_ctx, getState());
enterRule(_localctx, 20, RULE_intType);
try {
enterOuterAlt(_localctx, 1);
{
setState(215);
match(INTTYPE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RatTypeContext extends ParserRuleContext {
public TerminalNode RATTYPE() { return getToken(CfaDslParser.RATTYPE, 0); }
public RatTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ratType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterRatType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitRatType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitRatType(this);
else return visitor.visitChildren(this);
}
}
public final RatTypeContext ratType() throws RecognitionException {
RatTypeContext _localctx = new RatTypeContext(_ctx, getState());
enterRule(_localctx, 22, RULE_ratType);
try {
enterOuterAlt(_localctx, 1);
{
setState(217);
match(RATTYPE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FuncTypeContext extends ParserRuleContext {
public TypeListContext paramTypes;
public TypeContext returnType;
public TerminalNode LPAREN() { return getToken(CfaDslParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(CfaDslParser.RPAREN, 0); }
public TerminalNode RARROW() { return getToken(CfaDslParser.RARROW, 0); }
public TypeListContext typeList() {
return getRuleContext(TypeListContext.class,0);
}
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public FuncTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_funcType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterFuncType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitFuncType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitFuncType(this);
else return visitor.visitChildren(this);
}
}
public final FuncTypeContext funcType() throws RecognitionException {
FuncTypeContext _localctx = new FuncTypeContext(_ctx, getState());
enterRule(_localctx, 24, RULE_funcType);
try {
enterOuterAlt(_localctx, 1);
{
setState(219);
match(LPAREN);
setState(220);
((FuncTypeContext)_localctx).paramTypes = typeList();
setState(221);
match(RPAREN);
setState(222);
match(RARROW);
setState(223);
((FuncTypeContext)_localctx).returnType = type();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArrayTypeContext extends ParserRuleContext {
public TypeContext indexType;
public TypeContext elemType;
public TerminalNode LBRACK() { return getToken(CfaDslParser.LBRACK, 0); }
public TerminalNode RBRACK() { return getToken(CfaDslParser.RBRACK, 0); }
public TerminalNode RARROW() { return getToken(CfaDslParser.RARROW, 0); }
public List type() {
return getRuleContexts(TypeContext.class);
}
public TypeContext type(int i) {
return getRuleContext(TypeContext.class,i);
}
public ArrayTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arrayType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterArrayType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitArrayType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitArrayType(this);
else return visitor.visitChildren(this);
}
}
public final ArrayTypeContext arrayType() throws RecognitionException {
ArrayTypeContext _localctx = new ArrayTypeContext(_ctx, getState());
enterRule(_localctx, 26, RULE_arrayType);
try {
enterOuterAlt(_localctx, 1);
{
setState(225);
match(LBRACK);
setState(226);
((ArrayTypeContext)_localctx).indexType = type();
setState(227);
match(RBRACK);
setState(228);
match(RARROW);
setState(229);
((ArrayTypeContext)_localctx).elemType = type();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BvTypeContext extends ParserRuleContext {
public Token size;
public TerminalNode BVTYPE() { return getToken(CfaDslParser.BVTYPE, 0); }
public TerminalNode LBRACK() { return getToken(CfaDslParser.LBRACK, 0); }
public TerminalNode RBRACK() { return getToken(CfaDslParser.RBRACK, 0); }
public TerminalNode INT() { return getToken(CfaDslParser.INT, 0); }
public BvTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bvType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterBvType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitBvType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitBvType(this);
else return visitor.visitChildren(this);
}
}
public final BvTypeContext bvType() throws RecognitionException {
BvTypeContext _localctx = new BvTypeContext(_ctx, getState());
enterRule(_localctx, 28, RULE_bvType);
try {
enterOuterAlt(_localctx, 1);
{
setState(231);
match(BVTYPE);
setState(232);
match(LBRACK);
setState(233);
((BvTypeContext)_localctx).size = match(INT);
setState(234);
match(RBRACK);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FpTypeContext extends ParserRuleContext {
public TerminalNode FPTYPE() { return getToken(CfaDslParser.FPTYPE, 0); }
public TerminalNode FP_TYPE_DECL() { return getToken(CfaDslParser.FP_TYPE_DECL, 0); }
public FpTypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fpType; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterFpType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitFpType(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitFpType(this);
else return visitor.visitChildren(this);
}
}
public final FpTypeContext fpType() throws RecognitionException {
FpTypeContext _localctx = new FpTypeContext(_ctx, getState());
enterRule(_localctx, 30, RULE_fpType);
try {
enterOuterAlt(_localctx, 1);
{
setState(236);
match(FPTYPE);
setState(237);
match(FP_TYPE_DECL);
}
}
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 FuncLitExprContext funcLitExpr() {
return getRuleContext(FuncLitExprContext.class,0);
}
public ExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitExpr(this);
else return visitor.visitChildren(this);
}
}
public final ExprContext expr() throws RecognitionException {
ExprContext _localctx = new ExprContext(_ctx, getState());
enterRule(_localctx, 32, RULE_expr);
try {
enterOuterAlt(_localctx, 1);
{
setState(239);
funcLitExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExprListContext extends ParserRuleContext {
public ExprContext expr;
public List exprs = new ArrayList();
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public List COMMA() { return getTokens(CfaDslParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(CfaDslParser.COMMA, i);
}
public ExprListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exprList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterExprList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitExprList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitExprList(this);
else return visitor.visitChildren(this);
}
}
public final ExprListContext exprList() throws RecognitionException {
ExprListContext _localctx = new ExprListContext(_ctx, getState());
enterRule(_localctx, 34, RULE_exprList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
{
setState(241);
((ExprListContext)_localctx).expr = expr();
((ExprListContext)_localctx).exprs.add(((ExprListContext)_localctx).expr);
}
setState(246);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==COMMA) {
{
{
setState(242);
match(COMMA);
setState(243);
((ExprListContext)_localctx).expr = expr();
((ExprListContext)_localctx).exprs.add(((ExprListContext)_localctx).expr);
}
}
setState(248);
_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 FuncLitExprContext extends ParserRuleContext {
public DeclListContext paramDecls;
public FuncLitExprContext result;
public IteExprContext iteExpr() {
return getRuleContext(IteExprContext.class,0);
}
public TerminalNode LPAREN() { return getToken(CfaDslParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(CfaDslParser.RPAREN, 0); }
public TerminalNode RARROW() { return getToken(CfaDslParser.RARROW, 0); }
public FuncLitExprContext funcLitExpr() {
return getRuleContext(FuncLitExprContext.class,0);
}
public DeclListContext declList() {
return getRuleContext(DeclListContext.class,0);
}
public FuncLitExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_funcLitExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterFuncLitExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitFuncLitExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitFuncLitExpr(this);
else return visitor.visitChildren(this);
}
}
public final FuncLitExprContext funcLitExpr() throws RecognitionException {
FuncLitExprContext _localctx = new FuncLitExprContext(_ctx, getState());
enterRule(_localctx, 36, RULE_funcLitExpr);
int _la;
try {
setState(257);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(249);
iteExpr();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(250);
match(LPAREN);
setState(252);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ID) {
{
setState(251);
((FuncLitExprContext)_localctx).paramDecls = declList();
}
}
setState(254);
match(RPAREN);
setState(255);
match(RARROW);
setState(256);
((FuncLitExprContext)_localctx).result = funcLitExpr();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IteExprContext extends ParserRuleContext {
public ExprContext cond;
public ExprContext then;
public IteExprContext elze;
public IffExprContext iffExpr() {
return getRuleContext(IffExprContext.class,0);
}
public TerminalNode IF() { return getToken(CfaDslParser.IF, 0); }
public TerminalNode THEN() { return getToken(CfaDslParser.THEN, 0); }
public TerminalNode ELSE() { return getToken(CfaDslParser.ELSE, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public IteExprContext iteExpr() {
return getRuleContext(IteExprContext.class,0);
}
public IteExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_iteExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterIteExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitIteExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitIteExpr(this);
else return visitor.visitChildren(this);
}
}
public final IteExprContext iteExpr() throws RecognitionException {
IteExprContext _localctx = new IteExprContext(_ctx, getState());
enterRule(_localctx, 38, RULE_iteExpr);
try {
setState(267);
_errHandler.sync(this);
switch (_input.LA(1)) {
case FORALL:
case EXISTS:
case NOT:
case PLUS:
case MINUS:
case BV_POS:
case BV_NEG:
case BV_NOT:
case FP_ABS:
case FP_FROM_BV:
case FP_IS_NAN:
case FPROUNDTOINT:
case FPSQRT:
case FPTOBV:
case FPTOFP:
case FPPOS:
case FPNEG:
case TRUE:
case FALSE:
case BV:
case INT:
case ID:
case LPAREN:
case LBRACK:
enterOuterAlt(_localctx, 1);
{
setState(259);
iffExpr();
}
break;
case IF:
enterOuterAlt(_localctx, 2);
{
setState(260);
match(IF);
setState(261);
((IteExprContext)_localctx).cond = expr();
setState(262);
match(THEN);
setState(263);
((IteExprContext)_localctx).then = expr();
setState(264);
match(ELSE);
setState(265);
((IteExprContext)_localctx).elze = iteExpr();
}
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 IffExprContext extends ParserRuleContext {
public ImplyExprContext leftOp;
public IffExprContext rightOp;
public ImplyExprContext implyExpr() {
return getRuleContext(ImplyExprContext.class,0);
}
public TerminalNode IFF() { return getToken(CfaDslParser.IFF, 0); }
public IffExprContext iffExpr() {
return getRuleContext(IffExprContext.class,0);
}
public IffExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_iffExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterIffExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitIffExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitIffExpr(this);
else return visitor.visitChildren(this);
}
}
public final IffExprContext iffExpr() throws RecognitionException {
IffExprContext _localctx = new IffExprContext(_ctx, getState());
enterRule(_localctx, 40, RULE_iffExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(269);
((IffExprContext)_localctx).leftOp = implyExpr();
setState(272);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IFF) {
{
setState(270);
match(IFF);
setState(271);
((IffExprContext)_localctx).rightOp = iffExpr();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ImplyExprContext extends ParserRuleContext {
public QuantifiedExprContext leftOp;
public ImplyExprContext rightOp;
public QuantifiedExprContext quantifiedExpr() {
return getRuleContext(QuantifiedExprContext.class,0);
}
public TerminalNode IMPLY() { return getToken(CfaDslParser.IMPLY, 0); }
public ImplyExprContext implyExpr() {
return getRuleContext(ImplyExprContext.class,0);
}
public ImplyExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_implyExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterImplyExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitImplyExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitImplyExpr(this);
else return visitor.visitChildren(this);
}
}
public final ImplyExprContext implyExpr() throws RecognitionException {
ImplyExprContext _localctx = new ImplyExprContext(_ctx, getState());
enterRule(_localctx, 42, RULE_implyExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(274);
((ImplyExprContext)_localctx).leftOp = quantifiedExpr();
setState(277);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==IMPLY) {
{
setState(275);
match(IMPLY);
setState(276);
((ImplyExprContext)_localctx).rightOp = implyExpr();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QuantifiedExprContext extends ParserRuleContext {
public FpFuncExprContext fpFuncExpr() {
return getRuleContext(FpFuncExprContext.class,0);
}
public ForallExprContext forallExpr() {
return getRuleContext(ForallExprContext.class,0);
}
public ExistsExprContext existsExpr() {
return getRuleContext(ExistsExprContext.class,0);
}
public QuantifiedExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_quantifiedExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterQuantifiedExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitQuantifiedExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitQuantifiedExpr(this);
else return visitor.visitChildren(this);
}
}
public final QuantifiedExprContext quantifiedExpr() throws RecognitionException {
QuantifiedExprContext _localctx = new QuantifiedExprContext(_ctx, getState());
enterRule(_localctx, 44, RULE_quantifiedExpr);
try {
setState(282);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NOT:
case PLUS:
case MINUS:
case BV_POS:
case BV_NEG:
case BV_NOT:
case FP_ABS:
case FP_FROM_BV:
case FP_IS_NAN:
case FPROUNDTOINT:
case FPSQRT:
case FPTOBV:
case FPTOFP:
case FPPOS:
case FPNEG:
case TRUE:
case FALSE:
case BV:
case INT:
case ID:
case LPAREN:
case LBRACK:
enterOuterAlt(_localctx, 1);
{
setState(279);
fpFuncExpr();
}
break;
case FORALL:
enterOuterAlt(_localctx, 2);
{
setState(280);
forallExpr();
}
break;
case EXISTS:
enterOuterAlt(_localctx, 3);
{
setState(281);
existsExpr();
}
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 ForallExprContext extends ParserRuleContext {
public DeclListContext paramDecls;
public QuantifiedExprContext op;
public TerminalNode FORALL() { return getToken(CfaDslParser.FORALL, 0); }
public TerminalNode LPAREN() { return getToken(CfaDslParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(CfaDslParser.RPAREN, 0); }
public DeclListContext declList() {
return getRuleContext(DeclListContext.class,0);
}
public QuantifiedExprContext quantifiedExpr() {
return getRuleContext(QuantifiedExprContext.class,0);
}
public ForallExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forallExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterForallExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitForallExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitForallExpr(this);
else return visitor.visitChildren(this);
}
}
public final ForallExprContext forallExpr() throws RecognitionException {
ForallExprContext _localctx = new ForallExprContext(_ctx, getState());
enterRule(_localctx, 46, RULE_forallExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(284);
match(FORALL);
setState(285);
match(LPAREN);
setState(286);
((ForallExprContext)_localctx).paramDecls = declList();
setState(287);
match(RPAREN);
setState(288);
((ForallExprContext)_localctx).op = quantifiedExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExistsExprContext extends ParserRuleContext {
public DeclListContext paramDecls;
public QuantifiedExprContext op;
public TerminalNode EXISTS() { return getToken(CfaDslParser.EXISTS, 0); }
public TerminalNode LPAREN() { return getToken(CfaDslParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(CfaDslParser.RPAREN, 0); }
public DeclListContext declList() {
return getRuleContext(DeclListContext.class,0);
}
public QuantifiedExprContext quantifiedExpr() {
return getRuleContext(QuantifiedExprContext.class,0);
}
public ExistsExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_existsExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterExistsExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitExistsExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitExistsExpr(this);
else return visitor.visitChildren(this);
}
}
public final ExistsExprContext existsExpr() throws RecognitionException {
ExistsExprContext _localctx = new ExistsExprContext(_ctx, getState());
enterRule(_localctx, 48, RULE_existsExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(290);
match(EXISTS);
setState(291);
match(LPAREN);
setState(292);
((ExistsExprContext)_localctx).paramDecls = declList();
setState(293);
match(RPAREN);
setState(294);
((ExistsExprContext)_localctx).op = quantifiedExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FpFuncExprContext extends ParserRuleContext {
public OrExprContext leftOp;
public Token oper;
public OrExprContext rightOp;
public List orExpr() {
return getRuleContexts(OrExprContext.class);
}
public OrExprContext orExpr(int i) {
return getRuleContext(OrExprContext.class,i);
}
public TerminalNode FPMAX() { return getToken(CfaDslParser.FPMAX, 0); }
public TerminalNode FPMIN() { return getToken(CfaDslParser.FPMIN, 0); }
public FpFuncExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fpFuncExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterFpFuncExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitFpFuncExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitFpFuncExpr(this);
else return visitor.visitChildren(this);
}
}
public final FpFuncExprContext fpFuncExpr() throws RecognitionException {
FpFuncExprContext _localctx = new FpFuncExprContext(_ctx, getState());
enterRule(_localctx, 50, RULE_fpFuncExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(296);
((FpFuncExprContext)_localctx).leftOp = orExpr();
setState(299);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==FPMAX || _la==FPMIN) {
{
setState(297);
((FpFuncExprContext)_localctx).oper = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==FPMAX || _la==FPMIN) ) {
((FpFuncExprContext)_localctx).oper = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(298);
((FpFuncExprContext)_localctx).rightOp = orExpr();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OrExprContext extends ParserRuleContext {
public XorExprContext xorExpr;
public List ops = new ArrayList();
public List xorExpr() {
return getRuleContexts(XorExprContext.class);
}
public XorExprContext xorExpr(int i) {
return getRuleContext(XorExprContext.class,i);
}
public List OR() { return getTokens(CfaDslParser.OR); }
public TerminalNode OR(int i) {
return getToken(CfaDslParser.OR, i);
}
public OrExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_orExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterOrExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitOrExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitOrExpr(this);
else return visitor.visitChildren(this);
}
}
public final OrExprContext orExpr() throws RecognitionException {
OrExprContext _localctx = new OrExprContext(_ctx, getState());
enterRule(_localctx, 52, RULE_orExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(301);
((OrExprContext)_localctx).xorExpr = xorExpr();
((OrExprContext)_localctx).ops.add(((OrExprContext)_localctx).xorExpr);
setState(306);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==OR) {
{
{
setState(302);
match(OR);
setState(303);
((OrExprContext)_localctx).xorExpr = xorExpr();
((OrExprContext)_localctx).ops.add(((OrExprContext)_localctx).xorExpr);
}
}
setState(308);
_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 XorExprContext extends ParserRuleContext {
public AndExprContext leftOp;
public XorExprContext rightOp;
public AndExprContext andExpr() {
return getRuleContext(AndExprContext.class,0);
}
public TerminalNode XOR() { return getToken(CfaDslParser.XOR, 0); }
public XorExprContext xorExpr() {
return getRuleContext(XorExprContext.class,0);
}
public XorExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_xorExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterXorExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitXorExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitXorExpr(this);
else return visitor.visitChildren(this);
}
}
public final XorExprContext xorExpr() throws RecognitionException {
XorExprContext _localctx = new XorExprContext(_ctx, getState());
enterRule(_localctx, 54, RULE_xorExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(309);
((XorExprContext)_localctx).leftOp = andExpr();
setState(312);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==XOR) {
{
setState(310);
match(XOR);
setState(311);
((XorExprContext)_localctx).rightOp = xorExpr();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AndExprContext extends ParserRuleContext {
public NotExprContext notExpr;
public List ops = new ArrayList();
public List notExpr() {
return getRuleContexts(NotExprContext.class);
}
public NotExprContext notExpr(int i) {
return getRuleContext(NotExprContext.class,i);
}
public List AND() { return getTokens(CfaDslParser.AND); }
public TerminalNode AND(int i) {
return getToken(CfaDslParser.AND, i);
}
public AndExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_andExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterAndExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitAndExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitAndExpr(this);
else return visitor.visitChildren(this);
}
}
public final AndExprContext andExpr() throws RecognitionException {
AndExprContext _localctx = new AndExprContext(_ctx, getState());
enterRule(_localctx, 56, RULE_andExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(314);
((AndExprContext)_localctx).notExpr = notExpr();
((AndExprContext)_localctx).ops.add(((AndExprContext)_localctx).notExpr);
setState(319);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AND) {
{
{
setState(315);
match(AND);
setState(316);
((AndExprContext)_localctx).notExpr = notExpr();
((AndExprContext)_localctx).ops.add(((AndExprContext)_localctx).notExpr);
}
}
setState(321);
_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 NotExprContext extends ParserRuleContext {
public EqualityExprContext op;
public EqualityExprContext equalityExpr() {
return getRuleContext(EqualityExprContext.class,0);
}
public TerminalNode NOT() { return getToken(CfaDslParser.NOT, 0); }
public NotExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_notExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterNotExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitNotExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitNotExpr(this);
else return visitor.visitChildren(this);
}
}
public final NotExprContext notExpr() throws RecognitionException {
NotExprContext _localctx = new NotExprContext(_ctx, getState());
enterRule(_localctx, 58, RULE_notExpr);
try {
setState(325);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case BV_POS:
case BV_NEG:
case BV_NOT:
case FP_ABS:
case FP_FROM_BV:
case FP_IS_NAN:
case FPROUNDTOINT:
case FPSQRT:
case FPTOBV:
case FPTOFP:
case FPPOS:
case FPNEG:
case TRUE:
case FALSE:
case BV:
case INT:
case ID:
case LPAREN:
case LBRACK:
enterOuterAlt(_localctx, 1);
{
setState(322);
equalityExpr();
}
break;
case NOT:
enterOuterAlt(_localctx, 2);
{
setState(323);
match(NOT);
setState(324);
((NotExprContext)_localctx).op = equalityExpr();
}
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 EqualityExprContext extends ParserRuleContext {
public RelationExprContext leftOp;
public Token oper;
public RelationExprContext rightOp;
public List relationExpr() {
return getRuleContexts(RelationExprContext.class);
}
public RelationExprContext relationExpr(int i) {
return getRuleContext(RelationExprContext.class,i);
}
public TerminalNode EQ() { return getToken(CfaDslParser.EQ, 0); }
public TerminalNode NEQ() { return getToken(CfaDslParser.NEQ, 0); }
public EqualityExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_equalityExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterEqualityExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitEqualityExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitEqualityExpr(this);
else return visitor.visitChildren(this);
}
}
public final EqualityExprContext equalityExpr() throws RecognitionException {
EqualityExprContext _localctx = new EqualityExprContext(_ctx, getState());
enterRule(_localctx, 60, RULE_equalityExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(327);
((EqualityExprContext)_localctx).leftOp = relationExpr();
setState(330);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==EQ || _la==NEQ) {
{
setState(328);
((EqualityExprContext)_localctx).oper = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==EQ || _la==NEQ) ) {
((EqualityExprContext)_localctx).oper = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(329);
((EqualityExprContext)_localctx).rightOp = relationExpr();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RelationExprContext extends ParserRuleContext {
public BitwiseOrExprContext leftOp;
public Token oper;
public BitwiseOrExprContext rightOp;
public List bitwiseOrExpr() {
return getRuleContexts(BitwiseOrExprContext.class);
}
public BitwiseOrExprContext bitwiseOrExpr(int i) {
return getRuleContext(BitwiseOrExprContext.class,i);
}
public TerminalNode LT() { return getToken(CfaDslParser.LT, 0); }
public TerminalNode LEQ() { return getToken(CfaDslParser.LEQ, 0); }
public TerminalNode GT() { return getToken(CfaDslParser.GT, 0); }
public TerminalNode GEQ() { return getToken(CfaDslParser.GEQ, 0); }
public TerminalNode BV_ULT() { return getToken(CfaDslParser.BV_ULT, 0); }
public TerminalNode BV_ULE() { return getToken(CfaDslParser.BV_ULE, 0); }
public TerminalNode BV_UGT() { return getToken(CfaDslParser.BV_UGT, 0); }
public TerminalNode BV_UGE() { return getToken(CfaDslParser.BV_UGE, 0); }
public TerminalNode BV_SLT() { return getToken(CfaDslParser.BV_SLT, 0); }
public TerminalNode BV_SLE() { return getToken(CfaDslParser.BV_SLE, 0); }
public TerminalNode BV_SGT() { return getToken(CfaDslParser.BV_SGT, 0); }
public TerminalNode BV_SGE() { return getToken(CfaDslParser.BV_SGE, 0); }
public RelationExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relationExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterRelationExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitRelationExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitRelationExpr(this);
else return visitor.visitChildren(this);
}
}
public final RelationExprContext relationExpr() throws RecognitionException {
RelationExprContext _localctx = new RelationExprContext(_ctx, getState());
enterRule(_localctx, 62, RULE_relationExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(332);
((RelationExprContext)_localctx).leftOp = bitwiseOrExpr();
setState(335);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 26)) & ~0x3f) == 0 && ((1L << (_la - 26)) & ((1L << (LT - 26)) | (1L << (LEQ - 26)) | (1L << (GT - 26)) | (1L << (GEQ - 26)) | (1L << (BV_ULT - 26)) | (1L << (BV_ULE - 26)) | (1L << (BV_UGT - 26)) | (1L << (BV_UGE - 26)) | (1L << (BV_SLT - 26)) | (1L << (BV_SLE - 26)) | (1L << (BV_SGT - 26)) | (1L << (BV_SGE - 26)))) != 0)) {
{
setState(333);
((RelationExprContext)_localctx).oper = _input.LT(1);
_la = _input.LA(1);
if ( !(((((_la - 26)) & ~0x3f) == 0 && ((1L << (_la - 26)) & ((1L << (LT - 26)) | (1L << (LEQ - 26)) | (1L << (GT - 26)) | (1L << (GEQ - 26)) | (1L << (BV_ULT - 26)) | (1L << (BV_ULE - 26)) | (1L << (BV_UGT - 26)) | (1L << (BV_UGE - 26)) | (1L << (BV_SLT - 26)) | (1L << (BV_SLE - 26)) | (1L << (BV_SGT - 26)) | (1L << (BV_SGE - 26)))) != 0)) ) {
((RelationExprContext)_localctx).oper = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(334);
((RelationExprContext)_localctx).rightOp = bitwiseOrExpr();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BitwiseOrExprContext extends ParserRuleContext {
public BitwiseXorExprContext leftOp;
public Token oper;
public BitwiseXorExprContext rightOp;
public List bitwiseXorExpr() {
return getRuleContexts(BitwiseXorExprContext.class);
}
public BitwiseXorExprContext bitwiseXorExpr(int i) {
return getRuleContext(BitwiseXorExprContext.class,i);
}
public TerminalNode BV_OR() { return getToken(CfaDslParser.BV_OR, 0); }
public BitwiseOrExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bitwiseOrExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterBitwiseOrExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitBitwiseOrExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitBitwiseOrExpr(this);
else return visitor.visitChildren(this);
}
}
public final BitwiseOrExprContext bitwiseOrExpr() throws RecognitionException {
BitwiseOrExprContext _localctx = new BitwiseOrExprContext(_ctx, getState());
enterRule(_localctx, 64, RULE_bitwiseOrExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(337);
((BitwiseOrExprContext)_localctx).leftOp = bitwiseXorExpr();
setState(340);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BV_OR) {
{
setState(338);
((BitwiseOrExprContext)_localctx).oper = match(BV_OR);
setState(339);
((BitwiseOrExprContext)_localctx).rightOp = bitwiseXorExpr();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BitwiseXorExprContext extends ParserRuleContext {
public BitwiseAndExprContext leftOp;
public Token oper;
public BitwiseAndExprContext rightOp;
public List bitwiseAndExpr() {
return getRuleContexts(BitwiseAndExprContext.class);
}
public BitwiseAndExprContext bitwiseAndExpr(int i) {
return getRuleContext(BitwiseAndExprContext.class,i);
}
public TerminalNode BV_XOR() { return getToken(CfaDslParser.BV_XOR, 0); }
public BitwiseXorExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bitwiseXorExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterBitwiseXorExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitBitwiseXorExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitBitwiseXorExpr(this);
else return visitor.visitChildren(this);
}
}
public final BitwiseXorExprContext bitwiseXorExpr() throws RecognitionException {
BitwiseXorExprContext _localctx = new BitwiseXorExprContext(_ctx, getState());
enterRule(_localctx, 66, RULE_bitwiseXorExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(342);
((BitwiseXorExprContext)_localctx).leftOp = bitwiseAndExpr();
setState(345);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BV_XOR) {
{
setState(343);
((BitwiseXorExprContext)_localctx).oper = match(BV_XOR);
setState(344);
((BitwiseXorExprContext)_localctx).rightOp = bitwiseAndExpr();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BitwiseAndExprContext extends ParserRuleContext {
public BitwiseShiftExprContext leftOp;
public Token oper;
public BitwiseShiftExprContext rightOp;
public List bitwiseShiftExpr() {
return getRuleContexts(BitwiseShiftExprContext.class);
}
public BitwiseShiftExprContext bitwiseShiftExpr(int i) {
return getRuleContext(BitwiseShiftExprContext.class,i);
}
public TerminalNode BV_AND() { return getToken(CfaDslParser.BV_AND, 0); }
public BitwiseAndExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bitwiseAndExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterBitwiseAndExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitBitwiseAndExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitBitwiseAndExpr(this);
else return visitor.visitChildren(this);
}
}
public final BitwiseAndExprContext bitwiseAndExpr() throws RecognitionException {
BitwiseAndExprContext _localctx = new BitwiseAndExprContext(_ctx, getState());
enterRule(_localctx, 68, RULE_bitwiseAndExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(347);
((BitwiseAndExprContext)_localctx).leftOp = bitwiseShiftExpr();
setState(350);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BV_AND) {
{
setState(348);
((BitwiseAndExprContext)_localctx).oper = match(BV_AND);
setState(349);
((BitwiseAndExprContext)_localctx).rightOp = bitwiseShiftExpr();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BitwiseShiftExprContext extends ParserRuleContext {
public AdditiveExprContext leftOp;
public Token oper;
public AdditiveExprContext rightOp;
public List additiveExpr() {
return getRuleContexts(AdditiveExprContext.class);
}
public AdditiveExprContext additiveExpr(int i) {
return getRuleContext(AdditiveExprContext.class,i);
}
public TerminalNode BV_SHL() { return getToken(CfaDslParser.BV_SHL, 0); }
public TerminalNode BV_ASHR() { return getToken(CfaDslParser.BV_ASHR, 0); }
public TerminalNode BV_LSHR() { return getToken(CfaDslParser.BV_LSHR, 0); }
public TerminalNode BV_ROL() { return getToken(CfaDslParser.BV_ROL, 0); }
public TerminalNode BV_ROR() { return getToken(CfaDslParser.BV_ROR, 0); }
public BitwiseShiftExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bitwiseShiftExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterBitwiseShiftExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitBitwiseShiftExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitBitwiseShiftExpr(this);
else return visitor.visitChildren(this);
}
}
public final BitwiseShiftExprContext bitwiseShiftExpr() throws RecognitionException {
BitwiseShiftExprContext _localctx = new BitwiseShiftExprContext(_ctx, getState());
enterRule(_localctx, 70, RULE_bitwiseShiftExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(352);
((BitwiseShiftExprContext)_localctx).leftOp = additiveExpr();
setState(355);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BV_SHL) | (1L << BV_ASHR) | (1L << BV_LSHR) | (1L << BV_ROL) | (1L << BV_ROR))) != 0)) {
{
setState(353);
((BitwiseShiftExprContext)_localctx).oper = _input.LT(1);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BV_SHL) | (1L << BV_ASHR) | (1L << BV_LSHR) | (1L << BV_ROL) | (1L << BV_ROR))) != 0)) ) {
((BitwiseShiftExprContext)_localctx).oper = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(354);
((BitwiseShiftExprContext)_localctx).rightOp = additiveExpr();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AdditiveExprContext extends ParserRuleContext {
public MultiplicativeExprContext multiplicativeExpr;
public List ops = new ArrayList();
public Token PLUS;
public List opers = new ArrayList();
public Token MINUS;
public Token BV_ADD;
public Token BV_SUB;
public Token FPADD;
public Token FPSUB;
public Token _tset914;
public List multiplicativeExpr() {
return getRuleContexts(MultiplicativeExprContext.class);
}
public MultiplicativeExprContext multiplicativeExpr(int i) {
return getRuleContext(MultiplicativeExprContext.class,i);
}
public List PLUS() { return getTokens(CfaDslParser.PLUS); }
public TerminalNode PLUS(int i) {
return getToken(CfaDslParser.PLUS, i);
}
public List MINUS() { return getTokens(CfaDslParser.MINUS); }
public TerminalNode MINUS(int i) {
return getToken(CfaDslParser.MINUS, i);
}
public List BV_ADD() { return getTokens(CfaDslParser.BV_ADD); }
public TerminalNode BV_ADD(int i) {
return getToken(CfaDslParser.BV_ADD, i);
}
public List BV_SUB() { return getTokens(CfaDslParser.BV_SUB); }
public TerminalNode BV_SUB(int i) {
return getToken(CfaDslParser.BV_SUB, i);
}
public List FPADD() { return getTokens(CfaDslParser.FPADD); }
public TerminalNode FPADD(int i) {
return getToken(CfaDslParser.FPADD, i);
}
public List FPSUB() { return getTokens(CfaDslParser.FPSUB); }
public TerminalNode FPSUB(int i) {
return getToken(CfaDslParser.FPSUB, i);
}
public AdditiveExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_additiveExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterAdditiveExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitAdditiveExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitAdditiveExpr(this);
else return visitor.visitChildren(this);
}
}
public final AdditiveExprContext additiveExpr() throws RecognitionException {
AdditiveExprContext _localctx = new AdditiveExprContext(_ctx, getState());
enterRule(_localctx, 72, RULE_additiveExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(357);
((AdditiveExprContext)_localctx).multiplicativeExpr = multiplicativeExpr();
((AdditiveExprContext)_localctx).ops.add(((AdditiveExprContext)_localctx).multiplicativeExpr);
setState(362);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 30)) & ~0x3f) == 0 && ((1L << (_la - 30)) & ((1L << (PLUS - 30)) | (1L << (MINUS - 30)) | (1L << (BV_ADD - 30)) | (1L << (BV_SUB - 30)) | (1L << (FPSUB - 30)) | (1L << (FPADD - 30)))) != 0)) {
{
{
setState(358);
((AdditiveExprContext)_localctx)._tset914 = _input.LT(1);
_la = _input.LA(1);
if ( !(((((_la - 30)) & ~0x3f) == 0 && ((1L << (_la - 30)) & ((1L << (PLUS - 30)) | (1L << (MINUS - 30)) | (1L << (BV_ADD - 30)) | (1L << (BV_SUB - 30)) | (1L << (FPSUB - 30)) | (1L << (FPADD - 30)))) != 0)) ) {
((AdditiveExprContext)_localctx)._tset914 = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
((AdditiveExprContext)_localctx).opers.add(((AdditiveExprContext)_localctx)._tset914);
setState(359);
((AdditiveExprContext)_localctx).multiplicativeExpr = multiplicativeExpr();
((AdditiveExprContext)_localctx).ops.add(((AdditiveExprContext)_localctx).multiplicativeExpr);
}
}
setState(364);
_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 MultiplicativeExprContext extends ParserRuleContext {
public BvConcatExprContext bvConcatExpr;
public List ops = new ArrayList();
public Token MUL;
public List opers = new ArrayList();
public Token DIV;
public Token MOD;
public Token REM;
public Token BV_MUL;
public Token BV_UDIV;
public Token BV_SDIV;
public Token BV_SMOD;
public Token BV_UREM;
public Token BV_SREM;
public Token FPREM;
public Token FPMUL;
public Token FPDIV;
public Token _tset957;
public List bvConcatExpr() {
return getRuleContexts(BvConcatExprContext.class);
}
public BvConcatExprContext bvConcatExpr(int i) {
return getRuleContext(BvConcatExprContext.class,i);
}
public List MUL() { return getTokens(CfaDslParser.MUL); }
public TerminalNode MUL(int i) {
return getToken(CfaDslParser.MUL, i);
}
public List DIV() { return getTokens(CfaDslParser.DIV); }
public TerminalNode DIV(int i) {
return getToken(CfaDslParser.DIV, i);
}
public List MOD() { return getTokens(CfaDslParser.MOD); }
public TerminalNode MOD(int i) {
return getToken(CfaDslParser.MOD, i);
}
public List REM() { return getTokens(CfaDslParser.REM); }
public TerminalNode REM(int i) {
return getToken(CfaDslParser.REM, i);
}
public List BV_MUL() { return getTokens(CfaDslParser.BV_MUL); }
public TerminalNode BV_MUL(int i) {
return getToken(CfaDslParser.BV_MUL, i);
}
public List BV_UDIV() { return getTokens(CfaDslParser.BV_UDIV); }
public TerminalNode BV_UDIV(int i) {
return getToken(CfaDslParser.BV_UDIV, i);
}
public List BV_SDIV() { return getTokens(CfaDslParser.BV_SDIV); }
public TerminalNode BV_SDIV(int i) {
return getToken(CfaDslParser.BV_SDIV, i);
}
public List BV_SMOD() { return getTokens(CfaDslParser.BV_SMOD); }
public TerminalNode BV_SMOD(int i) {
return getToken(CfaDslParser.BV_SMOD, i);
}
public List BV_UREM() { return getTokens(CfaDslParser.BV_UREM); }
public TerminalNode BV_UREM(int i) {
return getToken(CfaDslParser.BV_UREM, i);
}
public List BV_SREM() { return getTokens(CfaDslParser.BV_SREM); }
public TerminalNode BV_SREM(int i) {
return getToken(CfaDslParser.BV_SREM, i);
}
public List FPREM() { return getTokens(CfaDslParser.FPREM); }
public TerminalNode FPREM(int i) {
return getToken(CfaDslParser.FPREM, i);
}
public List FPMUL() { return getTokens(CfaDslParser.FPMUL); }
public TerminalNode FPMUL(int i) {
return getToken(CfaDslParser.FPMUL, i);
}
public List FPDIV() { return getTokens(CfaDslParser.FPDIV); }
public TerminalNode FPDIV(int i) {
return getToken(CfaDslParser.FPDIV, i);
}
public MultiplicativeExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_multiplicativeExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterMultiplicativeExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitMultiplicativeExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitMultiplicativeExpr(this);
else return visitor.visitChildren(this);
}
}
public final MultiplicativeExprContext multiplicativeExpr() throws RecognitionException {
MultiplicativeExprContext _localctx = new MultiplicativeExprContext(_ctx, getState());
enterRule(_localctx, 74, RULE_multiplicativeExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(365);
((MultiplicativeExprContext)_localctx).bvConcatExpr = bvConcatExpr();
((MultiplicativeExprContext)_localctx).ops.add(((MultiplicativeExprContext)_localctx).bvConcatExpr);
setState(370);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 32)) & ~0x3f) == 0 && ((1L << (_la - 32)) & ((1L << (MUL - 32)) | (1L << (DIV - 32)) | (1L << (MOD - 32)) | (1L << (REM - 32)) | (1L << (BV_MUL - 32)) | (1L << (BV_UDIV - 32)) | (1L << (BV_SDIV - 32)) | (1L << (BV_SMOD - 32)) | (1L << (BV_UREM - 32)) | (1L << (BV_SREM - 32)) | (1L << (FPREM - 32)) | (1L << (FPMUL - 32)) | (1L << (FPDIV - 32)))) != 0)) {
{
{
setState(366);
((MultiplicativeExprContext)_localctx)._tset957 = _input.LT(1);
_la = _input.LA(1);
if ( !(((((_la - 32)) & ~0x3f) == 0 && ((1L << (_la - 32)) & ((1L << (MUL - 32)) | (1L << (DIV - 32)) | (1L << (MOD - 32)) | (1L << (REM - 32)) | (1L << (BV_MUL - 32)) | (1L << (BV_UDIV - 32)) | (1L << (BV_SDIV - 32)) | (1L << (BV_SMOD - 32)) | (1L << (BV_UREM - 32)) | (1L << (BV_SREM - 32)) | (1L << (FPREM - 32)) | (1L << (FPMUL - 32)) | (1L << (FPDIV - 32)))) != 0)) ) {
((MultiplicativeExprContext)_localctx)._tset957 = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
((MultiplicativeExprContext)_localctx).opers.add(((MultiplicativeExprContext)_localctx)._tset957);
setState(367);
((MultiplicativeExprContext)_localctx).bvConcatExpr = bvConcatExpr();
((MultiplicativeExprContext)_localctx).ops.add(((MultiplicativeExprContext)_localctx).bvConcatExpr);
}
}
setState(372);
_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 BvConcatExprContext extends ParserRuleContext {
public BvExtendExprContext bvExtendExpr;
public List ops = new ArrayList();
public Token BV_CONCAT;
public List opers = new ArrayList();
public List bvExtendExpr() {
return getRuleContexts(BvExtendExprContext.class);
}
public BvExtendExprContext bvExtendExpr(int i) {
return getRuleContext(BvExtendExprContext.class,i);
}
public List BV_CONCAT() { return getTokens(CfaDslParser.BV_CONCAT); }
public TerminalNode BV_CONCAT(int i) {
return getToken(CfaDslParser.BV_CONCAT, i);
}
public BvConcatExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bvConcatExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterBvConcatExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitBvConcatExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitBvConcatExpr(this);
else return visitor.visitChildren(this);
}
}
public final BvConcatExprContext bvConcatExpr() throws RecognitionException {
BvConcatExprContext _localctx = new BvConcatExprContext(_ctx, getState());
enterRule(_localctx, 76, RULE_bvConcatExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(373);
((BvConcatExprContext)_localctx).bvExtendExpr = bvExtendExpr();
((BvConcatExprContext)_localctx).ops.add(((BvConcatExprContext)_localctx).bvExtendExpr);
setState(378);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==BV_CONCAT) {
{
{
setState(374);
((BvConcatExprContext)_localctx).BV_CONCAT = match(BV_CONCAT);
((BvConcatExprContext)_localctx).opers.add(((BvConcatExprContext)_localctx).BV_CONCAT);
setState(375);
((BvConcatExprContext)_localctx).bvExtendExpr = bvExtendExpr();
((BvConcatExprContext)_localctx).ops.add(((BvConcatExprContext)_localctx).bvExtendExpr);
}
}
setState(380);
_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 BvExtendExprContext extends ParserRuleContext {
public UnaryExprContext leftOp;
public Token oper;
public BvTypeContext rightOp;
public UnaryExprContext unaryExpr() {
return getRuleContext(UnaryExprContext.class,0);
}
public BvTypeContext bvType() {
return getRuleContext(BvTypeContext.class,0);
}
public TerminalNode BV_ZERO_EXTEND() { return getToken(CfaDslParser.BV_ZERO_EXTEND, 0); }
public TerminalNode BV_SIGN_EXTEND() { return getToken(CfaDslParser.BV_SIGN_EXTEND, 0); }
public BvExtendExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bvExtendExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterBvExtendExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitBvExtendExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitBvExtendExpr(this);
else return visitor.visitChildren(this);
}
}
public final BvExtendExprContext bvExtendExpr() throws RecognitionException {
BvExtendExprContext _localctx = new BvExtendExprContext(_ctx, getState());
enterRule(_localctx, 78, RULE_bvExtendExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(381);
((BvExtendExprContext)_localctx).leftOp = unaryExpr();
setState(384);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==BV_ZERO_EXTEND || _la==BV_SIGN_EXTEND) {
{
setState(382);
((BvExtendExprContext)_localctx).oper = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==BV_ZERO_EXTEND || _la==BV_SIGN_EXTEND) ) {
((BvExtendExprContext)_localctx).oper = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(383);
((BvExtendExprContext)_localctx).rightOp = bvType();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnaryExprContext extends ParserRuleContext {
public Token oper;
public UnaryExprContext op;
public BitwiseNotExprContext bitwiseNotExpr() {
return getRuleContext(BitwiseNotExprContext.class,0);
}
public UnaryExprContext unaryExpr() {
return getRuleContext(UnaryExprContext.class,0);
}
public TerminalNode PLUS() { return getToken(CfaDslParser.PLUS, 0); }
public TerminalNode MINUS() { return getToken(CfaDslParser.MINUS, 0); }
public TerminalNode BV_POS() { return getToken(CfaDslParser.BV_POS, 0); }
public TerminalNode BV_NEG() { return getToken(CfaDslParser.BV_NEG, 0); }
public TerminalNode FP_ABS() { return getToken(CfaDslParser.FP_ABS, 0); }
public TerminalNode FP_IS_NAN() { return getToken(CfaDslParser.FP_IS_NAN, 0); }
public TerminalNode FPROUNDTOINT() { return getToken(CfaDslParser.FPROUNDTOINT, 0); }
public TerminalNode FPSQRT() { return getToken(CfaDslParser.FPSQRT, 0); }
public TerminalNode FPTOFP() { return getToken(CfaDslParser.FPTOFP, 0); }
public TerminalNode FPTOBV() { return getToken(CfaDslParser.FPTOBV, 0); }
public TerminalNode FP_FROM_BV() { return getToken(CfaDslParser.FP_FROM_BV, 0); }
public TerminalNode FPNEG() { return getToken(CfaDslParser.FPNEG, 0); }
public TerminalNode FPPOS() { return getToken(CfaDslParser.FPPOS, 0); }
public UnaryExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unaryExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterUnaryExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitUnaryExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitUnaryExpr(this);
else return visitor.visitChildren(this);
}
}
public final UnaryExprContext unaryExpr() throws RecognitionException {
UnaryExprContext _localctx = new UnaryExprContext(_ctx, getState());
enterRule(_localctx, 80, RULE_unaryExpr);
int _la;
try {
setState(389);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(386);
bitwiseNotExpr();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(387);
((UnaryExprContext)_localctx).oper = _input.LT(1);
_la = _input.LA(1);
if ( !(((((_la - 30)) & ~0x3f) == 0 && ((1L << (_la - 30)) & ((1L << (PLUS - 30)) | (1L << (MINUS - 30)) | (1L << (BV_POS - 30)) | (1L << (BV_NEG - 30)) | (1L << (FP_ABS - 30)) | (1L << (FP_FROM_BV - 30)) | (1L << (FP_IS_NAN - 30)) | (1L << (FPROUNDTOINT - 30)) | (1L << (FPSQRT - 30)) | (1L << (FPTOBV - 30)) | (1L << (FPTOFP - 30)) | (1L << (FPPOS - 30)) | (1L << (FPNEG - 30)))) != 0)) ) {
((UnaryExprContext)_localctx).oper = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(388);
((UnaryExprContext)_localctx).op = unaryExpr();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BitwiseNotExprContext extends ParserRuleContext {
public BitwiseNotExprContext op;
public AccessorExprContext accessorExpr() {
return getRuleContext(AccessorExprContext.class,0);
}
public TerminalNode BV_NOT() { return getToken(CfaDslParser.BV_NOT, 0); }
public BitwiseNotExprContext bitwiseNotExpr() {
return getRuleContext(BitwiseNotExprContext.class,0);
}
public BitwiseNotExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bitwiseNotExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterBitwiseNotExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitBitwiseNotExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitBitwiseNotExpr(this);
else return visitor.visitChildren(this);
}
}
public final BitwiseNotExprContext bitwiseNotExpr() throws RecognitionException {
BitwiseNotExprContext _localctx = new BitwiseNotExprContext(_ctx, getState());
enterRule(_localctx, 82, RULE_bitwiseNotExpr);
try {
setState(394);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PLUS:
case MINUS:
case TRUE:
case FALSE:
case BV:
case INT:
case ID:
case LPAREN:
case LBRACK:
enterOuterAlt(_localctx, 1);
{
setState(391);
accessorExpr();
}
break;
case BV_NOT:
enterOuterAlt(_localctx, 2);
{
setState(392);
match(BV_NOT);
setState(393);
((BitwiseNotExprContext)_localctx).op = bitwiseNotExpr();
}
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 AccessorExprContext extends ParserRuleContext {
public PrimaryExprContext op;
public AccessContext access;
public List accesses = new ArrayList();
public PrimaryExprContext primaryExpr() {
return getRuleContext(PrimaryExprContext.class,0);
}
public List access() {
return getRuleContexts(AccessContext.class);
}
public AccessContext access(int i) {
return getRuleContext(AccessContext.class,i);
}
public AccessorExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_accessorExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterAccessorExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitAccessorExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitAccessorExpr(this);
else return visitor.visitChildren(this);
}
}
public final AccessorExprContext accessorExpr() throws RecognitionException {
AccessorExprContext _localctx = new AccessorExprContext(_ctx, getState());
enterRule(_localctx, 84, RULE_accessorExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(396);
((AccessorExprContext)_localctx).op = primaryExpr();
setState(400);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 103)) & ~0x3f) == 0 && ((1L << (_la - 103)) & ((1L << (LPAREN - 103)) | (1L << (LBRACK - 103)) | (1L << (QUOT - 103)))) != 0)) {
{
{
setState(397);
((AccessorExprContext)_localctx).access = access();
((AccessorExprContext)_localctx).accesses.add(((AccessorExprContext)_localctx).access);
}
}
setState(402);
_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 AccessContext extends ParserRuleContext {
public FuncAccessContext params;
public ArrayReadAccessContext readIndex;
public ArrayWriteAccessContext writeIndex;
public PrimeAccessContext prime;
public BvExtractAccessContext bvExtract;
public FuncAccessContext funcAccess() {
return getRuleContext(FuncAccessContext.class,0);
}
public ArrayReadAccessContext arrayReadAccess() {
return getRuleContext(ArrayReadAccessContext.class,0);
}
public ArrayWriteAccessContext arrayWriteAccess() {
return getRuleContext(ArrayWriteAccessContext.class,0);
}
public PrimeAccessContext primeAccess() {
return getRuleContext(PrimeAccessContext.class,0);
}
public BvExtractAccessContext bvExtractAccess() {
return getRuleContext(BvExtractAccessContext.class,0);
}
public AccessContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_access; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterAccess(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitAccess(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitAccess(this);
else return visitor.visitChildren(this);
}
}
public final AccessContext access() throws RecognitionException {
AccessContext _localctx = new AccessContext(_ctx, getState());
enterRule(_localctx, 86, RULE_access);
try {
setState(408);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(403);
((AccessContext)_localctx).params = funcAccess();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(404);
((AccessContext)_localctx).readIndex = arrayReadAccess();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(405);
((AccessContext)_localctx).writeIndex = arrayWriteAccess();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(406);
((AccessContext)_localctx).prime = primeAccess();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(407);
((AccessContext)_localctx).bvExtract = bvExtractAccess();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FuncAccessContext extends ParserRuleContext {
public ExprListContext params;
public TerminalNode LPAREN() { return getToken(CfaDslParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(CfaDslParser.RPAREN, 0); }
public ExprListContext exprList() {
return getRuleContext(ExprListContext.class,0);
}
public FuncAccessContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_funcAccess; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterFuncAccess(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitFuncAccess(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitFuncAccess(this);
else return visitor.visitChildren(this);
}
}
public final FuncAccessContext funcAccess() throws RecognitionException {
FuncAccessContext _localctx = new FuncAccessContext(_ctx, getState());
enterRule(_localctx, 88, RULE_funcAccess);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(410);
match(LPAREN);
setState(412);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IF) | (1L << FORALL) | (1L << EXISTS) | (1L << NOT) | (1L << PLUS) | (1L << MINUS) | (1L << BV_POS) | (1L << BV_NEG) | (1L << BV_NOT))) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & ((1L << (FP_ABS - 67)) | (1L << (FP_FROM_BV - 67)) | (1L << (FP_IS_NAN - 67)) | (1L << (FPROUNDTOINT - 67)) | (1L << (FPSQRT - 67)) | (1L << (FPTOBV - 67)) | (1L << (FPTOFP - 67)) | (1L << (FPPOS - 67)) | (1L << (FPNEG - 67)) | (1L << (TRUE - 67)) | (1L << (FALSE - 67)) | (1L << (BV - 67)) | (1L << (INT - 67)) | (1L << (ID - 67)) | (1L << (LPAREN - 67)) | (1L << (LBRACK - 67)))) != 0)) {
{
setState(411);
((FuncAccessContext)_localctx).params = exprList();
}
}
setState(414);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArrayReadAccessContext extends ParserRuleContext {
public ExprContext index;
public TerminalNode LBRACK() { return getToken(CfaDslParser.LBRACK, 0); }
public TerminalNode RBRACK() { return getToken(CfaDslParser.RBRACK, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public ArrayReadAccessContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arrayReadAccess; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterArrayReadAccess(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitArrayReadAccess(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitArrayReadAccess(this);
else return visitor.visitChildren(this);
}
}
public final ArrayReadAccessContext arrayReadAccess() throws RecognitionException {
ArrayReadAccessContext _localctx = new ArrayReadAccessContext(_ctx, getState());
enterRule(_localctx, 90, RULE_arrayReadAccess);
try {
enterOuterAlt(_localctx, 1);
{
setState(416);
match(LBRACK);
setState(417);
((ArrayReadAccessContext)_localctx).index = expr();
setState(418);
match(RBRACK);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArrayWriteAccessContext extends ParserRuleContext {
public ExprContext index;
public ExprContext elem;
public TerminalNode LBRACK() { return getToken(CfaDslParser.LBRACK, 0); }
public TerminalNode LARROW() { return getToken(CfaDslParser.LARROW, 0); }
public TerminalNode RBRACK() { return getToken(CfaDslParser.RBRACK, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public ArrayWriteAccessContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arrayWriteAccess; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterArrayWriteAccess(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitArrayWriteAccess(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitArrayWriteAccess(this);
else return visitor.visitChildren(this);
}
}
public final ArrayWriteAccessContext arrayWriteAccess() throws RecognitionException {
ArrayWriteAccessContext _localctx = new ArrayWriteAccessContext(_ctx, getState());
enterRule(_localctx, 92, RULE_arrayWriteAccess);
try {
enterOuterAlt(_localctx, 1);
{
setState(420);
match(LBRACK);
setState(421);
((ArrayWriteAccessContext)_localctx).index = expr();
setState(422);
match(LARROW);
setState(423);
((ArrayWriteAccessContext)_localctx).elem = expr();
setState(424);
match(RBRACK);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrimeAccessContext extends ParserRuleContext {
public TerminalNode QUOT() { return getToken(CfaDslParser.QUOT, 0); }
public PrimeAccessContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primeAccess; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterPrimeAccess(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitPrimeAccess(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitPrimeAccess(this);
else return visitor.visitChildren(this);
}
}
public final PrimeAccessContext primeAccess() throws RecognitionException {
PrimeAccessContext _localctx = new PrimeAccessContext(_ctx, getState());
enterRule(_localctx, 94, RULE_primeAccess);
try {
enterOuterAlt(_localctx, 1);
{
setState(426);
match(QUOT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BvExtractAccessContext extends ParserRuleContext {
public Token until;
public Token from;
public TerminalNode LBRACK() { return getToken(CfaDslParser.LBRACK, 0); }
public TerminalNode COLON() { return getToken(CfaDslParser.COLON, 0); }
public TerminalNode RBRACK() { return getToken(CfaDslParser.RBRACK, 0); }
public List INT() { return getTokens(CfaDslParser.INT); }
public TerminalNode INT(int i) {
return getToken(CfaDslParser.INT, i);
}
public BvExtractAccessContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bvExtractAccess; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterBvExtractAccess(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitBvExtractAccess(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitBvExtractAccess(this);
else return visitor.visitChildren(this);
}
}
public final BvExtractAccessContext bvExtractAccess() throws RecognitionException {
BvExtractAccessContext _localctx = new BvExtractAccessContext(_ctx, getState());
enterRule(_localctx, 96, RULE_bvExtractAccess);
try {
enterOuterAlt(_localctx, 1);
{
setState(428);
match(LBRACK);
setState(429);
((BvExtractAccessContext)_localctx).until = match(INT);
setState(430);
match(COLON);
setState(431);
((BvExtractAccessContext)_localctx).from = match(INT);
setState(432);
match(RBRACK);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrimaryExprContext extends ParserRuleContext {
public TrueExprContext trueExpr() {
return getRuleContext(TrueExprContext.class,0);
}
public FalseExprContext falseExpr() {
return getRuleContext(FalseExprContext.class,0);
}
public IntLitExprContext intLitExpr() {
return getRuleContext(IntLitExprContext.class,0);
}
public RatLitExprContext ratLitExpr() {
return getRuleContext(RatLitExprContext.class,0);
}
public ArrLitExprContext arrLitExpr() {
return getRuleContext(ArrLitExprContext.class,0);
}
public FpLitExprContext fpLitExpr() {
return getRuleContext(FpLitExprContext.class,0);
}
public BvLitExprContext bvLitExpr() {
return getRuleContext(BvLitExprContext.class,0);
}
public IdExprContext idExpr() {
return getRuleContext(IdExprContext.class,0);
}
public ParenExprContext parenExpr() {
return getRuleContext(ParenExprContext.class,0);
}
public PrimaryExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primaryExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterPrimaryExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitPrimaryExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitPrimaryExpr(this);
else return visitor.visitChildren(this);
}
}
public final PrimaryExprContext primaryExpr() throws RecognitionException {
PrimaryExprContext _localctx = new PrimaryExprContext(_ctx, getState());
enterRule(_localctx, 98, RULE_primaryExpr);
try {
setState(443);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(434);
trueExpr();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(435);
falseExpr();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(436);
intLitExpr();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(437);
ratLitExpr();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(438);
arrLitExpr();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(439);
fpLitExpr();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(440);
bvLitExpr();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(441);
idExpr();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(442);
parenExpr();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TrueExprContext extends ParserRuleContext {
public TerminalNode TRUE() { return getToken(CfaDslParser.TRUE, 0); }
public TrueExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_trueExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterTrueExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitTrueExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitTrueExpr(this);
else return visitor.visitChildren(this);
}
}
public final TrueExprContext trueExpr() throws RecognitionException {
TrueExprContext _localctx = new TrueExprContext(_ctx, getState());
enterRule(_localctx, 100, RULE_trueExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(445);
match(TRUE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FalseExprContext extends ParserRuleContext {
public TerminalNode FALSE() { return getToken(CfaDslParser.FALSE, 0); }
public FalseExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_falseExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterFalseExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitFalseExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitFalseExpr(this);
else return visitor.visitChildren(this);
}
}
public final FalseExprContext falseExpr() throws RecognitionException {
FalseExprContext _localctx = new FalseExprContext(_ctx, getState());
enterRule(_localctx, 102, RULE_falseExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(447);
match(FALSE);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IntLitExprContext extends ParserRuleContext {
public Token value;
public TerminalNode INT() { return getToken(CfaDslParser.INT, 0); }
public IntLitExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_intLitExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterIntLitExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitIntLitExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitIntLitExpr(this);
else return visitor.visitChildren(this);
}
}
public final IntLitExprContext intLitExpr() throws RecognitionException {
IntLitExprContext _localctx = new IntLitExprContext(_ctx, getState());
enterRule(_localctx, 104, RULE_intLitExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(449);
((IntLitExprContext)_localctx).value = match(INT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RatLitExprContext extends ParserRuleContext {
public Token num;
public Token denom;
public TerminalNode PERCENT() { return getToken(CfaDslParser.PERCENT, 0); }
public List INT() { return getTokens(CfaDslParser.INT); }
public TerminalNode INT(int i) {
return getToken(CfaDslParser.INT, i);
}
public RatLitExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ratLitExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterRatLitExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitRatLitExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitRatLitExpr(this);
else return visitor.visitChildren(this);
}
}
public final RatLitExprContext ratLitExpr() throws RecognitionException {
RatLitExprContext _localctx = new RatLitExprContext(_ctx, getState());
enterRule(_localctx, 106, RULE_ratLitExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(451);
((RatLitExprContext)_localctx).num = match(INT);
setState(452);
match(PERCENT);
setState(453);
((RatLitExprContext)_localctx).denom = match(INT);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArrLitExprContext extends ParserRuleContext {
public ExprContext expr;
public List indexExpr = new ArrayList();
public List valueExpr = new ArrayList();
public TypeContext indexType;
public ExprContext elseExpr;
public TerminalNode LBRACK() { return getToken(CfaDslParser.LBRACK, 0); }
public TerminalNode DEFAULT() { return getToken(CfaDslParser.DEFAULT, 0); }
public List LARROW() { return getTokens(CfaDslParser.LARROW); }
public TerminalNode LARROW(int i) {
return getToken(CfaDslParser.LARROW, i);
}
public TerminalNode RBRACK() { return getToken(CfaDslParser.RBRACK, 0); }
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public List COMMA() { return getTokens(CfaDslParser.COMMA); }
public TerminalNode COMMA(int i) {
return getToken(CfaDslParser.COMMA, i);
}
public TerminalNode LT() { return getToken(CfaDslParser.LT, 0); }
public TerminalNode GT() { return getToken(CfaDslParser.GT, 0); }
public TypeContext type() {
return getRuleContext(TypeContext.class,0);
}
public ArrLitExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_arrLitExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterArrLitExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitArrLitExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitArrLitExpr(this);
else return visitor.visitChildren(this);
}
}
public final ArrLitExprContext arrLitExpr() throws RecognitionException {
ArrLitExprContext _localctx = new ArrLitExprContext(_ctx, getState());
enterRule(_localctx, 108, RULE_arrLitExpr);
int _la;
try {
setState(485);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,43,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(455);
match(LBRACK);
setState(461);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(456);
((ArrLitExprContext)_localctx).expr = expr();
((ArrLitExprContext)_localctx).indexExpr.add(((ArrLitExprContext)_localctx).expr);
setState(457);
match(LARROW);
setState(458);
((ArrLitExprContext)_localctx).expr = expr();
((ArrLitExprContext)_localctx).valueExpr.add(((ArrLitExprContext)_localctx).expr);
setState(459);
match(COMMA);
}
}
setState(463);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IF) | (1L << FORALL) | (1L << EXISTS) | (1L << NOT) | (1L << PLUS) | (1L << MINUS) | (1L << BV_POS) | (1L << BV_NEG) | (1L << BV_NOT))) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & ((1L << (FP_ABS - 67)) | (1L << (FP_FROM_BV - 67)) | (1L << (FP_IS_NAN - 67)) | (1L << (FPROUNDTOINT - 67)) | (1L << (FPSQRT - 67)) | (1L << (FPTOBV - 67)) | (1L << (FPTOFP - 67)) | (1L << (FPPOS - 67)) | (1L << (FPNEG - 67)) | (1L << (TRUE - 67)) | (1L << (FALSE - 67)) | (1L << (BV - 67)) | (1L << (INT - 67)) | (1L << (ID - 67)) | (1L << (LPAREN - 67)) | (1L << (LBRACK - 67)))) != 0) );
setState(469);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LT) {
{
setState(465);
match(LT);
setState(466);
((ArrLitExprContext)_localctx).indexType = type();
setState(467);
match(GT);
}
}
setState(471);
match(DEFAULT);
setState(472);
match(LARROW);
setState(473);
((ArrLitExprContext)_localctx).elseExpr = expr();
setState(474);
match(RBRACK);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(476);
match(LBRACK);
setState(477);
match(LT);
setState(478);
((ArrLitExprContext)_localctx).indexType = type();
setState(479);
match(GT);
setState(480);
match(DEFAULT);
setState(481);
match(LARROW);
setState(482);
((ArrLitExprContext)_localctx).elseExpr = expr();
setState(483);
match(RBRACK);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BvLitExprContext extends ParserRuleContext {
public Token bv;
public TerminalNode BV() { return getToken(CfaDslParser.BV, 0); }
public BvLitExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bvLitExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterBvLitExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitBvLitExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitBvLitExpr(this);
else return visitor.visitChildren(this);
}
}
public final BvLitExprContext bvLitExpr() throws RecognitionException {
BvLitExprContext _localctx = new BvLitExprContext(_ctx, getState());
enterRule(_localctx, 110, RULE_bvLitExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(487);
((BvLitExprContext)_localctx).bv = match(BV);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FpLitExprContext extends ParserRuleContext {
public Token sig;
public List bvLitExpr() {
return getRuleContexts(BvLitExprContext.class);
}
public BvLitExprContext bvLitExpr(int i) {
return getRuleContext(BvLitExprContext.class,i);
}
public TerminalNode DOT() { return getToken(CfaDslParser.DOT, 0); }
public TerminalNode PLUS() { return getToken(CfaDslParser.PLUS, 0); }
public TerminalNode MINUS() { return getToken(CfaDslParser.MINUS, 0); }
public FpLitExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_fpLitExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterFpLitExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitFpLitExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitFpLitExpr(this);
else return visitor.visitChildren(this);
}
}
public final FpLitExprContext fpLitExpr() throws RecognitionException {
FpLitExprContext _localctx = new FpLitExprContext(_ctx, getState());
enterRule(_localctx, 112, RULE_fpLitExpr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(490);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PLUS || _la==MINUS) {
{
setState(489);
((FpLitExprContext)_localctx).sig = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==PLUS || _la==MINUS) ) {
((FpLitExprContext)_localctx).sig = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
setState(492);
bvLitExpr();
setState(493);
match(DOT);
setState(494);
bvLitExpr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IdExprContext extends ParserRuleContext {
public Token id;
public TerminalNode ID() { return getToken(CfaDslParser.ID, 0); }
public IdExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_idExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterIdExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitIdExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitIdExpr(this);
else return visitor.visitChildren(this);
}
}
public final IdExprContext idExpr() throws RecognitionException {
IdExprContext _localctx = new IdExprContext(_ctx, getState());
enterRule(_localctx, 114, RULE_idExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(496);
((IdExprContext)_localctx).id = match(ID);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParenExprContext extends ParserRuleContext {
public ExprContext op;
public TerminalNode LPAREN() { return getToken(CfaDslParser.LPAREN, 0); }
public TerminalNode RPAREN() { return getToken(CfaDslParser.RPAREN, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public ParenExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parenExpr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterParenExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitParenExpr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitParenExpr(this);
else return visitor.visitChildren(this);
}
}
public final ParenExprContext parenExpr() throws RecognitionException {
ParenExprContext _localctx = new ParenExprContext(_ctx, getState());
enterRule(_localctx, 116, RULE_parenExpr);
try {
enterOuterAlt(_localctx, 1);
{
setState(498);
match(LPAREN);
setState(499);
((ParenExprContext)_localctx).op = expr();
setState(500);
match(RPAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StmtContext extends ParserRuleContext {
public AssignStmtContext assignStmt() {
return getRuleContext(AssignStmtContext.class,0);
}
public HavocStmtContext havocStmt() {
return getRuleContext(HavocStmtContext.class,0);
}
public AssumeStmtContext assumeStmt() {
return getRuleContext(AssumeStmtContext.class,0);
}
public ReturnStmtContext returnStmt() {
return getRuleContext(ReturnStmtContext.class,0);
}
public StmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterStmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitStmt(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitStmt(this);
else return visitor.visitChildren(this);
}
}
public final StmtContext stmt() throws RecognitionException {
StmtContext _localctx = new StmtContext(_ctx, getState());
enterRule(_localctx, 118, RULE_stmt);
try {
setState(506);
_errHandler.sync(this);
switch (_input.LA(1)) {
case ID:
enterOuterAlt(_localctx, 1);
{
setState(502);
assignStmt();
}
break;
case HAVOC:
enterOuterAlt(_localctx, 2);
{
setState(503);
havocStmt();
}
break;
case ASSUME:
enterOuterAlt(_localctx, 3);
{
setState(504);
assumeStmt();
}
break;
case RETURN:
enterOuterAlt(_localctx, 4);
{
setState(505);
returnStmt();
}
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 StmtListContext extends ParserRuleContext {
public StmtContext stmt;
public List stmts = new ArrayList();
public TerminalNode SEMICOLON() { return getToken(CfaDslParser.SEMICOLON, 0); }
public List stmt() {
return getRuleContexts(StmtContext.class);
}
public StmtContext stmt(int i) {
return getRuleContext(StmtContext.class,i);
}
public StmtListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_stmtList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterStmtList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitStmtList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitStmtList(this);
else return visitor.visitChildren(this);
}
}
public final StmtListContext stmtList() throws RecognitionException {
StmtListContext _localctx = new StmtListContext(_ctx, getState());
enterRule(_localctx, 120, RULE_stmtList);
try {
enterOuterAlt(_localctx, 1);
{
{
setState(508);
((StmtListContext)_localctx).stmt = stmt();
((StmtListContext)_localctx).stmts.add(((StmtListContext)_localctx).stmt);
}
{
setState(509);
match(SEMICOLON);
setState(510);
((StmtListContext)_localctx).stmt = stmt();
((StmtListContext)_localctx).stmts.add(((StmtListContext)_localctx).stmt);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AssignStmtContext extends ParserRuleContext {
public Token lhs;
public ExprContext value;
public TerminalNode ASSIGN() { return getToken(CfaDslParser.ASSIGN, 0); }
public TerminalNode ID() { return getToken(CfaDslParser.ID, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public AssignStmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assignStmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterAssignStmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitAssignStmt(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitAssignStmt(this);
else return visitor.visitChildren(this);
}
}
public final AssignStmtContext assignStmt() throws RecognitionException {
AssignStmtContext _localctx = new AssignStmtContext(_ctx, getState());
enterRule(_localctx, 122, RULE_assignStmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(512);
((AssignStmtContext)_localctx).lhs = match(ID);
setState(513);
match(ASSIGN);
setState(514);
((AssignStmtContext)_localctx).value = expr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HavocStmtContext extends ParserRuleContext {
public Token lhs;
public TerminalNode HAVOC() { return getToken(CfaDslParser.HAVOC, 0); }
public TerminalNode ID() { return getToken(CfaDslParser.ID, 0); }
public HavocStmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_havocStmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterHavocStmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitHavocStmt(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitHavocStmt(this);
else return visitor.visitChildren(this);
}
}
public final HavocStmtContext havocStmt() throws RecognitionException {
HavocStmtContext _localctx = new HavocStmtContext(_ctx, getState());
enterRule(_localctx, 124, RULE_havocStmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(516);
match(HAVOC);
setState(517);
((HavocStmtContext)_localctx).lhs = match(ID);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AssumeStmtContext extends ParserRuleContext {
public ExprContext cond;
public TerminalNode ASSUME() { return getToken(CfaDslParser.ASSUME, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public AssumeStmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assumeStmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterAssumeStmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitAssumeStmt(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitAssumeStmt(this);
else return visitor.visitChildren(this);
}
}
public final AssumeStmtContext assumeStmt() throws RecognitionException {
AssumeStmtContext _localctx = new AssumeStmtContext(_ctx, getState());
enterRule(_localctx, 126, RULE_assumeStmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(519);
match(ASSUME);
setState(520);
((AssumeStmtContext)_localctx).cond = expr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ReturnStmtContext extends ParserRuleContext {
public ExprContext value;
public TerminalNode RETURN() { return getToken(CfaDslParser.RETURN, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public ReturnStmtContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_returnStmt; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).enterReturnStmt(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CfaDslListener ) ((CfaDslListener)listener).exitReturnStmt(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CfaDslVisitor ) return ((CfaDslVisitor)visitor).visitReturnStmt(this);
else return visitor.visitChildren(this);
}
}
public final ReturnStmtContext returnStmt() throws RecognitionException {
ReturnStmtContext _localctx = new ReturnStmtContext(_ctx, getState());
enterRule(_localctx, 128, RULE_returnStmt);
try {
enterOuterAlt(_localctx, 1);
{
setState(522);
match(RETURN);
setState(523);
((ReturnStmtContext)_localctx).value = expr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static final String _serializedATN =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3w\u0210\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\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
"\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
"\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\3\2\3\2\7\2\u0087\n\2\f\2\16\2\u008a\13"+
"\2\3\3\3\3\3\3\3\4\5\4\u0090\n\4\3\4\3\4\3\4\3\4\5\4\u0096\n\4\3\4\5\4"+
"\u0099\n\4\3\4\3\4\3\4\3\4\7\4\u009f\n\4\f\4\16\4\u00a2\13\4\3\4\3\4\3"+
"\5\3\5\3\5\5\5\u00a9\n\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\7\6\u00b3\n\6"+
"\f\6\16\6\u00b6\13\6\3\6\5\6\u00b9\n\6\3\7\3\7\3\7\3\7\3\b\3\b\3\b\7\b"+
"\u00c2\n\b\f\b\16\b\u00c5\13\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\5\t\u00ce\n"+
"\t\3\n\3\n\3\n\7\n\u00d3\n\n\f\n\16\n\u00d6\13\n\3\13\3\13\3\f\3\f\3\r"+
"\3\r\3\16\3\16\3\16\3\16\3\16\3\16\3\17\3\17\3\17\3\17\3\17\3\17\3\20"+
"\3\20\3\20\3\20\3\20\3\21\3\21\3\21\3\22\3\22\3\23\3\23\3\23\7\23\u00f7"+
"\n\23\f\23\16\23\u00fa\13\23\3\24\3\24\3\24\5\24\u00ff\n\24\3\24\3\24"+
"\3\24\5\24\u0104\n\24\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\5\25\u010e"+
"\n\25\3\26\3\26\3\26\5\26\u0113\n\26\3\27\3\27\3\27\5\27\u0118\n\27\3"+
"\30\3\30\3\30\5\30\u011d\n\30\3\31\3\31\3\31\3\31\3\31\3\31\3\32\3\32"+
"\3\32\3\32\3\32\3\32\3\33\3\33\3\33\5\33\u012e\n\33\3\34\3\34\3\34\7\34"+
"\u0133\n\34\f\34\16\34\u0136\13\34\3\35\3\35\3\35\5\35\u013b\n\35\3\36"+
"\3\36\3\36\7\36\u0140\n\36\f\36\16\36\u0143\13\36\3\37\3\37\3\37\5\37"+
"\u0148\n\37\3 \3 \3 \5 \u014d\n \3!\3!\3!\5!\u0152\n!\3\"\3\"\3\"\5\""+
"\u0157\n\"\3#\3#\3#\5#\u015c\n#\3$\3$\3$\5$\u0161\n$\3%\3%\3%\5%\u0166"+
"\n%\3&\3&\3&\7&\u016b\n&\f&\16&\u016e\13&\3\'\3\'\3\'\7\'\u0173\n\'\f"+
"\'\16\'\u0176\13\'\3(\3(\3(\7(\u017b\n(\f(\16(\u017e\13(\3)\3)\3)\5)\u0183"+
"\n)\3*\3*\3*\5*\u0188\n*\3+\3+\3+\5+\u018d\n+\3,\3,\7,\u0191\n,\f,\16"+
",\u0194\13,\3-\3-\3-\3-\3-\5-\u019b\n-\3.\3.\5.\u019f\n.\3.\3.\3/\3/\3"+
"/\3/\3\60\3\60\3\60\3\60\3\60\3\60\3\61\3\61\3\62\3\62\3\62\3\62\3\62"+
"\3\62\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63\5\63\u01be\n\63\3\64"+
"\3\64\3\65\3\65\3\66\3\66\3\67\3\67\3\67\3\67\38\38\38\38\38\38\68\u01d0"+
"\n8\r8\168\u01d1\38\38\38\38\58\u01d8\n8\38\38\38\38\38\38\38\38\38\3"+
"8\38\38\38\38\58\u01e8\n8\39\39\3:\5:\u01ed\n:\3:\3:\3:\3:\3;\3;\3<\3"+
"<\3<\3<\3=\3=\3=\3=\5=\u01fd\n=\3>\3>\3>\3>\3?\3?\3?\3?\3@\3@\3@\3A\3"+
"A\3A\3B\3B\3B\3B\2\2C\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,."+
"\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\2\13\3\2"+
"HI\3\2\32\33\4\2\34\37=D\3\28<\5\2 !*+OP\6\2\"%.\63JJQR\3\2()\7\2 !,-"+
"EGKNST\3\2 !\2\u0211\2\u0088\3\2\2\2\4\u008b\3\2\2\2\6\u008f\3\2\2\2\b"+
"\u00a8\3\2\2\2\n\u00ad\3\2\2\2\f\u00ba\3\2\2\2\16\u00be\3\2\2\2\20\u00cd"+
"\3\2\2\2\22\u00cf\3\2\2\2\24\u00d7\3\2\2\2\26\u00d9\3\2\2\2\30\u00db\3"+
"\2\2\2\32\u00dd\3\2\2\2\34\u00e3\3\2\2\2\36\u00e9\3\2\2\2 \u00ee\3\2\2"+
"\2\"\u00f1\3\2\2\2$\u00f3\3\2\2\2&\u0103\3\2\2\2(\u010d\3\2\2\2*\u010f"+
"\3\2\2\2,\u0114\3\2\2\2.\u011c\3\2\2\2\60\u011e\3\2\2\2\62\u0124\3\2\2"+
"\2\64\u012a\3\2\2\2\66\u012f\3\2\2\28\u0137\3\2\2\2:\u013c\3\2\2\2<\u0147"+
"\3\2\2\2>\u0149\3\2\2\2@\u014e\3\2\2\2B\u0153\3\2\2\2D\u0158\3\2\2\2F"+
"\u015d\3\2\2\2H\u0162\3\2\2\2J\u0167\3\2\2\2L\u016f\3\2\2\2N\u0177\3\2"+
"\2\2P\u017f\3\2\2\2R\u0187\3\2\2\2T\u018c\3\2\2\2V\u018e\3\2\2\2X\u019a"+
"\3\2\2\2Z\u019c\3\2\2\2\\\u01a2\3\2\2\2^\u01a6\3\2\2\2`\u01ac\3\2\2\2"+
"b\u01ae\3\2\2\2d\u01bd\3\2\2\2f\u01bf\3\2\2\2h\u01c1\3\2\2\2j\u01c3\3"+
"\2\2\2l\u01c5\3\2\2\2n\u01e7\3\2\2\2p\u01e9\3\2\2\2r\u01ec\3\2\2\2t\u01f2"+
"\3\2\2\2v\u01f4\3\2\2\2x\u01fc\3\2\2\2z\u01fe\3\2\2\2|\u0202\3\2\2\2~"+
"\u0206\3\2\2\2\u0080\u0209\3\2\2\2\u0082\u020c\3\2\2\2\u0084\u0087\5\4"+
"\3\2\u0085\u0087\5\6\4\2\u0086\u0084\3\2\2\2\u0086\u0085\3\2\2\2\u0087"+
"\u008a\3\2\2\2\u0088\u0086\3\2\2\2\u0088\u0089\3\2\2\2\u0089\3\3\2\2\2"+
"\u008a\u0088\3\2\2\2\u008b\u008c\7\3\2\2\u008c\u008d\5\f\7\2\u008d\5\3"+
"\2\2\2\u008e\u0090\7\4\2\2\u008f\u008e\3\2\2\2\u008f\u0090\3\2\2\2\u0090"+
"\u0091\3\2\2\2\u0091\u0092\7\5\2\2\u0092\u0098\7e\2\2\u0093\u0095\7i\2"+
"\2\u0094\u0096\5\16\b\2\u0095\u0094\3\2\2\2\u0095\u0096\3\2\2\2\u0096"+
"\u0097\3\2\2\2\u0097\u0099\7j\2\2\u0098\u0093\3\2\2\2\u0098\u0099\3\2"+
"\2\2\u0099\u009a\3\2\2\2\u009a\u00a0\7m\2\2\u009b\u009f\5\4\3\2\u009c"+
"\u009f\5\b\5\2\u009d\u009f\5\n\6\2\u009e\u009b\3\2\2\2\u009e\u009c\3\2"+
"\2\2\u009e\u009d\3\2\2\2\u009f\u00a2\3\2\2\2\u00a0\u009e\3\2\2\2\u00a0"+
"\u00a1\3\2\2\2\u00a1\u00a3\3\2\2\2\u00a2\u00a0\3\2\2\2\u00a3\u00a4\7n"+
"\2\2\u00a4\7\3\2\2\2\u00a5\u00a9\7\6\2\2\u00a6\u00a9\7\7\2\2\u00a7\u00a9"+
"\7\b\2\2\u00a8\u00a5\3\2\2\2\u00a8\u00a6\3\2\2\2\u00a8\u00a7\3\2\2\2\u00a8"+
"\u00a9\3\2\2\2\u00a9\u00aa\3\2\2\2\u00aa\u00ab\7\t\2\2\u00ab\u00ac\7e"+
"\2\2\u00ac\t\3\2\2\2\u00ad\u00ae\7e\2\2\u00ae\u00af\7t\2\2\u00af\u00b8"+
"\7e\2\2\u00b0\u00b4\7m\2\2\u00b1\u00b3\5x=\2\u00b2\u00b1\3\2\2\2\u00b3"+
"\u00b6\3\2\2\2\u00b4\u00b2\3\2\2\2\u00b4\u00b5\3\2\2\2\u00b5\u00b7\3\2"+
"\2\2\u00b6\u00b4\3\2\2\2\u00b7\u00b9\7n\2\2\u00b8\u00b0\3\2\2\2\u00b8"+
"\u00b9\3\2\2\2\u00b9\13\3\2\2\2\u00ba\u00bb\7e\2\2\u00bb\u00bc\7p\2\2"+
"\u00bc\u00bd\5\20\t\2\u00bd\r\3\2\2\2\u00be\u00c3\5\f\7\2\u00bf\u00c0"+
"\7o\2\2\u00c0\u00c2\5\f\7\2\u00c1\u00bf\3\2\2\2\u00c2\u00c5\3\2\2\2\u00c3"+
"\u00c1\3\2\2\2\u00c3\u00c4\3\2\2\2\u00c4\17\3\2\2\2\u00c5\u00c3\3\2\2"+
"\2\u00c6\u00ce\5\24\13\2\u00c7\u00ce\5\26\f\2\u00c8\u00ce\5\30\r\2\u00c9"+
"\u00ce\5\32\16\2\u00ca\u00ce\5\34\17\2\u00cb\u00ce\5\36\20\2\u00cc\u00ce"+
"\5 \21\2\u00cd\u00c6\3\2\2\2\u00cd\u00c7\3\2\2\2\u00cd\u00c8\3\2\2\2\u00cd"+
"\u00c9\3\2\2\2\u00cd\u00ca\3\2\2\2\u00cd\u00cb\3\2\2\2\u00cd\u00cc\3\2"+
"\2\2\u00ce\21\3\2\2\2\u00cf\u00d4\5\20\t\2\u00d0\u00d1\7o\2\2\u00d1\u00d3"+
"\5\20\t\2\u00d2\u00d0\3\2\2\2\u00d3\u00d6\3\2\2\2\u00d4\u00d2\3\2\2\2"+
"\u00d4\u00d5\3\2\2\2\u00d5\23\3\2\2\2\u00d6\u00d4\3\2\2\2\u00d7\u00d8"+
"\7\n\2\2\u00d8\25\3\2\2\2\u00d9\u00da\7\13\2\2\u00da\27\3\2\2\2\u00db"+
"\u00dc\7\f\2\2\u00dc\31\3\2\2\2\u00dd\u00de\7i\2\2\u00de\u00df\5\22\n"+
"\2\u00df\u00e0\7j\2\2\u00e0\u00e1\7t\2\2\u00e1\u00e2\5\20\t\2\u00e2\33"+
"\3\2\2\2\u00e3\u00e4\7k\2\2\u00e4\u00e5\5\20\t\2\u00e5\u00e6\7l\2\2\u00e6"+
"\u00e7\7t\2\2\u00e7\u00e8\5\20\t\2\u00e8\35\3\2\2\2\u00e9\u00ea\7\r\2"+
"\2\u00ea\u00eb\7k\2\2\u00eb\u00ec\7a\2\2\u00ec\u00ed\7l\2\2\u00ed\37\3"+
"\2\2\2\u00ee\u00ef\7\16\2\2\u00ef\u00f0\7X\2\2\u00f0!\3\2\2\2\u00f1\u00f2"+
"\5&\24\2\u00f2#\3\2\2\2\u00f3\u00f8\5\"\22\2\u00f4\u00f5\7o\2\2\u00f5"+
"\u00f7\5\"\22\2\u00f6\u00f4\3\2\2\2\u00f7\u00fa\3\2\2\2\u00f8\u00f6\3"+
"\2\2\2\u00f8\u00f9\3\2\2\2\u00f9%\3\2\2\2\u00fa\u00f8\3\2\2\2\u00fb\u0104"+
"\5(\25\2\u00fc\u00fe\7i\2\2\u00fd\u00ff\5\16\b\2\u00fe\u00fd\3\2\2\2\u00fe"+
"\u00ff\3\2\2\2\u00ff\u0100\3\2\2\2\u0100\u0101\7j\2\2\u0101\u0102\7t\2"+
"\2\u0102\u0104\5&\24\2\u0103\u00fb\3\2\2\2\u0103\u00fc\3\2\2\2\u0104\'"+
"\3\2\2\2\u0105\u010e\5*\26\2\u0106\u0107\7\17\2\2\u0107\u0108\5\"\22\2"+
"\u0108\u0109\7\20\2\2\u0109\u010a\5\"\22\2\u010a\u010b\7\21\2\2\u010b"+
"\u010c\5(\25\2\u010c\u010e\3\2\2\2\u010d\u0105\3\2\2\2\u010d\u0106\3\2"+
"\2\2\u010e)\3\2\2\2\u010f\u0112\5,\27\2\u0110\u0111\7\22\2\2\u0111\u0113"+
"\5*\26\2\u0112\u0110\3\2\2\2\u0112\u0113\3\2\2\2\u0113+\3\2\2\2\u0114"+
"\u0117\5.\30\2\u0115\u0116\7\23\2\2\u0116\u0118\5,\27\2\u0117\u0115\3"+
"\2\2\2\u0117\u0118\3\2\2\2\u0118-\3\2\2\2\u0119\u011d\5\64\33\2\u011a"+
"\u011d\5\60\31\2\u011b\u011d\5\62\32\2\u011c\u0119\3\2\2\2\u011c\u011a"+
"\3\2\2\2\u011c\u011b\3\2\2\2\u011d/\3\2\2\2\u011e\u011f\7\24\2\2\u011f"+
"\u0120\7i\2\2\u0120\u0121\5\16\b\2\u0121\u0122\7j\2\2\u0122\u0123\5.\30"+
"\2\u0123\61\3\2\2\2\u0124\u0125\7\25\2\2\u0125\u0126\7i\2\2\u0126\u0127"+
"\5\16\b\2\u0127\u0128\7j\2\2\u0128\u0129\5.\30\2\u0129\63\3\2\2\2\u012a"+
"\u012d\5\66\34\2\u012b\u012c\t\2\2\2\u012c\u012e\5\66\34\2\u012d\u012b"+
"\3\2\2\2\u012d\u012e\3\2\2\2\u012e\65\3\2\2\2\u012f\u0134\58\35\2\u0130"+
"\u0131\7\26\2\2\u0131\u0133\58\35\2\u0132\u0130\3\2\2\2\u0133\u0136\3"+
"\2\2\2\u0134\u0132\3\2\2\2\u0134\u0135\3\2\2\2\u0135\67\3\2\2\2\u0136"+
"\u0134\3\2\2\2\u0137\u013a\5:\36\2\u0138\u0139\7\30\2\2\u0139\u013b\5"+
"8\35\2\u013a\u0138\3\2\2\2\u013a\u013b\3\2\2\2\u013b9\3\2\2\2\u013c\u0141"+
"\5<\37\2\u013d\u013e\7\27\2\2\u013e\u0140\5<\37\2\u013f\u013d\3\2\2\2"+
"\u0140\u0143\3\2\2\2\u0141\u013f\3\2\2\2\u0141\u0142\3\2\2\2\u0142;\3"+
"\2\2\2\u0143\u0141\3\2\2\2\u0144\u0148\5> \2\u0145\u0146\7\31\2\2\u0146"+
"\u0148\5> \2\u0147\u0144\3\2\2\2\u0147\u0145\3\2\2\2\u0148=\3\2\2\2\u0149"+
"\u014c\5@!\2\u014a\u014b\t\3\2\2\u014b\u014d\5@!\2\u014c\u014a\3\2\2\2"+
"\u014c\u014d\3\2\2\2\u014d?\3\2\2\2\u014e\u0151\5B\"\2\u014f\u0150\t\4"+
"\2\2\u0150\u0152\5B\"\2\u0151\u014f\3\2\2\2\u0151\u0152\3\2\2\2\u0152"+
"A\3\2\2\2\u0153\u0156\5D#\2\u0154\u0155\7\64\2\2\u0155\u0157\5D#\2\u0156"+
"\u0154\3\2\2\2\u0156\u0157\3\2\2\2\u0157C\3\2\2\2\u0158\u015b\5F$\2\u0159"+
"\u015a\7\66\2\2\u015a\u015c\5F$\2\u015b\u0159\3\2\2\2\u015b\u015c\3\2"+
"\2\2\u015cE\3\2\2\2\u015d\u0160\5H%\2\u015e\u015f\7\65\2\2\u015f\u0161"+
"\5H%\2\u0160\u015e\3\2\2\2\u0160\u0161\3\2\2\2\u0161G\3\2\2\2\u0162\u0165"+
"\5J&\2\u0163\u0164\t\5\2\2\u0164\u0166\5J&\2\u0165\u0163\3\2\2\2\u0165"+
"\u0166\3\2\2\2\u0166I\3\2\2\2\u0167\u016c\5L\'\2\u0168\u0169\t\6\2\2\u0169"+
"\u016b\5L\'\2\u016a\u0168\3\2\2\2\u016b\u016e\3\2\2\2\u016c\u016a\3\2"+
"\2\2\u016c\u016d\3\2\2\2\u016dK\3\2\2\2\u016e\u016c\3\2\2\2\u016f\u0174"+
"\5N(\2\u0170\u0171\t\7\2\2\u0171\u0173\5N(\2\u0172\u0170\3\2\2\2\u0173"+
"\u0176\3\2\2\2\u0174\u0172\3\2\2\2\u0174\u0175\3\2\2\2\u0175M\3\2\2\2"+
"\u0176\u0174\3\2\2\2\u0177\u017c\5P)\2\u0178\u0179\7\'\2\2\u0179\u017b"+
"\5P)\2\u017a\u0178\3\2\2\2\u017b\u017e\3\2\2\2\u017c\u017a\3\2\2\2\u017c"+
"\u017d\3\2\2\2\u017dO\3\2\2\2\u017e\u017c\3\2\2\2\u017f\u0182\5R*\2\u0180"+
"\u0181\t\b\2\2\u0181\u0183\5\36\20\2\u0182\u0180\3\2\2\2\u0182\u0183\3"+
"\2\2\2\u0183Q\3\2\2\2\u0184\u0188\5T+\2\u0185\u0186\t\t\2\2\u0186\u0188"+
"\5R*\2\u0187\u0184\3\2\2\2\u0187\u0185\3\2\2\2\u0188S\3\2\2\2\u0189\u018d"+
"\5V,\2\u018a\u018b\7\67\2\2\u018b\u018d\5T+\2\u018c\u0189\3\2\2\2\u018c"+
"\u018a\3\2\2\2\u018dU\3\2\2\2\u018e\u0192\5d\63\2\u018f\u0191\5X-\2\u0190"+
"\u018f\3\2\2\2\u0191\u0194\3\2\2\2\u0192\u0190\3\2\2\2\u0192\u0193\3\2"+
"\2\2\u0193W\3\2\2\2\u0194\u0192\3\2\2\2\u0195\u019b\5Z.\2\u0196\u019b"+
"\5\\/\2\u0197\u019b\5^\60\2\u0198\u019b\5`\61\2\u0199\u019b\5b\62\2\u019a"+
"\u0195\3\2\2\2\u019a\u0196\3\2\2\2\u019a\u0197\3\2\2\2\u019a\u0198\3\2"+
"\2\2\u019a\u0199\3\2\2\2\u019bY\3\2\2\2\u019c\u019e\7i\2\2\u019d\u019f"+
"\5$\23\2\u019e\u019d\3\2\2\2\u019e\u019f\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0"+
"\u01a1\7j\2\2\u01a1[\3\2\2\2\u01a2\u01a3\7k\2\2\u01a3\u01a4\5\"\22\2\u01a4"+
"\u01a5\7l\2\2\u01a5]\3\2\2\2\u01a6\u01a7\7k\2\2\u01a7\u01a8\5\"\22\2\u01a8"+
"\u01a9\7s\2\2\u01a9\u01aa\5\"\22\2\u01aa\u01ab\7l\2\2\u01ab_\3\2\2\2\u01ac"+
"\u01ad\7r\2\2\u01ada\3\2\2\2\u01ae\u01af\7k\2\2\u01af\u01b0\7a\2\2\u01b0"+
"\u01b1\7p\2\2\u01b1\u01b2\7a\2\2\u01b2\u01b3\7l\2\2\u01b3c\3\2\2\2\u01b4"+
"\u01be\5f\64\2\u01b5\u01be\5h\65\2\u01b6\u01be\5j\66\2\u01b7\u01be\5l"+
"\67\2\u01b8\u01be\5n8\2\u01b9\u01be\5r:\2\u01ba\u01be\5p9\2\u01bb\u01be"+
"\5t;\2\u01bc\u01be\5v<\2\u01bd\u01b4\3\2\2\2\u01bd\u01b5\3\2\2\2\u01bd"+
"\u01b6\3\2\2\2\u01bd\u01b7\3\2\2\2\u01bd\u01b8\3\2\2\2\u01bd\u01b9\3\2"+
"\2\2\u01bd\u01ba\3\2\2\2\u01bd\u01bb\3\2\2\2\u01bd\u01bc\3\2\2\2\u01be"+
"e\3\2\2\2\u01bf\u01c0\7U\2\2\u01c0g\3\2\2\2\u01c1\u01c2\7Z\2\2\u01c2i"+
"\3\2\2\2\u01c3\u01c4\7a\2\2\u01c4k\3\2\2\2\u01c5\u01c6\7a\2\2\u01c6\u01c7"+
"\7&\2\2\u01c7\u01c8\7a\2\2\u01c8m\3\2\2\2\u01c9\u01cf\7k\2\2\u01ca\u01cb"+
"\5\"\22\2\u01cb\u01cc\7s\2\2\u01cc\u01cd\5\"\22\2\u01cd\u01ce\7o\2\2\u01ce"+
"\u01d0\3\2\2\2\u01cf\u01ca\3\2\2\2\u01d0\u01d1\3\2\2\2\u01d1\u01cf\3\2"+
"\2\2\u01d1\u01d2\3\2\2\2\u01d2\u01d7\3\2\2\2\u01d3\u01d4\7\34\2\2\u01d4"+
"\u01d5\5\20\t\2\u01d5\u01d6\7\36\2\2\u01d6\u01d8\3\2\2\2\u01d7\u01d3\3"+
"\2\2\2\u01d7\u01d8\3\2\2\2\u01d8\u01d9\3\2\2\2\u01d9\u01da\7[\2\2\u01da"+
"\u01db\7s\2\2\u01db\u01dc\5\"\22\2\u01dc\u01dd\7l\2\2\u01dd\u01e8\3\2"+
"\2\2\u01de\u01df\7k\2\2\u01df\u01e0\7\34\2\2\u01e0\u01e1\5\20\t\2\u01e1"+
"\u01e2\7\36\2\2\u01e2\u01e3\7[\2\2\u01e3\u01e4\7s\2\2\u01e4\u01e5\5\""+
"\22\2\u01e5\u01e6\7l\2\2\u01e6\u01e8\3\2\2\2\u01e7\u01c9\3\2\2\2\u01e7"+
"\u01de\3\2\2\2\u01e8o\3\2\2\2\u01e9\u01ea\7`\2\2\u01eaq\3\2\2\2\u01eb"+
"\u01ed\t\n\2\2\u01ec\u01eb\3\2\2\2\u01ec\u01ed\3\2\2\2\u01ed\u01ee\3\2"+
"\2\2\u01ee\u01ef\5p9\2\u01ef\u01f0\7d\2\2\u01f0\u01f1\5p9\2\u01f1s\3\2"+
"\2\2\u01f2\u01f3\7e\2\2\u01f3u\3\2\2\2\u01f4\u01f5\7i\2\2\u01f5\u01f6"+
"\5\"\22\2\u01f6\u01f7\7j\2\2\u01f7w\3\2\2\2\u01f8\u01fd\5|?\2\u01f9\u01fd"+
"\5~@\2\u01fa\u01fd\5\u0080A\2\u01fb\u01fd\5\u0082B\2\u01fc\u01f8\3\2\2"+
"\2\u01fc\u01f9\3\2\2\2\u01fc\u01fa\3\2\2\2\u01fc\u01fb\3\2\2\2\u01fdy"+
"\3\2\2\2\u01fe\u01ff\5x=\2\u01ff\u0200\7q\2\2\u0200\u0201\5x=\2\u0201"+
"{\3\2\2\2\u0202\u0203\7e\2\2\u0203\u0204\7\\\2\2\u0204\u0205\5\"\22\2"+
"\u0205}\3\2\2\2\u0206\u0207\7]\2\2\u0207\u0208\7e\2\2\u0208\177\3\2\2"+
"\2\u0209\u020a\7^\2\2\u020a\u020b\5\"\22\2\u020b\u0081\3\2\2\2\u020c\u020d"+
"\7_\2\2\u020d\u020e\5\"\22\2\u020e\u0083\3\2\2\2\60\u0086\u0088\u008f"+
"\u0095\u0098\u009e\u00a0\u00a8\u00b4\u00b8\u00c3\u00cd\u00d4\u00f8\u00fe"+
"\u0103\u010d\u0112\u0117\u011c\u012d\u0134\u013a\u0141\u0147\u014c\u0151"+
"\u0156\u015b\u0160\u0165\u016c\u0174\u017c\u0182\u0187\u018c\u0192\u019a"+
"\u019e\u01bd\u01d1\u01d7\u01e7\u01ec\u01fc";
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 - 2024 Weber Informatics LLC | Privacy Policy