hu.bme.mit.theta.solver.smtlib.dsl.gen.SMTLIBv2Parser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of theta-solver-smtlib Show documentation
Show all versions of theta-solver-smtlib Show documentation
Solver Smtlib subproject in the Theta model checking framework
// Generated from SMTLIBv2.g4 by ANTLR 4.9.2
package hu.bme.mit.theta.solver.smtlib.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 SMTLIBv2Parser 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
Comment=1, ParOpen=2, ParClose=3, Semicolon=4, String=5, QuotedSymbol=6,
PS_Not=7, PS_Bool=8, PS_ContinuedExecution=9, PS_Error=10, PS_False=11,
PS_ImmediateExit=12, PS_Incomplete=13, PS_Logic=14, PS_Memout=15, PS_Model=16,
PS_Sat=17, PS_Success=18, PS_Theory=19, PS_True=20, PS_Unknown=21, PS_Unsupported=22,
PS_Unsat=23, CMD_Assert=24, CMD_CheckSat=25, CMD_CheckSatAssuming=26,
CMD_DeclareConst=27, CMD_DeclareDatatype=28, CMD_DeclareDatatypes=29,
CMD_DeclareFun=30, CMD_DeclareSort=31, CMD_DefineFun=32, CMD_DefineFunRec=33,
CMD_DefineFunsRec=34, CMD_DefineSort=35, CMD_Echo=36, CMD_Exit=37, CMD_GetAssertions=38,
CMD_GetAssignment=39, CMD_GetInfo=40, CMD_GetModel=41, CMD_GetOption=42,
CMD_GetProof=43, CMD_GetUnsatAssumptions=44, CMD_GetUnsatCore=45, CMD_GetValue=46,
CMD_Pop=47, CMD_Push=48, CMD_Reset=49, CMD_ResetAssertions=50, CMD_SetInfo=51,
CMD_SetLogic=52, CMD_SetOption=53, GRW_Exclamation=54, GRW_Underscore=55,
GRW_As=56, GRW_Binary=57, GRW_Decimal=58, GRW_Exists=59, GRW_Hexadecimal=60,
GRW_Forall=61, GRW_Let=62, GRW_Match=63, GRW_Numeral=64, GRW_Par=65, GRW_String=66,
Numeral=67, Binary=68, HexDecimal=69, Decimal=70, Colon=71, PK_AllStatistics=72,
PK_AssertionStackLevels=73, PK_Authors=74, PK_Category=75, PK_Chainable=76,
PK_Definition=77, PK_DiagnosticOutputChannel=78, PK_ErrorBehaviour=79,
PK_Extension=80, PK_Funs=81, PK_FunsDescription=82, PK_GlobalDeclarations=83,
PK_InteractiveMode=84, PK_Language=85, PK_LeftAssoc=86, PK_License=87,
PK_Named=88, PK_Name=89, PK_Notes=90, PK_Pattern=91, PK_PrintSuccess=92,
PK_ProduceAssertions=93, PK_ProduceAssignments=94, PK_ProduceModels=95,
PK_ProduceProofs=96, PK_ProduceUnsatAssumptions=97, PK_ProduceUnsatCores=98,
PK_RandomSeed=99, PK_ReasonUnknown=100, PK_RegularOutputChannel=101, PK_ReproducibleResourceLimit=102,
PK_RightAssoc=103, PK_SmtLibVersion=104, PK_Sorts=105, PK_SortsDescription=106,
PK_Source=107, PK_Status=108, PK_Theories=109, PK_Values=110, PK_Verbosity=111,
PK_Version=112, UndefinedSymbol=113, WS=114;
public static final int
RULE_response = 0, RULE_general_response_success = 1, RULE_general_response_unsupported = 2,
RULE_general_response_error = 3, RULE_specific_success_response = 4, RULE_check_sat_response = 5,
RULE_get_unsat_core_response = 6, RULE_get_model_response = 7, RULE_model_response = 8,
RULE_model_response_fun = 9, RULE_model_response_fun_rec = 10, RULE_model_response_funs_rec = 11,
RULE_model_response_mathsat = 12, RULE_function_def = 13, RULE_function_dec = 14,
RULE_get_interpolants_response_smtinterpol = 15, RULE_simpleSymbol = 16,
RULE_quotedSymbol = 17, RULE_predefSymbol = 18, RULE_predefKeyword = 19,
RULE_symbol = 20, RULE_numeral = 21, RULE_decimal = 22, RULE_hexadecimal = 23,
RULE_binary = 24, RULE_string = 25, RULE_keyword = 26, RULE_spec_constant = 27,
RULE_s_expr = 28, RULE_index = 29, RULE_identifier = 30, RULE_attribute_value = 31,
RULE_attribute = 32, RULE_sort = 33, RULE_qual_identifier = 34, RULE_var_binding = 35,
RULE_sorted_var = 36, RULE_pattern = 37, RULE_match_case = 38, RULE_term = 39,
RULE_generic_term = 40, RULE_let_term = 41, RULE_forall_term = 42, RULE_exists_term = 43,
RULE_match_term = 44, RULE_annotate_term = 45;
private static String[] makeRuleNames() {
return new String[] {
"response", "general_response_success", "general_response_unsupported",
"general_response_error", "specific_success_response", "check_sat_response",
"get_unsat_core_response", "get_model_response", "model_response", "model_response_fun",
"model_response_fun_rec", "model_response_funs_rec", "model_response_mathsat",
"function_def", "function_dec", "get_interpolants_response_smtinterpol",
"simpleSymbol", "quotedSymbol", "predefSymbol", "predefKeyword", "symbol",
"numeral", "decimal", "hexadecimal", "binary", "string", "keyword", "spec_constant",
"s_expr", "index", "identifier", "attribute_value", "attribute", "sort",
"qual_identifier", "var_binding", "sorted_var", "pattern", "match_case",
"term", "generic_term", "let_term", "forall_term", "exists_term", "match_term",
"annotate_term"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, null, "'('", "')'", "';'", null, null, "'not'", "'Bool'", "'continued-execution'",
"'error'", "'false'", "'immediate-exit'", "'incomplete'", "'logic'",
"'memout'", "'model'", "'sat'", "'success'", "'theory'", "'true'", "'unknown'",
"'unsupported'", "'unsat'", "'assert'", "'check-sat'", "'check-sat-assuming'",
"'declare-const'", "'declare-datatype'", "'declare-datatypes'", "'declare-fun'",
"'declare-sort'", "'define-fun'", "'define-fun-rec'", "'define-funs-rec'",
"'define-sort'", "'echo'", "'exit'", "'get-assertions'", "'get-assignment'",
"'get-info'", "'get-model'", "'get-option'", "'get-proof'", "'get-unsat-assumptions'",
"'get-unsat-core'", "'get-value'", "'pop'", "'push'", "'reset'", "'reset-assertions'",
"'set-info'", "'set-logic'", "'set-option'", "'!'", "'_'", "'as'", "'BINARY'",
"'DECIMAL'", "'exists'", "'HEXADECIMAL'", "'forall'", "'let'", "'match'",
"'NUMERAL'", "'par'", "'string'", null, null, null, null, "':'", "':all-statistics'",
"':assertion-stack-levels'", "':authors'", "':category'", "':chainable'",
"':definition'", "':diagnostic-output-channel'", "':error-behavior'",
"':extensions'", "':funs'", "':funs-description'", "':global-declarations'",
"':interactive-mode'", "':language'", "':left-assoc'", "':license'",
"':named'", "':name'", "':notes'", "':pattern'", "':print-success'",
"':produce-assertions'", "':produce-assignments'", "':produce-models'",
"':produce-proofs'", "':produce-unsat-assumptions'", "':produce-unsat-cores'",
"':random-seed'", "':reason-unknown'", "':regular-output-channel'", "':reproducible-resource-limit'",
"':right-assoc'", "':smt-lib-version'", "':sorts'", "':sorts-description'",
"':source'", "':status'", "':theories'", "':values'", "':verbosity'",
"':version'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, "Comment", "ParOpen", "ParClose", "Semicolon", "String", "QuotedSymbol",
"PS_Not", "PS_Bool", "PS_ContinuedExecution", "PS_Error", "PS_False",
"PS_ImmediateExit", "PS_Incomplete", "PS_Logic", "PS_Memout", "PS_Model",
"PS_Sat", "PS_Success", "PS_Theory", "PS_True", "PS_Unknown", "PS_Unsupported",
"PS_Unsat", "CMD_Assert", "CMD_CheckSat", "CMD_CheckSatAssuming", "CMD_DeclareConst",
"CMD_DeclareDatatype", "CMD_DeclareDatatypes", "CMD_DeclareFun", "CMD_DeclareSort",
"CMD_DefineFun", "CMD_DefineFunRec", "CMD_DefineFunsRec", "CMD_DefineSort",
"CMD_Echo", "CMD_Exit", "CMD_GetAssertions", "CMD_GetAssignment", "CMD_GetInfo",
"CMD_GetModel", "CMD_GetOption", "CMD_GetProof", "CMD_GetUnsatAssumptions",
"CMD_GetUnsatCore", "CMD_GetValue", "CMD_Pop", "CMD_Push", "CMD_Reset",
"CMD_ResetAssertions", "CMD_SetInfo", "CMD_SetLogic", "CMD_SetOption",
"GRW_Exclamation", "GRW_Underscore", "GRW_As", "GRW_Binary", "GRW_Decimal",
"GRW_Exists", "GRW_Hexadecimal", "GRW_Forall", "GRW_Let", "GRW_Match",
"GRW_Numeral", "GRW_Par", "GRW_String", "Numeral", "Binary", "HexDecimal",
"Decimal", "Colon", "PK_AllStatistics", "PK_AssertionStackLevels", "PK_Authors",
"PK_Category", "PK_Chainable", "PK_Definition", "PK_DiagnosticOutputChannel",
"PK_ErrorBehaviour", "PK_Extension", "PK_Funs", "PK_FunsDescription",
"PK_GlobalDeclarations", "PK_InteractiveMode", "PK_Language", "PK_LeftAssoc",
"PK_License", "PK_Named", "PK_Name", "PK_Notes", "PK_Pattern", "PK_PrintSuccess",
"PK_ProduceAssertions", "PK_ProduceAssignments", "PK_ProduceModels",
"PK_ProduceProofs", "PK_ProduceUnsatAssumptions", "PK_ProduceUnsatCores",
"PK_RandomSeed", "PK_ReasonUnknown", "PK_RegularOutputChannel", "PK_ReproducibleResourceLimit",
"PK_RightAssoc", "PK_SmtLibVersion", "PK_Sorts", "PK_SortsDescription",
"PK_Source", "PK_Status", "PK_Theories", "PK_Values", "PK_Verbosity",
"PK_Version", "UndefinedSymbol", "WS"
};
}
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 "SMTLIBv2.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public SMTLIBv2Parser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class ResponseContext extends ParserRuleContext {
public General_response_successContext general_response_success() {
return getRuleContext(General_response_successContext.class,0);
}
public General_response_unsupportedContext general_response_unsupported() {
return getRuleContext(General_response_unsupportedContext.class,0);
}
public General_response_errorContext general_response_error() {
return getRuleContext(General_response_errorContext.class,0);
}
public Specific_success_responseContext specific_success_response() {
return getRuleContext(Specific_success_responseContext.class,0);
}
public ResponseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_response; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterResponse(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitResponse(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitResponse(this);
else return visitor.visitChildren(this);
}
}
public final ResponseContext response() throws RecognitionException {
ResponseContext _localctx = new ResponseContext(_ctx, getState());
enterRule(_localctx, 0, RULE_response);
try {
setState(96);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(92);
general_response_success();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(93);
general_response_unsupported();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(94);
general_response_error();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(95);
specific_success_response();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class General_response_successContext extends ParserRuleContext {
public TerminalNode PS_Success() { return getToken(SMTLIBv2Parser.PS_Success, 0); }
public General_response_successContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_general_response_success; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterGeneral_response_success(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitGeneral_response_success(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitGeneral_response_success(this);
else return visitor.visitChildren(this);
}
}
public final General_response_successContext general_response_success() throws RecognitionException {
General_response_successContext _localctx = new General_response_successContext(_ctx, getState());
enterRule(_localctx, 2, RULE_general_response_success);
try {
enterOuterAlt(_localctx, 1);
{
setState(98);
match(PS_Success);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class General_response_unsupportedContext extends ParserRuleContext {
public TerminalNode PS_Unsupported() { return getToken(SMTLIBv2Parser.PS_Unsupported, 0); }
public General_response_unsupportedContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_general_response_unsupported; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterGeneral_response_unsupported(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitGeneral_response_unsupported(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitGeneral_response_unsupported(this);
else return visitor.visitChildren(this);
}
}
public final General_response_unsupportedContext general_response_unsupported() throws RecognitionException {
General_response_unsupportedContext _localctx = new General_response_unsupportedContext(_ctx, getState());
enterRule(_localctx, 4, RULE_general_response_unsupported);
try {
enterOuterAlt(_localctx, 1);
{
setState(100);
match(PS_Unsupported);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class General_response_errorContext extends ParserRuleContext {
public Token reason;
public TerminalNode ParOpen() { return getToken(SMTLIBv2Parser.ParOpen, 0); }
public TerminalNode PS_Error() { return getToken(SMTLIBv2Parser.PS_Error, 0); }
public TerminalNode ParClose() { return getToken(SMTLIBv2Parser.ParClose, 0); }
public TerminalNode String() { return getToken(SMTLIBv2Parser.String, 0); }
public General_response_errorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_general_response_error; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterGeneral_response_error(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitGeneral_response_error(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitGeneral_response_error(this);
else return visitor.visitChildren(this);
}
}
public final General_response_errorContext general_response_error() throws RecognitionException {
General_response_errorContext _localctx = new General_response_errorContext(_ctx, getState());
enterRule(_localctx, 6, RULE_general_response_error);
try {
enterOuterAlt(_localctx, 1);
{
setState(102);
match(ParOpen);
setState(103);
match(PS_Error);
setState(104);
((General_response_errorContext)_localctx).reason = match(String);
setState(105);
match(ParClose);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Specific_success_responseContext extends ParserRuleContext {
public Check_sat_responseContext check_sat_response() {
return getRuleContext(Check_sat_responseContext.class,0);
}
public Get_unsat_core_responseContext get_unsat_core_response() {
return getRuleContext(Get_unsat_core_responseContext.class,0);
}
public Get_model_responseContext get_model_response() {
return getRuleContext(Get_model_responseContext.class,0);
}
public Get_interpolants_response_smtinterpolContext get_interpolants_response_smtinterpol() {
return getRuleContext(Get_interpolants_response_smtinterpolContext.class,0);
}
public Specific_success_responseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_specific_success_response; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterSpecific_success_response(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitSpecific_success_response(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitSpecific_success_response(this);
else return visitor.visitChildren(this);
}
}
public final Specific_success_responseContext specific_success_response() throws RecognitionException {
Specific_success_responseContext _localctx = new Specific_success_responseContext(_ctx, getState());
enterRule(_localctx, 8, RULE_specific_success_response);
try {
setState(111);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,1,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(107);
check_sat_response();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(108);
get_unsat_core_response();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(109);
get_model_response();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(110);
get_interpolants_response_smtinterpol();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Check_sat_responseContext extends ParserRuleContext {
public Token value;
public TerminalNode PS_Sat() { return getToken(SMTLIBv2Parser.PS_Sat, 0); }
public TerminalNode PS_Unsat() { return getToken(SMTLIBv2Parser.PS_Unsat, 0); }
public TerminalNode PS_Unknown() { return getToken(SMTLIBv2Parser.PS_Unknown, 0); }
public Check_sat_responseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_check_sat_response; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterCheck_sat_response(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitCheck_sat_response(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitCheck_sat_response(this);
else return visitor.visitChildren(this);
}
}
public final Check_sat_responseContext check_sat_response() throws RecognitionException {
Check_sat_responseContext _localctx = new Check_sat_responseContext(_ctx, getState());
enterRule(_localctx, 10, RULE_check_sat_response);
try {
setState(116);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PS_Sat:
enterOuterAlt(_localctx, 1);
{
setState(113);
((Check_sat_responseContext)_localctx).value = match(PS_Sat);
}
break;
case PS_Unsat:
enterOuterAlt(_localctx, 2);
{
setState(114);
((Check_sat_responseContext)_localctx).value = match(PS_Unsat);
}
break;
case PS_Unknown:
enterOuterAlt(_localctx, 3);
{
setState(115);
((Check_sat_responseContext)_localctx).value = match(PS_Unknown);
}
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 Get_unsat_core_responseContext extends ParserRuleContext {
public TerminalNode ParOpen() { return getToken(SMTLIBv2Parser.ParOpen, 0); }
public TerminalNode ParClose() { return getToken(SMTLIBv2Parser.ParClose, 0); }
public List symbol() {
return getRuleContexts(SymbolContext.class);
}
public SymbolContext symbol(int i) {
return getRuleContext(SymbolContext.class,i);
}
public Get_unsat_core_responseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_get_unsat_core_response; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterGet_unsat_core_response(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitGet_unsat_core_response(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitGet_unsat_core_response(this);
else return visitor.visitChildren(this);
}
}
public final Get_unsat_core_responseContext get_unsat_core_response() throws RecognitionException {
Get_unsat_core_responseContext _localctx = new Get_unsat_core_responseContext(_ctx, getState());
enterRule(_localctx, 12, RULE_get_unsat_core_response);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(118);
match(ParOpen);
setState(122);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << QuotedSymbol) | (1L << PS_Not) | (1L << PS_Bool) | (1L << PS_ContinuedExecution) | (1L << PS_Error) | (1L << PS_False) | (1L << PS_ImmediateExit) | (1L << PS_Incomplete) | (1L << PS_Logic) | (1L << PS_Memout) | (1L << PS_Sat) | (1L << PS_Success) | (1L << PS_Theory) | (1L << PS_True) | (1L << PS_Unknown) | (1L << PS_Unsupported) | (1L << PS_Unsat))) != 0) || _la==UndefinedSymbol) {
{
{
setState(119);
symbol();
}
}
setState(124);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(125);
match(ParClose);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Get_model_responseContext extends ParserRuleContext {
public TerminalNode ParOpen() { return getToken(SMTLIBv2Parser.ParOpen, 0); }
public TerminalNode ParClose() { return getToken(SMTLIBv2Parser.ParClose, 0); }
public TerminalNode PS_Model() { return getToken(SMTLIBv2Parser.PS_Model, 0); }
public List model_response() {
return getRuleContexts(Model_responseContext.class);
}
public Model_responseContext model_response(int i) {
return getRuleContext(Model_responseContext.class,i);
}
public Get_model_responseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_get_model_response; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterGet_model_response(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitGet_model_response(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitGet_model_response(this);
else return visitor.visitChildren(this);
}
}
public final Get_model_responseContext get_model_response() throws RecognitionException {
Get_model_responseContext _localctx = new Get_model_responseContext(_ctx, getState());
enterRule(_localctx, 14, RULE_get_model_response);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(127);
match(ParOpen);
setState(129);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==PS_Model) {
{
setState(128);
match(PS_Model);
}
}
setState(134);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ParOpen) {
{
{
setState(131);
model_response();
}
}
setState(136);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(137);
match(ParClose);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Model_responseContext extends ParserRuleContext {
public Model_response_funContext model_response_fun() {
return getRuleContext(Model_response_funContext.class,0);
}
public Model_response_fun_recContext model_response_fun_rec() {
return getRuleContext(Model_response_fun_recContext.class,0);
}
public Model_response_funs_recContext model_response_funs_rec() {
return getRuleContext(Model_response_funs_recContext.class,0);
}
public Model_response_mathsatContext model_response_mathsat() {
return getRuleContext(Model_response_mathsatContext.class,0);
}
public Model_responseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_model_response; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterModel_response(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitModel_response(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitModel_response(this);
else return visitor.visitChildren(this);
}
}
public final Model_responseContext model_response() throws RecognitionException {
Model_responseContext _localctx = new Model_responseContext(_ctx, getState());
enterRule(_localctx, 16, RULE_model_response);
try {
setState(143);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(139);
model_response_fun();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(140);
model_response_fun_rec();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(141);
model_response_funs_rec();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(142);
model_response_mathsat();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Model_response_funContext extends ParserRuleContext {
public TerminalNode ParOpen() { return getToken(SMTLIBv2Parser.ParOpen, 0); }
public TerminalNode CMD_DefineFun() { return getToken(SMTLIBv2Parser.CMD_DefineFun, 0); }
public Function_defContext function_def() {
return getRuleContext(Function_defContext.class,0);
}
public TerminalNode ParClose() { return getToken(SMTLIBv2Parser.ParClose, 0); }
public Model_response_funContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_model_response_fun; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterModel_response_fun(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitModel_response_fun(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitModel_response_fun(this);
else return visitor.visitChildren(this);
}
}
public final Model_response_funContext model_response_fun() throws RecognitionException {
Model_response_funContext _localctx = new Model_response_funContext(_ctx, getState());
enterRule(_localctx, 18, RULE_model_response_fun);
try {
enterOuterAlt(_localctx, 1);
{
setState(145);
match(ParOpen);
setState(146);
match(CMD_DefineFun);
setState(147);
function_def();
setState(148);
match(ParClose);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Model_response_fun_recContext extends ParserRuleContext {
public TerminalNode ParOpen() { return getToken(SMTLIBv2Parser.ParOpen, 0); }
public TerminalNode CMD_DefineFunRec() { return getToken(SMTLIBv2Parser.CMD_DefineFunRec, 0); }
public Function_defContext function_def() {
return getRuleContext(Function_defContext.class,0);
}
public TerminalNode ParClose() { return getToken(SMTLIBv2Parser.ParClose, 0); }
public Model_response_fun_recContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_model_response_fun_rec; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterModel_response_fun_rec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitModel_response_fun_rec(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitModel_response_fun_rec(this);
else return visitor.visitChildren(this);
}
}
public final Model_response_fun_recContext model_response_fun_rec() throws RecognitionException {
Model_response_fun_recContext _localctx = new Model_response_fun_recContext(_ctx, getState());
enterRule(_localctx, 20, RULE_model_response_fun_rec);
try {
enterOuterAlt(_localctx, 1);
{
setState(150);
match(ParOpen);
setState(151);
match(CMD_DefineFunRec);
setState(152);
function_def();
setState(153);
match(ParClose);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Model_response_funs_recContext extends ParserRuleContext {
public List ParOpen() { return getTokens(SMTLIBv2Parser.ParOpen); }
public TerminalNode ParOpen(int i) {
return getToken(SMTLIBv2Parser.ParOpen, i);
}
public TerminalNode CMD_DefineFunsRec() { return getToken(SMTLIBv2Parser.CMD_DefineFunsRec, 0); }
public List ParClose() { return getTokens(SMTLIBv2Parser.ParClose); }
public TerminalNode ParClose(int i) {
return getToken(SMTLIBv2Parser.ParClose, i);
}
public List function_dec() {
return getRuleContexts(Function_decContext.class);
}
public Function_decContext function_dec(int i) {
return getRuleContext(Function_decContext.class,i);
}
public List term() {
return getRuleContexts(TermContext.class);
}
public TermContext term(int i) {
return getRuleContext(TermContext.class,i);
}
public Model_response_funs_recContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_model_response_funs_rec; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterModel_response_funs_rec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitModel_response_funs_rec(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitModel_response_funs_rec(this);
else return visitor.visitChildren(this);
}
}
public final Model_response_funs_recContext model_response_funs_rec() throws RecognitionException {
Model_response_funs_recContext _localctx = new Model_response_funs_recContext(_ctx, getState());
enterRule(_localctx, 22, RULE_model_response_funs_rec);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(155);
match(ParOpen);
setState(156);
match(CMD_DefineFunsRec);
setState(157);
match(ParOpen);
setState(159);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(158);
function_dec();
}
}
setState(161);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==ParOpen );
setState(163);
match(ParClose);
setState(164);
match(ParOpen);
setState(166);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(165);
term();
}
}
setState(168);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ParOpen) | (1L << String) | (1L << QuotedSymbol) | (1L << PS_Not) | (1L << PS_Bool) | (1L << PS_ContinuedExecution) | (1L << PS_Error) | (1L << PS_False) | (1L << PS_ImmediateExit) | (1L << PS_Incomplete) | (1L << PS_Logic) | (1L << PS_Memout) | (1L << PS_Sat) | (1L << PS_Success) | (1L << PS_Theory) | (1L << PS_True) | (1L << PS_Unknown) | (1L << PS_Unsupported) | (1L << PS_Unsat))) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & ((1L << (Numeral - 67)) | (1L << (Binary - 67)) | (1L << (HexDecimal - 67)) | (1L << (Decimal - 67)) | (1L << (UndefinedSymbol - 67)))) != 0) );
setState(170);
match(ParClose);
setState(171);
match(ParClose);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Model_response_mathsatContext extends ParserRuleContext {
public TerminalNode ParOpen() { return getToken(SMTLIBv2Parser.ParOpen, 0); }
public SymbolContext symbol() {
return getRuleContext(SymbolContext.class,0);
}
public TermContext term() {
return getRuleContext(TermContext.class,0);
}
public TerminalNode ParClose() { return getToken(SMTLIBv2Parser.ParClose, 0); }
public Model_response_mathsatContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_model_response_mathsat; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterModel_response_mathsat(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitModel_response_mathsat(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitModel_response_mathsat(this);
else return visitor.visitChildren(this);
}
}
public final Model_response_mathsatContext model_response_mathsat() throws RecognitionException {
Model_response_mathsatContext _localctx = new Model_response_mathsatContext(_ctx, getState());
enterRule(_localctx, 24, RULE_model_response_mathsat);
try {
enterOuterAlt(_localctx, 1);
{
setState(173);
match(ParOpen);
setState(174);
symbol();
setState(175);
term();
setState(176);
match(ParClose);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Function_defContext extends ParserRuleContext {
public SymbolContext symbol() {
return getRuleContext(SymbolContext.class,0);
}
public TerminalNode ParOpen() { return getToken(SMTLIBv2Parser.ParOpen, 0); }
public TerminalNode ParClose() { return getToken(SMTLIBv2Parser.ParClose, 0); }
public SortContext sort() {
return getRuleContext(SortContext.class,0);
}
public TermContext term() {
return getRuleContext(TermContext.class,0);
}
public List sorted_var() {
return getRuleContexts(Sorted_varContext.class);
}
public Sorted_varContext sorted_var(int i) {
return getRuleContext(Sorted_varContext.class,i);
}
public Function_defContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_function_def; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterFunction_def(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitFunction_def(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitFunction_def(this);
else return visitor.visitChildren(this);
}
}
public final Function_defContext function_def() throws RecognitionException {
Function_defContext _localctx = new Function_defContext(_ctx, getState());
enterRule(_localctx, 26, RULE_function_def);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(178);
symbol();
setState(179);
match(ParOpen);
setState(183);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ParOpen) {
{
{
setState(180);
sorted_var();
}
}
setState(185);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(186);
match(ParClose);
setState(187);
sort();
setState(188);
term();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Function_decContext extends ParserRuleContext {
public List ParOpen() { return getTokens(SMTLIBv2Parser.ParOpen); }
public TerminalNode ParOpen(int i) {
return getToken(SMTLIBv2Parser.ParOpen, i);
}
public SymbolContext symbol() {
return getRuleContext(SymbolContext.class,0);
}
public List ParClose() { return getTokens(SMTLIBv2Parser.ParClose); }
public TerminalNode ParClose(int i) {
return getToken(SMTLIBv2Parser.ParClose, i);
}
public SortContext sort() {
return getRuleContext(SortContext.class,0);
}
public List sorted_var() {
return getRuleContexts(Sorted_varContext.class);
}
public Sorted_varContext sorted_var(int i) {
return getRuleContext(Sorted_varContext.class,i);
}
public Function_decContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_function_dec; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterFunction_dec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitFunction_dec(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitFunction_dec(this);
else return visitor.visitChildren(this);
}
}
public final Function_decContext function_dec() throws RecognitionException {
Function_decContext _localctx = new Function_decContext(_ctx, getState());
enterRule(_localctx, 28, RULE_function_dec);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(190);
match(ParOpen);
setState(191);
symbol();
setState(192);
match(ParOpen);
setState(196);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==ParOpen) {
{
{
setState(193);
sorted_var();
}
}
setState(198);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(199);
match(ParClose);
setState(200);
sort();
setState(201);
match(ParClose);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Get_interpolants_response_smtinterpolContext extends ParserRuleContext {
public TerminalNode ParOpen() { return getToken(SMTLIBv2Parser.ParOpen, 0); }
public TerminalNode ParClose() { return getToken(SMTLIBv2Parser.ParClose, 0); }
public List term() {
return getRuleContexts(TermContext.class);
}
public TermContext term(int i) {
return getRuleContext(TermContext.class,i);
}
public Get_interpolants_response_smtinterpolContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_get_interpolants_response_smtinterpol; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterGet_interpolants_response_smtinterpol(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitGet_interpolants_response_smtinterpol(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitGet_interpolants_response_smtinterpol(this);
else return visitor.visitChildren(this);
}
}
public final Get_interpolants_response_smtinterpolContext get_interpolants_response_smtinterpol() throws RecognitionException {
Get_interpolants_response_smtinterpolContext _localctx = new Get_interpolants_response_smtinterpolContext(_ctx, getState());
enterRule(_localctx, 30, RULE_get_interpolants_response_smtinterpol);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(203);
match(ParOpen);
setState(207);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ParOpen) | (1L << String) | (1L << QuotedSymbol) | (1L << PS_Not) | (1L << PS_Bool) | (1L << PS_ContinuedExecution) | (1L << PS_Error) | (1L << PS_False) | (1L << PS_ImmediateExit) | (1L << PS_Incomplete) | (1L << PS_Logic) | (1L << PS_Memout) | (1L << PS_Sat) | (1L << PS_Success) | (1L << PS_Theory) | (1L << PS_True) | (1L << PS_Unknown) | (1L << PS_Unsupported) | (1L << PS_Unsat))) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & ((1L << (Numeral - 67)) | (1L << (Binary - 67)) | (1L << (HexDecimal - 67)) | (1L << (Decimal - 67)) | (1L << (UndefinedSymbol - 67)))) != 0)) {
{
{
setState(204);
term();
}
}
setState(209);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(210);
match(ParClose);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SimpleSymbolContext extends ParserRuleContext {
public PredefSymbolContext predefSymbol() {
return getRuleContext(PredefSymbolContext.class,0);
}
public TerminalNode UndefinedSymbol() { return getToken(SMTLIBv2Parser.UndefinedSymbol, 0); }
public SimpleSymbolContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simpleSymbol; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterSimpleSymbol(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitSimpleSymbol(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitSimpleSymbol(this);
else return visitor.visitChildren(this);
}
}
public final SimpleSymbolContext simpleSymbol() throws RecognitionException {
SimpleSymbolContext _localctx = new SimpleSymbolContext(_ctx, getState());
enterRule(_localctx, 32, RULE_simpleSymbol);
try {
setState(214);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PS_Not:
case PS_Bool:
case PS_ContinuedExecution:
case PS_Error:
case PS_False:
case PS_ImmediateExit:
case PS_Incomplete:
case PS_Logic:
case PS_Memout:
case PS_Sat:
case PS_Success:
case PS_Theory:
case PS_True:
case PS_Unknown:
case PS_Unsupported:
case PS_Unsat:
enterOuterAlt(_localctx, 1);
{
setState(212);
predefSymbol();
}
break;
case UndefinedSymbol:
enterOuterAlt(_localctx, 2);
{
setState(213);
match(UndefinedSymbol);
}
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 QuotedSymbolContext extends ParserRuleContext {
public TerminalNode QuotedSymbol() { return getToken(SMTLIBv2Parser.QuotedSymbol, 0); }
public QuotedSymbolContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_quotedSymbol; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterQuotedSymbol(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitQuotedSymbol(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitQuotedSymbol(this);
else return visitor.visitChildren(this);
}
}
public final QuotedSymbolContext quotedSymbol() throws RecognitionException {
QuotedSymbolContext _localctx = new QuotedSymbolContext(_ctx, getState());
enterRule(_localctx, 34, RULE_quotedSymbol);
try {
enterOuterAlt(_localctx, 1);
{
setState(216);
match(QuotedSymbol);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PredefSymbolContext extends ParserRuleContext {
public TerminalNode PS_Not() { return getToken(SMTLIBv2Parser.PS_Not, 0); }
public TerminalNode PS_Bool() { return getToken(SMTLIBv2Parser.PS_Bool, 0); }
public TerminalNode PS_ContinuedExecution() { return getToken(SMTLIBv2Parser.PS_ContinuedExecution, 0); }
public TerminalNode PS_Error() { return getToken(SMTLIBv2Parser.PS_Error, 0); }
public TerminalNode PS_False() { return getToken(SMTLIBv2Parser.PS_False, 0); }
public TerminalNode PS_ImmediateExit() { return getToken(SMTLIBv2Parser.PS_ImmediateExit, 0); }
public TerminalNode PS_Incomplete() { return getToken(SMTLIBv2Parser.PS_Incomplete, 0); }
public TerminalNode PS_Logic() { return getToken(SMTLIBv2Parser.PS_Logic, 0); }
public TerminalNode PS_Memout() { return getToken(SMTLIBv2Parser.PS_Memout, 0); }
public TerminalNode PS_Sat() { return getToken(SMTLIBv2Parser.PS_Sat, 0); }
public TerminalNode PS_Success() { return getToken(SMTLIBv2Parser.PS_Success, 0); }
public TerminalNode PS_Theory() { return getToken(SMTLIBv2Parser.PS_Theory, 0); }
public TerminalNode PS_True() { return getToken(SMTLIBv2Parser.PS_True, 0); }
public TerminalNode PS_Unknown() { return getToken(SMTLIBv2Parser.PS_Unknown, 0); }
public TerminalNode PS_Unsupported() { return getToken(SMTLIBv2Parser.PS_Unsupported, 0); }
public TerminalNode PS_Unsat() { return getToken(SMTLIBv2Parser.PS_Unsat, 0); }
public PredefSymbolContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_predefSymbol; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterPredefSymbol(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitPredefSymbol(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitPredefSymbol(this);
else return visitor.visitChildren(this);
}
}
public final PredefSymbolContext predefSymbol() throws RecognitionException {
PredefSymbolContext _localctx = new PredefSymbolContext(_ctx, getState());
enterRule(_localctx, 36, RULE_predefSymbol);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(218);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PS_Not) | (1L << PS_Bool) | (1L << PS_ContinuedExecution) | (1L << PS_Error) | (1L << PS_False) | (1L << PS_ImmediateExit) | (1L << PS_Incomplete) | (1L << PS_Logic) | (1L << PS_Memout) | (1L << PS_Sat) | (1L << PS_Success) | (1L << PS_Theory) | (1L << PS_True) | (1L << PS_Unknown) | (1L << PS_Unsupported) | (1L << PS_Unsat))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PredefKeywordContext extends ParserRuleContext {
public TerminalNode PK_AllStatistics() { return getToken(SMTLIBv2Parser.PK_AllStatistics, 0); }
public TerminalNode PK_AssertionStackLevels() { return getToken(SMTLIBv2Parser.PK_AssertionStackLevels, 0); }
public TerminalNode PK_Authors() { return getToken(SMTLIBv2Parser.PK_Authors, 0); }
public TerminalNode PK_Category() { return getToken(SMTLIBv2Parser.PK_Category, 0); }
public TerminalNode PK_Chainable() { return getToken(SMTLIBv2Parser.PK_Chainable, 0); }
public TerminalNode PK_Definition() { return getToken(SMTLIBv2Parser.PK_Definition, 0); }
public TerminalNode PK_DiagnosticOutputChannel() { return getToken(SMTLIBv2Parser.PK_DiagnosticOutputChannel, 0); }
public TerminalNode PK_ErrorBehaviour() { return getToken(SMTLIBv2Parser.PK_ErrorBehaviour, 0); }
public TerminalNode PK_Extension() { return getToken(SMTLIBv2Parser.PK_Extension, 0); }
public TerminalNode PK_Funs() { return getToken(SMTLIBv2Parser.PK_Funs, 0); }
public TerminalNode PK_FunsDescription() { return getToken(SMTLIBv2Parser.PK_FunsDescription, 0); }
public TerminalNode PK_GlobalDeclarations() { return getToken(SMTLIBv2Parser.PK_GlobalDeclarations, 0); }
public TerminalNode PK_InteractiveMode() { return getToken(SMTLIBv2Parser.PK_InteractiveMode, 0); }
public TerminalNode PK_Language() { return getToken(SMTLIBv2Parser.PK_Language, 0); }
public TerminalNode PK_LeftAssoc() { return getToken(SMTLIBv2Parser.PK_LeftAssoc, 0); }
public TerminalNode PK_License() { return getToken(SMTLIBv2Parser.PK_License, 0); }
public TerminalNode PK_Named() { return getToken(SMTLIBv2Parser.PK_Named, 0); }
public TerminalNode PK_Name() { return getToken(SMTLIBv2Parser.PK_Name, 0); }
public TerminalNode PK_Notes() { return getToken(SMTLIBv2Parser.PK_Notes, 0); }
public TerminalNode PK_Pattern() { return getToken(SMTLIBv2Parser.PK_Pattern, 0); }
public TerminalNode PK_PrintSuccess() { return getToken(SMTLIBv2Parser.PK_PrintSuccess, 0); }
public TerminalNode PK_ProduceAssertions() { return getToken(SMTLIBv2Parser.PK_ProduceAssertions, 0); }
public TerminalNode PK_ProduceAssignments() { return getToken(SMTLIBv2Parser.PK_ProduceAssignments, 0); }
public TerminalNode PK_ProduceModels() { return getToken(SMTLIBv2Parser.PK_ProduceModels, 0); }
public TerminalNode PK_ProduceProofs() { return getToken(SMTLIBv2Parser.PK_ProduceProofs, 0); }
public TerminalNode PK_ProduceUnsatAssumptions() { return getToken(SMTLIBv2Parser.PK_ProduceUnsatAssumptions, 0); }
public TerminalNode PK_ProduceUnsatCores() { return getToken(SMTLIBv2Parser.PK_ProduceUnsatCores, 0); }
public TerminalNode PK_RandomSeed() { return getToken(SMTLIBv2Parser.PK_RandomSeed, 0); }
public TerminalNode PK_ReasonUnknown() { return getToken(SMTLIBv2Parser.PK_ReasonUnknown, 0); }
public TerminalNode PK_RegularOutputChannel() { return getToken(SMTLIBv2Parser.PK_RegularOutputChannel, 0); }
public TerminalNode PK_ReproducibleResourceLimit() { return getToken(SMTLIBv2Parser.PK_ReproducibleResourceLimit, 0); }
public TerminalNode PK_RightAssoc() { return getToken(SMTLIBv2Parser.PK_RightAssoc, 0); }
public TerminalNode PK_SmtLibVersion() { return getToken(SMTLIBv2Parser.PK_SmtLibVersion, 0); }
public TerminalNode PK_Sorts() { return getToken(SMTLIBv2Parser.PK_Sorts, 0); }
public TerminalNode PK_SortsDescription() { return getToken(SMTLIBv2Parser.PK_SortsDescription, 0); }
public TerminalNode PK_Source() { return getToken(SMTLIBv2Parser.PK_Source, 0); }
public TerminalNode PK_Status() { return getToken(SMTLIBv2Parser.PK_Status, 0); }
public TerminalNode PK_Theories() { return getToken(SMTLIBv2Parser.PK_Theories, 0); }
public TerminalNode PK_Values() { return getToken(SMTLIBv2Parser.PK_Values, 0); }
public TerminalNode PK_Verbosity() { return getToken(SMTLIBv2Parser.PK_Verbosity, 0); }
public TerminalNode PK_Version() { return getToken(SMTLIBv2Parser.PK_Version, 0); }
public PredefKeywordContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_predefKeyword; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterPredefKeyword(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitPredefKeyword(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitPredefKeyword(this);
else return visitor.visitChildren(this);
}
}
public final PredefKeywordContext predefKeyword() throws RecognitionException {
PredefKeywordContext _localctx = new PredefKeywordContext(_ctx, getState());
enterRule(_localctx, 38, RULE_predefKeyword);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(220);
_la = _input.LA(1);
if ( !(((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & ((1L << (PK_AllStatistics - 72)) | (1L << (PK_AssertionStackLevels - 72)) | (1L << (PK_Authors - 72)) | (1L << (PK_Category - 72)) | (1L << (PK_Chainable - 72)) | (1L << (PK_Definition - 72)) | (1L << (PK_DiagnosticOutputChannel - 72)) | (1L << (PK_ErrorBehaviour - 72)) | (1L << (PK_Extension - 72)) | (1L << (PK_Funs - 72)) | (1L << (PK_FunsDescription - 72)) | (1L << (PK_GlobalDeclarations - 72)) | (1L << (PK_InteractiveMode - 72)) | (1L << (PK_Language - 72)) | (1L << (PK_LeftAssoc - 72)) | (1L << (PK_License - 72)) | (1L << (PK_Named - 72)) | (1L << (PK_Name - 72)) | (1L << (PK_Notes - 72)) | (1L << (PK_Pattern - 72)) | (1L << (PK_PrintSuccess - 72)) | (1L << (PK_ProduceAssertions - 72)) | (1L << (PK_ProduceAssignments - 72)) | (1L << (PK_ProduceModels - 72)) | (1L << (PK_ProduceProofs - 72)) | (1L << (PK_ProduceUnsatAssumptions - 72)) | (1L << (PK_ProduceUnsatCores - 72)) | (1L << (PK_RandomSeed - 72)) | (1L << (PK_ReasonUnknown - 72)) | (1L << (PK_RegularOutputChannel - 72)) | (1L << (PK_ReproducibleResourceLimit - 72)) | (1L << (PK_RightAssoc - 72)) | (1L << (PK_SmtLibVersion - 72)) | (1L << (PK_Sorts - 72)) | (1L << (PK_SortsDescription - 72)) | (1L << (PK_Source - 72)) | (1L << (PK_Status - 72)) | (1L << (PK_Theories - 72)) | (1L << (PK_Values - 72)) | (1L << (PK_Verbosity - 72)) | (1L << (PK_Version - 72)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SymbolContext extends ParserRuleContext {
public SimpleSymbolContext simpleSymbol() {
return getRuleContext(SimpleSymbolContext.class,0);
}
public QuotedSymbolContext quotedSymbol() {
return getRuleContext(QuotedSymbolContext.class,0);
}
public SymbolContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_symbol; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterSymbol(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitSymbol(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitSymbol(this);
else return visitor.visitChildren(this);
}
}
public final SymbolContext symbol() throws RecognitionException {
SymbolContext _localctx = new SymbolContext(_ctx, getState());
enterRule(_localctx, 40, RULE_symbol);
try {
setState(224);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PS_Not:
case PS_Bool:
case PS_ContinuedExecution:
case PS_Error:
case PS_False:
case PS_ImmediateExit:
case PS_Incomplete:
case PS_Logic:
case PS_Memout:
case PS_Sat:
case PS_Success:
case PS_Theory:
case PS_True:
case PS_Unknown:
case PS_Unsupported:
case PS_Unsat:
case UndefinedSymbol:
enterOuterAlt(_localctx, 1);
{
setState(222);
simpleSymbol();
}
break;
case QuotedSymbol:
enterOuterAlt(_localctx, 2);
{
setState(223);
quotedSymbol();
}
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 NumeralContext extends ParserRuleContext {
public TerminalNode Numeral() { return getToken(SMTLIBv2Parser.Numeral, 0); }
public NumeralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_numeral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterNumeral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitNumeral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitNumeral(this);
else return visitor.visitChildren(this);
}
}
public final NumeralContext numeral() throws RecognitionException {
NumeralContext _localctx = new NumeralContext(_ctx, getState());
enterRule(_localctx, 42, RULE_numeral);
try {
enterOuterAlt(_localctx, 1);
{
setState(226);
match(Numeral);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DecimalContext extends ParserRuleContext {
public TerminalNode Decimal() { return getToken(SMTLIBv2Parser.Decimal, 0); }
public DecimalContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_decimal; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterDecimal(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitDecimal(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitDecimal(this);
else return visitor.visitChildren(this);
}
}
public final DecimalContext decimal() throws RecognitionException {
DecimalContext _localctx = new DecimalContext(_ctx, getState());
enterRule(_localctx, 44, RULE_decimal);
try {
enterOuterAlt(_localctx, 1);
{
setState(228);
match(Decimal);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HexadecimalContext extends ParserRuleContext {
public TerminalNode HexDecimal() { return getToken(SMTLIBv2Parser.HexDecimal, 0); }
public HexadecimalContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_hexadecimal; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterHexadecimal(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitHexadecimal(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitHexadecimal(this);
else return visitor.visitChildren(this);
}
}
public final HexadecimalContext hexadecimal() throws RecognitionException {
HexadecimalContext _localctx = new HexadecimalContext(_ctx, getState());
enterRule(_localctx, 46, RULE_hexadecimal);
try {
enterOuterAlt(_localctx, 1);
{
setState(230);
match(HexDecimal);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BinaryContext extends ParserRuleContext {
public TerminalNode Binary() { return getToken(SMTLIBv2Parser.Binary, 0); }
public BinaryContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_binary; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterBinary(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitBinary(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitBinary(this);
else return visitor.visitChildren(this);
}
}
public final BinaryContext binary() throws RecognitionException {
BinaryContext _localctx = new BinaryContext(_ctx, getState());
enterRule(_localctx, 48, RULE_binary);
try {
enterOuterAlt(_localctx, 1);
{
setState(232);
match(Binary);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StringContext extends ParserRuleContext {
public TerminalNode String() { return getToken(SMTLIBv2Parser.String, 0); }
public StringContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_string; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterString(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitString(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitString(this);
else return visitor.visitChildren(this);
}
}
public final StringContext string() throws RecognitionException {
StringContext _localctx = new StringContext(_ctx, getState());
enterRule(_localctx, 50, RULE_string);
try {
enterOuterAlt(_localctx, 1);
{
setState(234);
match(String);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class KeywordContext extends ParserRuleContext {
public PredefKeywordContext predefKeyword() {
return getRuleContext(PredefKeywordContext.class,0);
}
public TerminalNode Colon() { return getToken(SMTLIBv2Parser.Colon, 0); }
public SimpleSymbolContext simpleSymbol() {
return getRuleContext(SimpleSymbolContext.class,0);
}
public KeywordContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_keyword; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterKeyword(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitKeyword(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitKeyword(this);
else return visitor.visitChildren(this);
}
}
public final KeywordContext keyword() throws RecognitionException {
KeywordContext _localctx = new KeywordContext(_ctx, getState());
enterRule(_localctx, 52, RULE_keyword);
try {
setState(239);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PK_AllStatistics:
case PK_AssertionStackLevels:
case PK_Authors:
case PK_Category:
case PK_Chainable:
case PK_Definition:
case PK_DiagnosticOutputChannel:
case PK_ErrorBehaviour:
case PK_Extension:
case PK_Funs:
case PK_FunsDescription:
case PK_GlobalDeclarations:
case PK_InteractiveMode:
case PK_Language:
case PK_LeftAssoc:
case PK_License:
case PK_Named:
case PK_Name:
case PK_Notes:
case PK_Pattern:
case PK_PrintSuccess:
case PK_ProduceAssertions:
case PK_ProduceAssignments:
case PK_ProduceModels:
case PK_ProduceProofs:
case PK_ProduceUnsatAssumptions:
case PK_ProduceUnsatCores:
case PK_RandomSeed:
case PK_ReasonUnknown:
case PK_RegularOutputChannel:
case PK_ReproducibleResourceLimit:
case PK_RightAssoc:
case PK_SmtLibVersion:
case PK_Sorts:
case PK_SortsDescription:
case PK_Source:
case PK_Status:
case PK_Theories:
case PK_Values:
case PK_Verbosity:
case PK_Version:
enterOuterAlt(_localctx, 1);
{
setState(236);
predefKeyword();
}
break;
case Colon:
enterOuterAlt(_localctx, 2);
{
setState(237);
match(Colon);
setState(238);
simpleSymbol();
}
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 Spec_constantContext extends ParserRuleContext {
public NumeralContext numeral() {
return getRuleContext(NumeralContext.class,0);
}
public DecimalContext decimal() {
return getRuleContext(DecimalContext.class,0);
}
public HexadecimalContext hexadecimal() {
return getRuleContext(HexadecimalContext.class,0);
}
public BinaryContext binary() {
return getRuleContext(BinaryContext.class,0);
}
public StringContext string() {
return getRuleContext(StringContext.class,0);
}
public Spec_constantContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_spec_constant; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterSpec_constant(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitSpec_constant(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitSpec_constant(this);
else return visitor.visitChildren(this);
}
}
public final Spec_constantContext spec_constant() throws RecognitionException {
Spec_constantContext _localctx = new Spec_constantContext(_ctx, getState());
enterRule(_localctx, 54, RULE_spec_constant);
try {
setState(246);
_errHandler.sync(this);
switch (_input.LA(1)) {
case Numeral:
enterOuterAlt(_localctx, 1);
{
setState(241);
numeral();
}
break;
case Decimal:
enterOuterAlt(_localctx, 2);
{
setState(242);
decimal();
}
break;
case HexDecimal:
enterOuterAlt(_localctx, 3);
{
setState(243);
hexadecimal();
}
break;
case Binary:
enterOuterAlt(_localctx, 4);
{
setState(244);
binary();
}
break;
case String:
enterOuterAlt(_localctx, 5);
{
setState(245);
string();
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class S_exprContext extends ParserRuleContext {
public Spec_constantContext spec_constant() {
return getRuleContext(Spec_constantContext.class,0);
}
public SymbolContext symbol() {
return getRuleContext(SymbolContext.class,0);
}
public KeywordContext keyword() {
return getRuleContext(KeywordContext.class,0);
}
public TerminalNode ParOpen() { return getToken(SMTLIBv2Parser.ParOpen, 0); }
public TerminalNode ParClose() { return getToken(SMTLIBv2Parser.ParClose, 0); }
public List s_expr() {
return getRuleContexts(S_exprContext.class);
}
public S_exprContext s_expr(int i) {
return getRuleContext(S_exprContext.class,i);
}
public S_exprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_s_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterS_expr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitS_expr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitS_expr(this);
else return visitor.visitChildren(this);
}
}
public final S_exprContext s_expr() throws RecognitionException {
S_exprContext _localctx = new S_exprContext(_ctx, getState());
enterRule(_localctx, 56, RULE_s_expr);
int _la;
try {
setState(259);
_errHandler.sync(this);
switch (_input.LA(1)) {
case String:
case Numeral:
case Binary:
case HexDecimal:
case Decimal:
enterOuterAlt(_localctx, 1);
{
setState(248);
spec_constant();
}
break;
case QuotedSymbol:
case PS_Not:
case PS_Bool:
case PS_ContinuedExecution:
case PS_Error:
case PS_False:
case PS_ImmediateExit:
case PS_Incomplete:
case PS_Logic:
case PS_Memout:
case PS_Sat:
case PS_Success:
case PS_Theory:
case PS_True:
case PS_Unknown:
case PS_Unsupported:
case PS_Unsat:
case UndefinedSymbol:
enterOuterAlt(_localctx, 2);
{
setState(249);
symbol();
}
break;
case Colon:
case PK_AllStatistics:
case PK_AssertionStackLevels:
case PK_Authors:
case PK_Category:
case PK_Chainable:
case PK_Definition:
case PK_DiagnosticOutputChannel:
case PK_ErrorBehaviour:
case PK_Extension:
case PK_Funs:
case PK_FunsDescription:
case PK_GlobalDeclarations:
case PK_InteractiveMode:
case PK_Language:
case PK_LeftAssoc:
case PK_License:
case PK_Named:
case PK_Name:
case PK_Notes:
case PK_Pattern:
case PK_PrintSuccess:
case PK_ProduceAssertions:
case PK_ProduceAssignments:
case PK_ProduceModels:
case PK_ProduceProofs:
case PK_ProduceUnsatAssumptions:
case PK_ProduceUnsatCores:
case PK_RandomSeed:
case PK_ReasonUnknown:
case PK_RegularOutputChannel:
case PK_ReproducibleResourceLimit:
case PK_RightAssoc:
case PK_SmtLibVersion:
case PK_Sorts:
case PK_SortsDescription:
case PK_Source:
case PK_Status:
case PK_Theories:
case PK_Values:
case PK_Verbosity:
case PK_Version:
enterOuterAlt(_localctx, 3);
{
setState(250);
keyword();
}
break;
case ParOpen:
enterOuterAlt(_localctx, 4);
{
setState(251);
match(ParOpen);
setState(255);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ParOpen) | (1L << String) | (1L << QuotedSymbol) | (1L << PS_Not) | (1L << PS_Bool) | (1L << PS_ContinuedExecution) | (1L << PS_Error) | (1L << PS_False) | (1L << PS_ImmediateExit) | (1L << PS_Incomplete) | (1L << PS_Logic) | (1L << PS_Memout) | (1L << PS_Sat) | (1L << PS_Success) | (1L << PS_Theory) | (1L << PS_True) | (1L << PS_Unknown) | (1L << PS_Unsupported) | (1L << PS_Unsat))) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & ((1L << (Numeral - 67)) | (1L << (Binary - 67)) | (1L << (HexDecimal - 67)) | (1L << (Decimal - 67)) | (1L << (Colon - 67)) | (1L << (PK_AllStatistics - 67)) | (1L << (PK_AssertionStackLevels - 67)) | (1L << (PK_Authors - 67)) | (1L << (PK_Category - 67)) | (1L << (PK_Chainable - 67)) | (1L << (PK_Definition - 67)) | (1L << (PK_DiagnosticOutputChannel - 67)) | (1L << (PK_ErrorBehaviour - 67)) | (1L << (PK_Extension - 67)) | (1L << (PK_Funs - 67)) | (1L << (PK_FunsDescription - 67)) | (1L << (PK_GlobalDeclarations - 67)) | (1L << (PK_InteractiveMode - 67)) | (1L << (PK_Language - 67)) | (1L << (PK_LeftAssoc - 67)) | (1L << (PK_License - 67)) | (1L << (PK_Named - 67)) | (1L << (PK_Name - 67)) | (1L << (PK_Notes - 67)) | (1L << (PK_Pattern - 67)) | (1L << (PK_PrintSuccess - 67)) | (1L << (PK_ProduceAssertions - 67)) | (1L << (PK_ProduceAssignments - 67)) | (1L << (PK_ProduceModels - 67)) | (1L << (PK_ProduceProofs - 67)) | (1L << (PK_ProduceUnsatAssumptions - 67)) | (1L << (PK_ProduceUnsatCores - 67)) | (1L << (PK_RandomSeed - 67)) | (1L << (PK_ReasonUnknown - 67)) | (1L << (PK_RegularOutputChannel - 67)) | (1L << (PK_ReproducibleResourceLimit - 67)) | (1L << (PK_RightAssoc - 67)) | (1L << (PK_SmtLibVersion - 67)) | (1L << (PK_Sorts - 67)) | (1L << (PK_SortsDescription - 67)) | (1L << (PK_Source - 67)) | (1L << (PK_Status - 67)) | (1L << (PK_Theories - 67)) | (1L << (PK_Values - 67)) | (1L << (PK_Verbosity - 67)) | (1L << (PK_Version - 67)) | (1L << (UndefinedSymbol - 67)))) != 0)) {
{
{
setState(252);
s_expr();
}
}
setState(257);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(258);
match(ParClose);
}
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 IndexContext extends ParserRuleContext {
public NumeralContext numeral() {
return getRuleContext(NumeralContext.class,0);
}
public SymbolContext symbol() {
return getRuleContext(SymbolContext.class,0);
}
public IndexContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_index; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterIndex(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitIndex(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitIndex(this);
else return visitor.visitChildren(this);
}
}
public final IndexContext index() throws RecognitionException {
IndexContext _localctx = new IndexContext(_ctx, getState());
enterRule(_localctx, 58, RULE_index);
try {
setState(263);
_errHandler.sync(this);
switch (_input.LA(1)) {
case Numeral:
enterOuterAlt(_localctx, 1);
{
setState(261);
numeral();
}
break;
case QuotedSymbol:
case PS_Not:
case PS_Bool:
case PS_ContinuedExecution:
case PS_Error:
case PS_False:
case PS_ImmediateExit:
case PS_Incomplete:
case PS_Logic:
case PS_Memout:
case PS_Sat:
case PS_Success:
case PS_Theory:
case PS_True:
case PS_Unknown:
case PS_Unsupported:
case PS_Unsat:
case UndefinedSymbol:
enterOuterAlt(_localctx, 2);
{
setState(262);
symbol();
}
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 IdentifierContext extends ParserRuleContext {
public SymbolContext symbol() {
return getRuleContext(SymbolContext.class,0);
}
public TerminalNode ParOpen() { return getToken(SMTLIBv2Parser.ParOpen, 0); }
public TerminalNode GRW_Underscore() { return getToken(SMTLIBv2Parser.GRW_Underscore, 0); }
public TerminalNode ParClose() { return getToken(SMTLIBv2Parser.ParClose, 0); }
public List index() {
return getRuleContexts(IndexContext.class);
}
public IndexContext index(int i) {
return getRuleContext(IndexContext.class,i);
}
public IdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitIdentifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitIdentifier(this);
else return visitor.visitChildren(this);
}
}
public final IdentifierContext identifier() throws RecognitionException {
IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
enterRule(_localctx, 60, RULE_identifier);
int _la;
try {
setState(276);
_errHandler.sync(this);
switch (_input.LA(1)) {
case QuotedSymbol:
case PS_Not:
case PS_Bool:
case PS_ContinuedExecution:
case PS_Error:
case PS_False:
case PS_ImmediateExit:
case PS_Incomplete:
case PS_Logic:
case PS_Memout:
case PS_Sat:
case PS_Success:
case PS_Theory:
case PS_True:
case PS_Unknown:
case PS_Unsupported:
case PS_Unsat:
case UndefinedSymbol:
enterOuterAlt(_localctx, 1);
{
setState(265);
symbol();
}
break;
case ParOpen:
enterOuterAlt(_localctx, 2);
{
setState(266);
match(ParOpen);
setState(267);
match(GRW_Underscore);
setState(268);
symbol();
setState(270);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(269);
index();
}
}
setState(272);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << QuotedSymbol) | (1L << PS_Not) | (1L << PS_Bool) | (1L << PS_ContinuedExecution) | (1L << PS_Error) | (1L << PS_False) | (1L << PS_ImmediateExit) | (1L << PS_Incomplete) | (1L << PS_Logic) | (1L << PS_Memout) | (1L << PS_Sat) | (1L << PS_Success) | (1L << PS_Theory) | (1L << PS_True) | (1L << PS_Unknown) | (1L << PS_Unsupported) | (1L << PS_Unsat))) != 0) || _la==Numeral || _la==UndefinedSymbol );
setState(274);
match(ParClose);
}
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 Attribute_valueContext extends ParserRuleContext {
public Spec_constantContext spec_constant() {
return getRuleContext(Spec_constantContext.class,0);
}
public SymbolContext symbol() {
return getRuleContext(SymbolContext.class,0);
}
public TerminalNode ParOpen() { return getToken(SMTLIBv2Parser.ParOpen, 0); }
public TerminalNode ParClose() { return getToken(SMTLIBv2Parser.ParClose, 0); }
public List s_expr() {
return getRuleContexts(S_exprContext.class);
}
public S_exprContext s_expr(int i) {
return getRuleContext(S_exprContext.class,i);
}
public Attribute_valueContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attribute_value; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterAttribute_value(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitAttribute_value(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitAttribute_value(this);
else return visitor.visitChildren(this);
}
}
public final Attribute_valueContext attribute_value() throws RecognitionException {
Attribute_valueContext _localctx = new Attribute_valueContext(_ctx, getState());
enterRule(_localctx, 62, RULE_attribute_value);
int _la;
try {
setState(288);
_errHandler.sync(this);
switch (_input.LA(1)) {
case String:
case Numeral:
case Binary:
case HexDecimal:
case Decimal:
enterOuterAlt(_localctx, 1);
{
setState(278);
spec_constant();
}
break;
case QuotedSymbol:
case PS_Not:
case PS_Bool:
case PS_ContinuedExecution:
case PS_Error:
case PS_False:
case PS_ImmediateExit:
case PS_Incomplete:
case PS_Logic:
case PS_Memout:
case PS_Sat:
case PS_Success:
case PS_Theory:
case PS_True:
case PS_Unknown:
case PS_Unsupported:
case PS_Unsat:
case UndefinedSymbol:
enterOuterAlt(_localctx, 2);
{
setState(279);
symbol();
}
break;
case ParOpen:
enterOuterAlt(_localctx, 3);
{
setState(280);
match(ParOpen);
setState(284);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ParOpen) | (1L << String) | (1L << QuotedSymbol) | (1L << PS_Not) | (1L << PS_Bool) | (1L << PS_ContinuedExecution) | (1L << PS_Error) | (1L << PS_False) | (1L << PS_ImmediateExit) | (1L << PS_Incomplete) | (1L << PS_Logic) | (1L << PS_Memout) | (1L << PS_Sat) | (1L << PS_Success) | (1L << PS_Theory) | (1L << PS_True) | (1L << PS_Unknown) | (1L << PS_Unsupported) | (1L << PS_Unsat))) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & ((1L << (Numeral - 67)) | (1L << (Binary - 67)) | (1L << (HexDecimal - 67)) | (1L << (Decimal - 67)) | (1L << (Colon - 67)) | (1L << (PK_AllStatistics - 67)) | (1L << (PK_AssertionStackLevels - 67)) | (1L << (PK_Authors - 67)) | (1L << (PK_Category - 67)) | (1L << (PK_Chainable - 67)) | (1L << (PK_Definition - 67)) | (1L << (PK_DiagnosticOutputChannel - 67)) | (1L << (PK_ErrorBehaviour - 67)) | (1L << (PK_Extension - 67)) | (1L << (PK_Funs - 67)) | (1L << (PK_FunsDescription - 67)) | (1L << (PK_GlobalDeclarations - 67)) | (1L << (PK_InteractiveMode - 67)) | (1L << (PK_Language - 67)) | (1L << (PK_LeftAssoc - 67)) | (1L << (PK_License - 67)) | (1L << (PK_Named - 67)) | (1L << (PK_Name - 67)) | (1L << (PK_Notes - 67)) | (1L << (PK_Pattern - 67)) | (1L << (PK_PrintSuccess - 67)) | (1L << (PK_ProduceAssertions - 67)) | (1L << (PK_ProduceAssignments - 67)) | (1L << (PK_ProduceModels - 67)) | (1L << (PK_ProduceProofs - 67)) | (1L << (PK_ProduceUnsatAssumptions - 67)) | (1L << (PK_ProduceUnsatCores - 67)) | (1L << (PK_RandomSeed - 67)) | (1L << (PK_ReasonUnknown - 67)) | (1L << (PK_RegularOutputChannel - 67)) | (1L << (PK_ReproducibleResourceLimit - 67)) | (1L << (PK_RightAssoc - 67)) | (1L << (PK_SmtLibVersion - 67)) | (1L << (PK_Sorts - 67)) | (1L << (PK_SortsDescription - 67)) | (1L << (PK_Source - 67)) | (1L << (PK_Status - 67)) | (1L << (PK_Theories - 67)) | (1L << (PK_Values - 67)) | (1L << (PK_Verbosity - 67)) | (1L << (PK_Version - 67)) | (1L << (UndefinedSymbol - 67)))) != 0)) {
{
{
setState(281);
s_expr();
}
}
setState(286);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(287);
match(ParClose);
}
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 AttributeContext extends ParserRuleContext {
public KeywordContext keyword() {
return getRuleContext(KeywordContext.class,0);
}
public Attribute_valueContext attribute_value() {
return getRuleContext(Attribute_valueContext.class,0);
}
public AttributeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attribute; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterAttribute(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitAttribute(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitAttribute(this);
else return visitor.visitChildren(this);
}
}
public final AttributeContext attribute() throws RecognitionException {
AttributeContext _localctx = new AttributeContext(_ctx, getState());
enterRule(_localctx, 64, RULE_attribute);
try {
setState(294);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,23,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(290);
keyword();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(291);
keyword();
setState(292);
attribute_value();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SortContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode ParOpen() { return getToken(SMTLIBv2Parser.ParOpen, 0); }
public TerminalNode ParClose() { return getToken(SMTLIBv2Parser.ParClose, 0); }
public List sort() {
return getRuleContexts(SortContext.class);
}
public SortContext sort(int i) {
return getRuleContext(SortContext.class,i);
}
public SortContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sort; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterSort(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitSort(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitSort(this);
else return visitor.visitChildren(this);
}
}
public final SortContext sort() throws RecognitionException {
SortContext _localctx = new SortContext(_ctx, getState());
enterRule(_localctx, 66, RULE_sort);
int _la;
try {
setState(306);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(296);
identifier();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(297);
match(ParOpen);
setState(298);
identifier();
setState(300);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(299);
sort();
}
}
setState(302);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ParOpen) | (1L << QuotedSymbol) | (1L << PS_Not) | (1L << PS_Bool) | (1L << PS_ContinuedExecution) | (1L << PS_Error) | (1L << PS_False) | (1L << PS_ImmediateExit) | (1L << PS_Incomplete) | (1L << PS_Logic) | (1L << PS_Memout) | (1L << PS_Sat) | (1L << PS_Success) | (1L << PS_Theory) | (1L << PS_True) | (1L << PS_Unknown) | (1L << PS_Unsupported) | (1L << PS_Unsat))) != 0) || _la==UndefinedSymbol );
setState(304);
match(ParClose);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Qual_identifierContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode ParOpen() { return getToken(SMTLIBv2Parser.ParOpen, 0); }
public TerminalNode GRW_As() { return getToken(SMTLIBv2Parser.GRW_As, 0); }
public SortContext sort() {
return getRuleContext(SortContext.class,0);
}
public TerminalNode ParClose() { return getToken(SMTLIBv2Parser.ParClose, 0); }
public Qual_identifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qual_identifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterQual_identifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitQual_identifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitQual_identifier(this);
else return visitor.visitChildren(this);
}
}
public final Qual_identifierContext qual_identifier() throws RecognitionException {
Qual_identifierContext _localctx = new Qual_identifierContext(_ctx, getState());
enterRule(_localctx, 68, RULE_qual_identifier);
try {
setState(315);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(308);
identifier();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(309);
match(ParOpen);
setState(310);
match(GRW_As);
setState(311);
identifier();
setState(312);
sort();
setState(313);
match(ParClose);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Var_bindingContext extends ParserRuleContext {
public TerminalNode ParOpen() { return getToken(SMTLIBv2Parser.ParOpen, 0); }
public SymbolContext symbol() {
return getRuleContext(SymbolContext.class,0);
}
public TermContext term() {
return getRuleContext(TermContext.class,0);
}
public TerminalNode ParClose() { return getToken(SMTLIBv2Parser.ParClose, 0); }
public Var_bindingContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_var_binding; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterVar_binding(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitVar_binding(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitVar_binding(this);
else return visitor.visitChildren(this);
}
}
public final Var_bindingContext var_binding() throws RecognitionException {
Var_bindingContext _localctx = new Var_bindingContext(_ctx, getState());
enterRule(_localctx, 70, RULE_var_binding);
try {
enterOuterAlt(_localctx, 1);
{
setState(317);
match(ParOpen);
setState(318);
symbol();
setState(319);
term();
setState(320);
match(ParClose);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Sorted_varContext extends ParserRuleContext {
public TerminalNode ParOpen() { return getToken(SMTLIBv2Parser.ParOpen, 0); }
public SymbolContext symbol() {
return getRuleContext(SymbolContext.class,0);
}
public SortContext sort() {
return getRuleContext(SortContext.class,0);
}
public TerminalNode ParClose() { return getToken(SMTLIBv2Parser.ParClose, 0); }
public Sorted_varContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sorted_var; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterSorted_var(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitSorted_var(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitSorted_var(this);
else return visitor.visitChildren(this);
}
}
public final Sorted_varContext sorted_var() throws RecognitionException {
Sorted_varContext _localctx = new Sorted_varContext(_ctx, getState());
enterRule(_localctx, 72, RULE_sorted_var);
try {
enterOuterAlt(_localctx, 1);
{
setState(322);
match(ParOpen);
setState(323);
symbol();
setState(324);
sort();
setState(325);
match(ParClose);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PatternContext extends ParserRuleContext {
public List symbol() {
return getRuleContexts(SymbolContext.class);
}
public SymbolContext symbol(int i) {
return getRuleContext(SymbolContext.class,i);
}
public TerminalNode ParOpen() { return getToken(SMTLIBv2Parser.ParOpen, 0); }
public TerminalNode ParClose() { return getToken(SMTLIBv2Parser.ParClose, 0); }
public PatternContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pattern; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterPattern(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitPattern(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitPattern(this);
else return visitor.visitChildren(this);
}
}
public final PatternContext pattern() throws RecognitionException {
PatternContext _localctx = new PatternContext(_ctx, getState());
enterRule(_localctx, 74, RULE_pattern);
int _la;
try {
setState(337);
_errHandler.sync(this);
switch (_input.LA(1)) {
case QuotedSymbol:
case PS_Not:
case PS_Bool:
case PS_ContinuedExecution:
case PS_Error:
case PS_False:
case PS_ImmediateExit:
case PS_Incomplete:
case PS_Logic:
case PS_Memout:
case PS_Sat:
case PS_Success:
case PS_Theory:
case PS_True:
case PS_Unknown:
case PS_Unsupported:
case PS_Unsat:
case UndefinedSymbol:
enterOuterAlt(_localctx, 1);
{
setState(327);
symbol();
}
break;
case ParOpen:
enterOuterAlt(_localctx, 2);
{
setState(328);
match(ParOpen);
setState(329);
symbol();
setState(331);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(330);
symbol();
}
}
setState(333);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << QuotedSymbol) | (1L << PS_Not) | (1L << PS_Bool) | (1L << PS_ContinuedExecution) | (1L << PS_Error) | (1L << PS_False) | (1L << PS_ImmediateExit) | (1L << PS_Incomplete) | (1L << PS_Logic) | (1L << PS_Memout) | (1L << PS_Sat) | (1L << PS_Success) | (1L << PS_Theory) | (1L << PS_True) | (1L << PS_Unknown) | (1L << PS_Unsupported) | (1L << PS_Unsat))) != 0) || _la==UndefinedSymbol );
setState(335);
match(ParClose);
}
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 Match_caseContext extends ParserRuleContext {
public TerminalNode ParOpen() { return getToken(SMTLIBv2Parser.ParOpen, 0); }
public PatternContext pattern() {
return getRuleContext(PatternContext.class,0);
}
public TermContext term() {
return getRuleContext(TermContext.class,0);
}
public TerminalNode ParClose() { return getToken(SMTLIBv2Parser.ParClose, 0); }
public Match_caseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_match_case; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterMatch_case(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitMatch_case(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitMatch_case(this);
else return visitor.visitChildren(this);
}
}
public final Match_caseContext match_case() throws RecognitionException {
Match_caseContext _localctx = new Match_caseContext(_ctx, getState());
enterRule(_localctx, 76, RULE_match_case);
try {
enterOuterAlt(_localctx, 1);
{
setState(339);
match(ParOpen);
setState(340);
pattern();
setState(341);
term();
setState(342);
match(ParClose);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TermContext extends ParserRuleContext {
public Spec_constantContext spec_constant() {
return getRuleContext(Spec_constantContext.class,0);
}
public Qual_identifierContext qual_identifier() {
return getRuleContext(Qual_identifierContext.class,0);
}
public Generic_termContext generic_term() {
return getRuleContext(Generic_termContext.class,0);
}
public Let_termContext let_term() {
return getRuleContext(Let_termContext.class,0);
}
public Forall_termContext forall_term() {
return getRuleContext(Forall_termContext.class,0);
}
public Exists_termContext exists_term() {
return getRuleContext(Exists_termContext.class,0);
}
public Match_termContext match_term() {
return getRuleContext(Match_termContext.class,0);
}
public Annotate_termContext annotate_term() {
return getRuleContext(Annotate_termContext.class,0);
}
public TermContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_term; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterTerm(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitTerm(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitTerm(this);
else return visitor.visitChildren(this);
}
}
public final TermContext term() throws RecognitionException {
TermContext _localctx = new TermContext(_ctx, getState());
enterRule(_localctx, 78, RULE_term);
try {
setState(352);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,29,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(344);
spec_constant();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(345);
qual_identifier();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(346);
generic_term();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(347);
let_term();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(348);
forall_term();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(349);
exists_term();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(350);
match_term();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(351);
annotate_term();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Generic_termContext extends ParserRuleContext {
public TerminalNode ParOpen() { return getToken(SMTLIBv2Parser.ParOpen, 0); }
public Qual_identifierContext qual_identifier() {
return getRuleContext(Qual_identifierContext.class,0);
}
public TerminalNode ParClose() { return getToken(SMTLIBv2Parser.ParClose, 0); }
public List term() {
return getRuleContexts(TermContext.class);
}
public TermContext term(int i) {
return getRuleContext(TermContext.class,i);
}
public Generic_termContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_generic_term; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterGeneric_term(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitGeneric_term(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitGeneric_term(this);
else return visitor.visitChildren(this);
}
}
public final Generic_termContext generic_term() throws RecognitionException {
Generic_termContext _localctx = new Generic_termContext(_ctx, getState());
enterRule(_localctx, 80, RULE_generic_term);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(354);
match(ParOpen);
setState(355);
qual_identifier();
setState(357);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(356);
term();
}
}
setState(359);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ParOpen) | (1L << String) | (1L << QuotedSymbol) | (1L << PS_Not) | (1L << PS_Bool) | (1L << PS_ContinuedExecution) | (1L << PS_Error) | (1L << PS_False) | (1L << PS_ImmediateExit) | (1L << PS_Incomplete) | (1L << PS_Logic) | (1L << PS_Memout) | (1L << PS_Sat) | (1L << PS_Success) | (1L << PS_Theory) | (1L << PS_True) | (1L << PS_Unknown) | (1L << PS_Unsupported) | (1L << PS_Unsat))) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & ((1L << (Numeral - 67)) | (1L << (Binary - 67)) | (1L << (HexDecimal - 67)) | (1L << (Decimal - 67)) | (1L << (UndefinedSymbol - 67)))) != 0) );
setState(361);
match(ParClose);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Let_termContext extends ParserRuleContext {
public List ParOpen() { return getTokens(SMTLIBv2Parser.ParOpen); }
public TerminalNode ParOpen(int i) {
return getToken(SMTLIBv2Parser.ParOpen, i);
}
public TerminalNode GRW_Let() { return getToken(SMTLIBv2Parser.GRW_Let, 0); }
public List ParClose() { return getTokens(SMTLIBv2Parser.ParClose); }
public TerminalNode ParClose(int i) {
return getToken(SMTLIBv2Parser.ParClose, i);
}
public TermContext term() {
return getRuleContext(TermContext.class,0);
}
public List var_binding() {
return getRuleContexts(Var_bindingContext.class);
}
public Var_bindingContext var_binding(int i) {
return getRuleContext(Var_bindingContext.class,i);
}
public Let_termContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_let_term; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterLet_term(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitLet_term(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitLet_term(this);
else return visitor.visitChildren(this);
}
}
public final Let_termContext let_term() throws RecognitionException {
Let_termContext _localctx = new Let_termContext(_ctx, getState());
enterRule(_localctx, 82, RULE_let_term);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(363);
match(ParOpen);
setState(364);
match(GRW_Let);
setState(365);
match(ParOpen);
setState(367);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(366);
var_binding();
}
}
setState(369);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==ParOpen );
setState(371);
match(ParClose);
setState(372);
term();
setState(373);
match(ParClose);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Forall_termContext extends ParserRuleContext {
public List ParOpen() { return getTokens(SMTLIBv2Parser.ParOpen); }
public TerminalNode ParOpen(int i) {
return getToken(SMTLIBv2Parser.ParOpen, i);
}
public TerminalNode GRW_Forall() { return getToken(SMTLIBv2Parser.GRW_Forall, 0); }
public List ParClose() { return getTokens(SMTLIBv2Parser.ParClose); }
public TerminalNode ParClose(int i) {
return getToken(SMTLIBv2Parser.ParClose, i);
}
public TermContext term() {
return getRuleContext(TermContext.class,0);
}
public List sorted_var() {
return getRuleContexts(Sorted_varContext.class);
}
public Sorted_varContext sorted_var(int i) {
return getRuleContext(Sorted_varContext.class,i);
}
public Forall_termContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forall_term; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterForall_term(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitForall_term(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitForall_term(this);
else return visitor.visitChildren(this);
}
}
public final Forall_termContext forall_term() throws RecognitionException {
Forall_termContext _localctx = new Forall_termContext(_ctx, getState());
enterRule(_localctx, 84, RULE_forall_term);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(375);
match(ParOpen);
setState(376);
match(GRW_Forall);
setState(377);
match(ParOpen);
setState(379);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(378);
sorted_var();
}
}
setState(381);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==ParOpen );
setState(383);
match(ParClose);
setState(384);
term();
setState(385);
match(ParClose);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Exists_termContext extends ParserRuleContext {
public List ParOpen() { return getTokens(SMTLIBv2Parser.ParOpen); }
public TerminalNode ParOpen(int i) {
return getToken(SMTLIBv2Parser.ParOpen, i);
}
public TerminalNode GRW_Exists() { return getToken(SMTLIBv2Parser.GRW_Exists, 0); }
public List ParClose() { return getTokens(SMTLIBv2Parser.ParClose); }
public TerminalNode ParClose(int i) {
return getToken(SMTLIBv2Parser.ParClose, i);
}
public TermContext term() {
return getRuleContext(TermContext.class,0);
}
public List sorted_var() {
return getRuleContexts(Sorted_varContext.class);
}
public Sorted_varContext sorted_var(int i) {
return getRuleContext(Sorted_varContext.class,i);
}
public Exists_termContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exists_term; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterExists_term(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitExists_term(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitExists_term(this);
else return visitor.visitChildren(this);
}
}
public final Exists_termContext exists_term() throws RecognitionException {
Exists_termContext _localctx = new Exists_termContext(_ctx, getState());
enterRule(_localctx, 86, RULE_exists_term);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(387);
match(ParOpen);
setState(388);
match(GRW_Exists);
setState(389);
match(ParOpen);
setState(391);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(390);
sorted_var();
}
}
setState(393);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==ParOpen );
setState(395);
match(ParClose);
setState(396);
term();
setState(397);
match(ParClose);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Match_termContext extends ParserRuleContext {
public List ParOpen() { return getTokens(SMTLIBv2Parser.ParOpen); }
public TerminalNode ParOpen(int i) {
return getToken(SMTLIBv2Parser.ParOpen, i);
}
public TerminalNode GRW_Match() { return getToken(SMTLIBv2Parser.GRW_Match, 0); }
public TermContext term() {
return getRuleContext(TermContext.class,0);
}
public List ParClose() { return getTokens(SMTLIBv2Parser.ParClose); }
public TerminalNode ParClose(int i) {
return getToken(SMTLIBv2Parser.ParClose, i);
}
public List match_case() {
return getRuleContexts(Match_caseContext.class);
}
public Match_caseContext match_case(int i) {
return getRuleContext(Match_caseContext.class,i);
}
public Match_termContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_match_term; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterMatch_term(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitMatch_term(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitMatch_term(this);
else return visitor.visitChildren(this);
}
}
public final Match_termContext match_term() throws RecognitionException {
Match_termContext _localctx = new Match_termContext(_ctx, getState());
enterRule(_localctx, 88, RULE_match_term);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(399);
match(ParOpen);
setState(400);
match(GRW_Match);
setState(401);
term();
setState(402);
match(ParOpen);
setState(404);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(403);
match_case();
}
}
setState(406);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==ParOpen );
setState(408);
match(ParClose);
setState(409);
match(ParClose);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Annotate_termContext extends ParserRuleContext {
public TerminalNode ParOpen() { return getToken(SMTLIBv2Parser.ParOpen, 0); }
public TerminalNode GRW_Exclamation() { return getToken(SMTLIBv2Parser.GRW_Exclamation, 0); }
public TermContext term() {
return getRuleContext(TermContext.class,0);
}
public TerminalNode ParClose() { return getToken(SMTLIBv2Parser.ParClose, 0); }
public List attribute() {
return getRuleContexts(AttributeContext.class);
}
public AttributeContext attribute(int i) {
return getRuleContext(AttributeContext.class,i);
}
public Annotate_termContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_annotate_term; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).enterAnnotate_term(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof SMTLIBv2Listener ) ((SMTLIBv2Listener)listener).exitAnnotate_term(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof SMTLIBv2Visitor ) return ((SMTLIBv2Visitor)visitor).visitAnnotate_term(this);
else return visitor.visitChildren(this);
}
}
public final Annotate_termContext annotate_term() throws RecognitionException {
Annotate_termContext _localctx = new Annotate_termContext(_ctx, getState());
enterRule(_localctx, 90, RULE_annotate_term);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(411);
match(ParOpen);
setState(412);
match(GRW_Exclamation);
setState(413);
term();
setState(415);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(414);
attribute();
}
}
setState(417);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( ((((_la - 71)) & ~0x3f) == 0 && ((1L << (_la - 71)) & ((1L << (Colon - 71)) | (1L << (PK_AllStatistics - 71)) | (1L << (PK_AssertionStackLevels - 71)) | (1L << (PK_Authors - 71)) | (1L << (PK_Category - 71)) | (1L << (PK_Chainable - 71)) | (1L << (PK_Definition - 71)) | (1L << (PK_DiagnosticOutputChannel - 71)) | (1L << (PK_ErrorBehaviour - 71)) | (1L << (PK_Extension - 71)) | (1L << (PK_Funs - 71)) | (1L << (PK_FunsDescription - 71)) | (1L << (PK_GlobalDeclarations - 71)) | (1L << (PK_InteractiveMode - 71)) | (1L << (PK_Language - 71)) | (1L << (PK_LeftAssoc - 71)) | (1L << (PK_License - 71)) | (1L << (PK_Named - 71)) | (1L << (PK_Name - 71)) | (1L << (PK_Notes - 71)) | (1L << (PK_Pattern - 71)) | (1L << (PK_PrintSuccess - 71)) | (1L << (PK_ProduceAssertions - 71)) | (1L << (PK_ProduceAssignments - 71)) | (1L << (PK_ProduceModels - 71)) | (1L << (PK_ProduceProofs - 71)) | (1L << (PK_ProduceUnsatAssumptions - 71)) | (1L << (PK_ProduceUnsatCores - 71)) | (1L << (PK_RandomSeed - 71)) | (1L << (PK_ReasonUnknown - 71)) | (1L << (PK_RegularOutputChannel - 71)) | (1L << (PK_ReproducibleResourceLimit - 71)) | (1L << (PK_RightAssoc - 71)) | (1L << (PK_SmtLibVersion - 71)) | (1L << (PK_Sorts - 71)) | (1L << (PK_SortsDescription - 71)) | (1L << (PK_Source - 71)) | (1L << (PK_Status - 71)) | (1L << (PK_Theories - 71)) | (1L << (PK_Values - 71)) | (1L << (PK_Verbosity - 71)) | (1L << (PK_Version - 71)))) != 0) );
setState(419);
match(ParClose);
}
}
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\3t\u01a8\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/\3\2\3\2\3\2\3\2\5\2c\n\2\3\3\3\3\3\4\3\4\3\5\3"+
"\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\5\6r\n\6\3\7\3\7\3\7\5\7w\n\7\3\b\3\b\7"+
"\b{\n\b\f\b\16\b~\13\b\3\b\3\b\3\t\3\t\5\t\u0084\n\t\3\t\7\t\u0087\n\t"+
"\f\t\16\t\u008a\13\t\3\t\3\t\3\n\3\n\3\n\3\n\5\n\u0092\n\n\3\13\3\13\3"+
"\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\r\3\r\3\r\3\r\6\r\u00a2\n\r\r\r\16"+
"\r\u00a3\3\r\3\r\3\r\6\r\u00a9\n\r\r\r\16\r\u00aa\3\r\3\r\3\r\3\16\3\16"+
"\3\16\3\16\3\16\3\17\3\17\3\17\7\17\u00b8\n\17\f\17\16\17\u00bb\13\17"+
"\3\17\3\17\3\17\3\17\3\20\3\20\3\20\3\20\7\20\u00c5\n\20\f\20\16\20\u00c8"+
"\13\20\3\20\3\20\3\20\3\20\3\21\3\21\7\21\u00d0\n\21\f\21\16\21\u00d3"+
"\13\21\3\21\3\21\3\22\3\22\5\22\u00d9\n\22\3\23\3\23\3\24\3\24\3\25\3"+
"\25\3\26\3\26\5\26\u00e3\n\26\3\27\3\27\3\30\3\30\3\31\3\31\3\32\3\32"+
"\3\33\3\33\3\34\3\34\3\34\5\34\u00f2\n\34\3\35\3\35\3\35\3\35\3\35\5\35"+
"\u00f9\n\35\3\36\3\36\3\36\3\36\3\36\7\36\u0100\n\36\f\36\16\36\u0103"+
"\13\36\3\36\5\36\u0106\n\36\3\37\3\37\5\37\u010a\n\37\3 \3 \3 \3 \3 \6"+
" \u0111\n \r \16 \u0112\3 \3 \5 \u0117\n \3!\3!\3!\3!\7!\u011d\n!\f!\16"+
"!\u0120\13!\3!\5!\u0123\n!\3\"\3\"\3\"\3\"\5\"\u0129\n\"\3#\3#\3#\3#\6"+
"#\u012f\n#\r#\16#\u0130\3#\3#\5#\u0135\n#\3$\3$\3$\3$\3$\3$\3$\5$\u013e"+
"\n$\3%\3%\3%\3%\3%\3&\3&\3&\3&\3&\3\'\3\'\3\'\3\'\6\'\u014e\n\'\r\'\16"+
"\'\u014f\3\'\3\'\5\'\u0154\n\'\3(\3(\3(\3(\3(\3)\3)\3)\3)\3)\3)\3)\3)"+
"\5)\u0163\n)\3*\3*\3*\6*\u0168\n*\r*\16*\u0169\3*\3*\3+\3+\3+\3+\6+\u0172"+
"\n+\r+\16+\u0173\3+\3+\3+\3+\3,\3,\3,\3,\6,\u017e\n,\r,\16,\u017f\3,\3"+
",\3,\3,\3-\3-\3-\3-\6-\u018a\n-\r-\16-\u018b\3-\3-\3-\3-\3.\3.\3.\3.\3"+
".\6.\u0197\n.\r.\16.\u0198\3.\3.\3.\3/\3/\3/\3/\6/\u01a2\n/\r/\16/\u01a3"+
"\3/\3/\3/\2\2\60\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62"+
"\64\668:<>@BDFHJLNPRTVXZ\\\2\4\4\2\t\21\23\31\3\2Jr\2\u01b0\2b\3\2\2\2"+
"\4d\3\2\2\2\6f\3\2\2\2\bh\3\2\2\2\nq\3\2\2\2\fv\3\2\2\2\16x\3\2\2\2\20"+
"\u0081\3\2\2\2\22\u0091\3\2\2\2\24\u0093\3\2\2\2\26\u0098\3\2\2\2\30\u009d"+
"\3\2\2\2\32\u00af\3\2\2\2\34\u00b4\3\2\2\2\36\u00c0\3\2\2\2 \u00cd\3\2"+
"\2\2\"\u00d8\3\2\2\2$\u00da\3\2\2\2&\u00dc\3\2\2\2(\u00de\3\2\2\2*\u00e2"+
"\3\2\2\2,\u00e4\3\2\2\2.\u00e6\3\2\2\2\60\u00e8\3\2\2\2\62\u00ea\3\2\2"+
"\2\64\u00ec\3\2\2\2\66\u00f1\3\2\2\28\u00f8\3\2\2\2:\u0105\3\2\2\2<\u0109"+
"\3\2\2\2>\u0116\3\2\2\2@\u0122\3\2\2\2B\u0128\3\2\2\2D\u0134\3\2\2\2F"+
"\u013d\3\2\2\2H\u013f\3\2\2\2J\u0144\3\2\2\2L\u0153\3\2\2\2N\u0155\3\2"+
"\2\2P\u0162\3\2\2\2R\u0164\3\2\2\2T\u016d\3\2\2\2V\u0179\3\2\2\2X\u0185"+
"\3\2\2\2Z\u0191\3\2\2\2\\\u019d\3\2\2\2^c\5\4\3\2_c\5\6\4\2`c\5\b\5\2"+
"ac\5\n\6\2b^\3\2\2\2b_\3\2\2\2b`\3\2\2\2ba\3\2\2\2c\3\3\2\2\2de\7\24\2"+
"\2e\5\3\2\2\2fg\7\30\2\2g\7\3\2\2\2hi\7\4\2\2ij\7\f\2\2jk\7\7\2\2kl\7"+
"\5\2\2l\t\3\2\2\2mr\5\f\7\2nr\5\16\b\2or\5\20\t\2pr\5 \21\2qm\3\2\2\2"+
"qn\3\2\2\2qo\3\2\2\2qp\3\2\2\2r\13\3\2\2\2sw\7\23\2\2tw\7\31\2\2uw\7\27"+
"\2\2vs\3\2\2\2vt\3\2\2\2vu\3\2\2\2w\r\3\2\2\2x|\7\4\2\2y{\5*\26\2zy\3"+
"\2\2\2{~\3\2\2\2|z\3\2\2\2|}\3\2\2\2}\177\3\2\2\2~|\3\2\2\2\177\u0080"+
"\7\5\2\2\u0080\17\3\2\2\2\u0081\u0083\7\4\2\2\u0082\u0084\7\22\2\2\u0083"+
"\u0082\3\2\2\2\u0083\u0084\3\2\2\2\u0084\u0088\3\2\2\2\u0085\u0087\5\22"+
"\n\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\u008b\3\2\2\2\u008a\u0088\3\2\2\2\u008b\u008c\7\5"+
"\2\2\u008c\21\3\2\2\2\u008d\u0092\5\24\13\2\u008e\u0092\5\26\f\2\u008f"+
"\u0092\5\30\r\2\u0090\u0092\5\32\16\2\u0091\u008d\3\2\2\2\u0091\u008e"+
"\3\2\2\2\u0091\u008f\3\2\2\2\u0091\u0090\3\2\2\2\u0092\23\3\2\2\2\u0093"+
"\u0094\7\4\2\2\u0094\u0095\7\"\2\2\u0095\u0096\5\34\17\2\u0096\u0097\7"+
"\5\2\2\u0097\25\3\2\2\2\u0098\u0099\7\4\2\2\u0099\u009a\7#\2\2\u009a\u009b"+
"\5\34\17\2\u009b\u009c\7\5\2\2\u009c\27\3\2\2\2\u009d\u009e\7\4\2\2\u009e"+
"\u009f\7$\2\2\u009f\u00a1\7\4\2\2\u00a0\u00a2\5\36\20\2\u00a1\u00a0\3"+
"\2\2\2\u00a2\u00a3\3\2\2\2\u00a3\u00a1\3\2\2\2\u00a3\u00a4\3\2\2\2\u00a4"+
"\u00a5\3\2\2\2\u00a5\u00a6\7\5\2\2\u00a6\u00a8\7\4\2\2\u00a7\u00a9\5P"+
")\2\u00a8\u00a7\3\2\2\2\u00a9\u00aa\3\2\2\2\u00aa\u00a8\3\2\2\2\u00aa"+
"\u00ab\3\2\2\2\u00ab\u00ac\3\2\2\2\u00ac\u00ad\7\5\2\2\u00ad\u00ae\7\5"+
"\2\2\u00ae\31\3\2\2\2\u00af\u00b0\7\4\2\2\u00b0\u00b1\5*\26\2\u00b1\u00b2"+
"\5P)\2\u00b2\u00b3\7\5\2\2\u00b3\33\3\2\2\2\u00b4\u00b5\5*\26\2\u00b5"+
"\u00b9\7\4\2\2\u00b6\u00b8\5J&\2\u00b7\u00b6\3\2\2\2\u00b8\u00bb\3\2\2"+
"\2\u00b9\u00b7\3\2\2\2\u00b9\u00ba\3\2\2\2\u00ba\u00bc\3\2\2\2\u00bb\u00b9"+
"\3\2\2\2\u00bc\u00bd\7\5\2\2\u00bd\u00be\5D#\2\u00be\u00bf\5P)\2\u00bf"+
"\35\3\2\2\2\u00c0\u00c1\7\4\2\2\u00c1\u00c2\5*\26\2\u00c2\u00c6\7\4\2"+
"\2\u00c3\u00c5\5J&\2\u00c4\u00c3\3\2\2\2\u00c5\u00c8\3\2\2\2\u00c6\u00c4"+
"\3\2\2\2\u00c6\u00c7\3\2\2\2\u00c7\u00c9\3\2\2\2\u00c8\u00c6\3\2\2\2\u00c9"+
"\u00ca\7\5\2\2\u00ca\u00cb\5D#\2\u00cb\u00cc\7\5\2\2\u00cc\37\3\2\2\2"+
"\u00cd\u00d1\7\4\2\2\u00ce\u00d0\5P)\2\u00cf\u00ce\3\2\2\2\u00d0\u00d3"+
"\3\2\2\2\u00d1\u00cf\3\2\2\2\u00d1\u00d2\3\2\2\2\u00d2\u00d4\3\2\2\2\u00d3"+
"\u00d1\3\2\2\2\u00d4\u00d5\7\5\2\2\u00d5!\3\2\2\2\u00d6\u00d9\5&\24\2"+
"\u00d7\u00d9\7s\2\2\u00d8\u00d6\3\2\2\2\u00d8\u00d7\3\2\2\2\u00d9#\3\2"+
"\2\2\u00da\u00db\7\b\2\2\u00db%\3\2\2\2\u00dc\u00dd\t\2\2\2\u00dd\'\3"+
"\2\2\2\u00de\u00df\t\3\2\2\u00df)\3\2\2\2\u00e0\u00e3\5\"\22\2\u00e1\u00e3"+
"\5$\23\2\u00e2\u00e0\3\2\2\2\u00e2\u00e1\3\2\2\2\u00e3+\3\2\2\2\u00e4"+
"\u00e5\7E\2\2\u00e5-\3\2\2\2\u00e6\u00e7\7H\2\2\u00e7/\3\2\2\2\u00e8\u00e9"+
"\7G\2\2\u00e9\61\3\2\2\2\u00ea\u00eb\7F\2\2\u00eb\63\3\2\2\2\u00ec\u00ed"+
"\7\7\2\2\u00ed\65\3\2\2\2\u00ee\u00f2\5(\25\2\u00ef\u00f0\7I\2\2\u00f0"+
"\u00f2\5\"\22\2\u00f1\u00ee\3\2\2\2\u00f1\u00ef\3\2\2\2\u00f2\67\3\2\2"+
"\2\u00f3\u00f9\5,\27\2\u00f4\u00f9\5.\30\2\u00f5\u00f9\5\60\31\2\u00f6"+
"\u00f9\5\62\32\2\u00f7\u00f9\5\64\33\2\u00f8\u00f3\3\2\2\2\u00f8\u00f4"+
"\3\2\2\2\u00f8\u00f5\3\2\2\2\u00f8\u00f6\3\2\2\2\u00f8\u00f7\3\2\2\2\u00f9"+
"9\3\2\2\2\u00fa\u0106\58\35\2\u00fb\u0106\5*\26\2\u00fc\u0106\5\66\34"+
"\2\u00fd\u0101\7\4\2\2\u00fe\u0100\5:\36\2\u00ff\u00fe\3\2\2\2\u0100\u0103"+
"\3\2\2\2\u0101\u00ff\3\2\2\2\u0101\u0102\3\2\2\2\u0102\u0104\3\2\2\2\u0103"+
"\u0101\3\2\2\2\u0104\u0106\7\5\2\2\u0105\u00fa\3\2\2\2\u0105\u00fb\3\2"+
"\2\2\u0105\u00fc\3\2\2\2\u0105\u00fd\3\2\2\2\u0106;\3\2\2\2\u0107\u010a"+
"\5,\27\2\u0108\u010a\5*\26\2\u0109\u0107\3\2\2\2\u0109\u0108\3\2\2\2\u010a"+
"=\3\2\2\2\u010b\u0117\5*\26\2\u010c\u010d\7\4\2\2\u010d\u010e\79\2\2\u010e"+
"\u0110\5*\26\2\u010f\u0111\5<\37\2\u0110\u010f\3\2\2\2\u0111\u0112\3\2"+
"\2\2\u0112\u0110\3\2\2\2\u0112\u0113\3\2\2\2\u0113\u0114\3\2\2\2\u0114"+
"\u0115\7\5\2\2\u0115\u0117\3\2\2\2\u0116\u010b\3\2\2\2\u0116\u010c\3\2"+
"\2\2\u0117?\3\2\2\2\u0118\u0123\58\35\2\u0119\u0123\5*\26\2\u011a\u011e"+
"\7\4\2\2\u011b\u011d\5:\36\2\u011c\u011b\3\2\2\2\u011d\u0120\3\2\2\2\u011e"+
"\u011c\3\2\2\2\u011e\u011f\3\2\2\2\u011f\u0121\3\2\2\2\u0120\u011e\3\2"+
"\2\2\u0121\u0123\7\5\2\2\u0122\u0118\3\2\2\2\u0122\u0119\3\2\2\2\u0122"+
"\u011a\3\2\2\2\u0123A\3\2\2\2\u0124\u0129\5\66\34\2\u0125\u0126\5\66\34"+
"\2\u0126\u0127\5@!\2\u0127\u0129\3\2\2\2\u0128\u0124\3\2\2\2\u0128\u0125"+
"\3\2\2\2\u0129C\3\2\2\2\u012a\u0135\5> \2\u012b\u012c\7\4\2\2\u012c\u012e"+
"\5> \2\u012d\u012f\5D#\2\u012e\u012d\3\2\2\2\u012f\u0130\3\2\2\2\u0130"+
"\u012e\3\2\2\2\u0130\u0131\3\2\2\2\u0131\u0132\3\2\2\2\u0132\u0133\7\5"+
"\2\2\u0133\u0135\3\2\2\2\u0134\u012a\3\2\2\2\u0134\u012b\3\2\2\2\u0135"+
"E\3\2\2\2\u0136\u013e\5> \2\u0137\u0138\7\4\2\2\u0138\u0139\7:\2\2\u0139"+
"\u013a\5> \2\u013a\u013b\5D#\2\u013b\u013c\7\5\2\2\u013c\u013e\3\2\2\2"+
"\u013d\u0136\3\2\2\2\u013d\u0137\3\2\2\2\u013eG\3\2\2\2\u013f\u0140\7"+
"\4\2\2\u0140\u0141\5*\26\2\u0141\u0142\5P)\2\u0142\u0143\7\5\2\2\u0143"+
"I\3\2\2\2\u0144\u0145\7\4\2\2\u0145\u0146\5*\26\2\u0146\u0147\5D#\2\u0147"+
"\u0148\7\5\2\2\u0148K\3\2\2\2\u0149\u0154\5*\26\2\u014a\u014b\7\4\2\2"+
"\u014b\u014d\5*\26\2\u014c\u014e\5*\26\2\u014d\u014c\3\2\2\2\u014e\u014f"+
"\3\2\2\2\u014f\u014d\3\2\2\2\u014f\u0150\3\2\2\2\u0150\u0151\3\2\2\2\u0151"+
"\u0152\7\5\2\2\u0152\u0154\3\2\2\2\u0153\u0149\3\2\2\2\u0153\u014a\3\2"+
"\2\2\u0154M\3\2\2\2\u0155\u0156\7\4\2\2\u0156\u0157\5L\'\2\u0157\u0158"+
"\5P)\2\u0158\u0159\7\5\2\2\u0159O\3\2\2\2\u015a\u0163\58\35\2\u015b\u0163"+
"\5F$\2\u015c\u0163\5R*\2\u015d\u0163\5T+\2\u015e\u0163\5V,\2\u015f\u0163"+
"\5X-\2\u0160\u0163\5Z.\2\u0161\u0163\5\\/\2\u0162\u015a\3\2\2\2\u0162"+
"\u015b\3\2\2\2\u0162\u015c\3\2\2\2\u0162\u015d\3\2\2\2\u0162\u015e\3\2"+
"\2\2\u0162\u015f\3\2\2\2\u0162\u0160\3\2\2\2\u0162\u0161\3\2\2\2\u0163"+
"Q\3\2\2\2\u0164\u0165\7\4\2\2\u0165\u0167\5F$\2\u0166\u0168\5P)\2\u0167"+
"\u0166\3\2\2\2\u0168\u0169\3\2\2\2\u0169\u0167\3\2\2\2\u0169\u016a\3\2"+
"\2\2\u016a\u016b\3\2\2\2\u016b\u016c\7\5\2\2\u016cS\3\2\2\2\u016d\u016e"+
"\7\4\2\2\u016e\u016f\7@\2\2\u016f\u0171\7\4\2\2\u0170\u0172\5H%\2\u0171"+
"\u0170\3\2\2\2\u0172\u0173\3\2\2\2\u0173\u0171\3\2\2\2\u0173\u0174\3\2"+
"\2\2\u0174\u0175\3\2\2\2\u0175\u0176\7\5\2\2\u0176\u0177\5P)\2\u0177\u0178"+
"\7\5\2\2\u0178U\3\2\2\2\u0179\u017a\7\4\2\2\u017a\u017b\7?\2\2\u017b\u017d"+
"\7\4\2\2\u017c\u017e\5J&\2\u017d\u017c\3\2\2\2\u017e\u017f\3\2\2\2\u017f"+
"\u017d\3\2\2\2\u017f\u0180\3\2\2\2\u0180\u0181\3\2\2\2\u0181\u0182\7\5"+
"\2\2\u0182\u0183\5P)\2\u0183\u0184\7\5\2\2\u0184W\3\2\2\2\u0185\u0186"+
"\7\4\2\2\u0186\u0187\7=\2\2\u0187\u0189\7\4\2\2\u0188\u018a\5J&\2\u0189"+
"\u0188\3\2\2\2\u018a\u018b\3\2\2\2\u018b\u0189\3\2\2\2\u018b\u018c\3\2"+
"\2\2\u018c\u018d\3\2\2\2\u018d\u018e\7\5\2\2\u018e\u018f\5P)\2\u018f\u0190"+
"\7\5\2\2\u0190Y\3\2\2\2\u0191\u0192\7\4\2\2\u0192\u0193\7A\2\2\u0193\u0194"+
"\5P)\2\u0194\u0196\7\4\2\2\u0195\u0197\5N(\2\u0196\u0195\3\2\2\2\u0197"+
"\u0198\3\2\2\2\u0198\u0196\3\2\2\2\u0198\u0199\3\2\2\2\u0199\u019a\3\2"+
"\2\2\u019a\u019b\7\5\2\2\u019b\u019c\7\5\2\2\u019c[\3\2\2\2\u019d\u019e"+
"\7\4\2\2\u019e\u019f\78\2\2\u019f\u01a1\5P)\2\u01a0\u01a2\5B\"\2\u01a1"+
"\u01a0\3\2\2\2\u01a2\u01a3\3\2\2\2\u01a3\u01a1\3\2\2\2\u01a3\u01a4\3\2"+
"\2\2\u01a4\u01a5\3\2\2\2\u01a5\u01a6\7\5\2\2\u01a6]\3\2\2\2&bqv|\u0083"+
"\u0088\u0091\u00a3\u00aa\u00b9\u00c6\u00d1\u00d8\u00e2\u00f1\u00f8\u0101"+
"\u0105\u0109\u0112\u0116\u011e\u0122\u0128\u0130\u0134\u013d\u014f\u0153"+
"\u0162\u0169\u0173\u017f\u018b\u0198\u01a3";
public static final ATN _ATN =
new ATNDeserializer().deserialize(_serializedATN.toCharArray());
static {
_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
}
}
} © 2015 - 2025 Weber Informatics LLC | Privacy Policy