ltl-dsl.0.1.3.source-code.LtlParser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of ltl-dsl Show documentation
Show all versions of ltl-dsl Show documentation
Parser for a LTL Pattern DSL
// Generated from /builds/stups/prob/ltl-pattern-parser/src/main/antlr/Ltl.g4 by ANTLR 4.7.2
package de.prob.ltl.parser;
import de.prob.ltl.parser.prolog.LtlPrologTermGenerator;
import de.prob.ltl.parser.pattern.PatternManager;
import de.prob.ltl.parser.semantic.SemanticCheck;
import de.prob.ltl.parser.symboltable.SymbolTableManager;
import de.prob.parserbase.ProBParserBase;
import de.prob.prolog.output.StructuredPrologOutput;
import de.prob.prolog.term.PrologTerm;
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 LtlParser extends Parser {
static { RuntimeMetaData.checkVersion("4.7.2", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
T__0=1, T__1=2, TRUE=3, FALSE=4, SINK=5, DEADLOCK=6, CURRENT=7, GLOBALLY=8,
FINALLY=9, NEXT=10, HISTORICALLY=11, ONCE=12, YESTERDAY=13, UNARY_COMBINED=14,
UNTIL=15, WEAKUNTIL=16, RELEASE=17, SINCE=18, TRIGGER=19, NOT=20, AND=21,
OR=22, IMPLIES=23, PREDICATE=24, ACTION=25, ENABLED=26, LEFT_CURLY=27,
RIGHT_CURLY=28, LEFT_BRACKET=29, RIGHT_BRACKET=30, LEFT_PAREN=31, RIGHT_PAREN=32,
COMMENT=33, PATTERN_DEF=34, BEFORE_SCOPE=35, AFTER_SCOPE=36, BETWEEN_SCOPE=37,
UNTIL_SCOPE=38, VAR=39, NUM_VAR=40, SEQ_VAR=41, SEQ_WITHOUT=42, LOOP_BEGIN=43,
LOOP_END=44, UP=45, DOWN=46, TO=47, NUM=48, ID=49, WS=50;
public static final int
RULE_start = 0, RULE_start_pattern_def = 1, RULE_body = 2, RULE_argument = 3,
RULE_pattern_def = 4, RULE_pattern_def_param = 5, RULE_pattern_call = 6,
RULE_scope_call = 7, RULE_var_def = 8, RULE_var_assign = 9, RULE_seq_def = 10,
RULE_seq_call = 11, RULE_loop = 12, RULE_loop_body = 13, RULE_expr = 14,
RULE_atom = 15;
private static String[] makeRuleNames() {
return new String[] {
"start", "start_pattern_def", "body", "argument", "pattern_def", "pattern_def_param",
"pattern_call", "scope_call", "var_def", "var_assign", "seq_def", "seq_call",
"loop", "loop_body", "expr", "atom"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, "','", "':'", "'true'", "'false'", "'sink'", "'deadlock'", "'current'",
"'G'", "'F'", "'X'", "'H'", "'O'", "'Y'", null, "'U'", "'W'", "'R'",
"'S'", "'T'", null, null, null, "'=>'", null, null, null, "'{'", "'}'",
"'['", "']'", "'('", "')'", null, "'def'", "'before'", "'after'", "'between'",
"'after_until'", "'var'", "'num'", "'seq'", "'without'", "'count'", "'end'",
"'up'", "'down'", "'to'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, null, null, "TRUE", "FALSE", "SINK", "DEADLOCK", "CURRENT", "GLOBALLY",
"FINALLY", "NEXT", "HISTORICALLY", "ONCE", "YESTERDAY", "UNARY_COMBINED",
"UNTIL", "WEAKUNTIL", "RELEASE", "SINCE", "TRIGGER", "NOT", "AND", "OR",
"IMPLIES", "PREDICATE", "ACTION", "ENABLED", "LEFT_CURLY", "RIGHT_CURLY",
"LEFT_BRACKET", "RIGHT_BRACKET", "LEFT_PAREN", "RIGHT_PAREN", "COMMENT",
"PATTERN_DEF", "BEFORE_SCOPE", "AFTER_SCOPE", "BETWEEN_SCOPE", "UNTIL_SCOPE",
"VAR", "NUM_VAR", "SEQ_VAR", "SEQ_WITHOUT", "LOOP_BEGIN", "LOOP_END",
"UP", "DOWN", "TO", "NUM", "ID", "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 "Ltl.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
private SymbolTableManager symbolTableManager = new SymbolTableManager();
private PatternManager patternManager;
private List warningListeners = new ArrayList();
private LtlLexer lexer;
private SemanticCheck semanticCheck;
private ParseTree lastAst;
public LtlParser(String input) {
this(new CommonTokenStream(new LtlLexer(new ANTLRInputStream(input))));
if (getTokenStream().getTokenSource() instanceof LtlLexer) {
lexer = (LtlLexer) getTokenStream().getTokenSource();
}
}
public void parse() {
if (patternManager != null) {
patternManager.updatePatterns(symbolTableManager);
}
StartContext ast = start();
lastAst = ast;
semanticCheck = new SemanticCheck(this);
semanticCheck.check(ast.body());
}
public void parsePatternDefinition() {
if (patternManager != null) {
patternManager.updatePatterns(symbolTableManager);
}
Start_pattern_defContext ast = start_pattern_def();
lastAst = ast;
semanticCheck = new SemanticCheck(this);
semanticCheck.check(ast);
}
public PrologTerm generatePrologTerm(String currentState, ProBParserBase parserBase) {
StructuredPrologOutput pto = new StructuredPrologOutput();
LtlPrologTermGenerator generator = new LtlPrologTermGenerator(this, currentState, parserBase);
if (semanticCheck.getBody() != null) {
generator.generatePrologTerm(semanticCheck.getBody(), pto);
pto.fullstop();
return pto.getSentences().get(0);
} else {
return null;
}
}
public SymbolTableManager getSymbolTableManager() {
return symbolTableManager;
}
public void setSymbolTableManager(SymbolTableManager symbolTableManager) {
this.symbolTableManager = symbolTableManager;
}
public PatternManager getPatternManager() {
return patternManager;
}
public void setPatternManager(PatternManager patternManager) {
this.patternManager = patternManager;
}
public LtlLexer getLexer() {
return lexer;
}
public ParseTree getAst() {
return lastAst;
}
@Override
public void addErrorListener(@NotNull ANTLRErrorListener listener) {
super.addErrorListener(listener);
lexer.addErrorListener(listener);
}
@Override
public void removeErrorListener(@NotNull ANTLRErrorListener listener) {
super.removeErrorListener(listener);
lexer.removeErrorListener(listener);
}
@Override
public void removeErrorListeners() {
super.removeErrorListeners();
lexer.removeErrorListeners();
}
public void addWarningListener(WarningListener listener) {
warningListeners.add(listener);
}
public List getWarningListeners() {
return warningListeners;
}
public void removeWarningListener(WarningListener listener) {
warningListeners.remove(listener);
}
public void removeWarningListeners() {
warningListeners.clear();
}
public void notifyWarningListeners(Token token, String message) {
for (WarningListener listener : warningListeners) {
listener.warning(token, message);
}
}
public LtlParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class StartContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(LtlParser.EOF, 0); }
public BodyContext body() {
return getRuleContext(BodyContext.class,0);
}
public StartContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_start; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterStart(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitStart(this);
}
}
public final StartContext start() throws RecognitionException {
StartContext _localctx = new StartContext(_ctx, getState());
enterRule(_localctx, 0, RULE_start);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(33);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << TRUE) | (1L << FALSE) | (1L << SINK) | (1L << DEADLOCK) | (1L << CURRENT) | (1L << GLOBALLY) | (1L << FINALLY) | (1L << NEXT) | (1L << HISTORICALLY) | (1L << ONCE) | (1L << YESTERDAY) | (1L << UNARY_COMBINED) | (1L << NOT) | (1L << PREDICATE) | (1L << ACTION) | (1L << ENABLED) | (1L << LEFT_PAREN) | (1L << PATTERN_DEF) | (1L << BEFORE_SCOPE) | (1L << AFTER_SCOPE) | (1L << BETWEEN_SCOPE) | (1L << UNTIL_SCOPE) | (1L << VAR) | (1L << NUM_VAR) | (1L << SEQ_VAR) | (1L << LOOP_BEGIN) | (1L << ID))) != 0)) {
{
setState(32);
body();
}
}
setState(35);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Start_pattern_defContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(LtlParser.EOF, 0); }
public List pattern_def() {
return getRuleContexts(Pattern_defContext.class);
}
public Pattern_defContext pattern_def(int i) {
return getRuleContext(Pattern_defContext.class,i);
}
public Start_pattern_defContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_start_pattern_def; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterStart_pattern_def(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitStart_pattern_def(this);
}
}
public final Start_pattern_defContext start_pattern_def() throws RecognitionException {
Start_pattern_defContext _localctx = new Start_pattern_defContext(_ctx, getState());
enterRule(_localctx, 2, RULE_start_pattern_def);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(40);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==PATTERN_DEF) {
{
{
setState(37);
pattern_def();
}
}
setState(42);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(43);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BodyContext extends ParserRuleContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public List pattern_def() {
return getRuleContexts(Pattern_defContext.class);
}
public Pattern_defContext pattern_def(int i) {
return getRuleContext(Pattern_defContext.class,i);
}
public List var_def() {
return getRuleContexts(Var_defContext.class);
}
public Var_defContext var_def(int i) {
return getRuleContext(Var_defContext.class,i);
}
public List var_assign() {
return getRuleContexts(Var_assignContext.class);
}
public Var_assignContext var_assign(int i) {
return getRuleContext(Var_assignContext.class,i);
}
public List loop() {
return getRuleContexts(LoopContext.class);
}
public LoopContext loop(int i) {
return getRuleContext(LoopContext.class,i);
}
public BodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_body; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterBody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitBody(this);
}
}
public final BodyContext body() throws RecognitionException {
BodyContext _localctx = new BodyContext(_ctx, getState());
enterRule(_localctx, 4, RULE_body);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(51);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,3,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
setState(49);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PATTERN_DEF:
{
setState(45);
pattern_def();
}
break;
case VAR:
case NUM_VAR:
case SEQ_VAR:
{
setState(46);
var_def();
}
break;
case ID:
{
setState(47);
var_assign();
}
break;
case LOOP_BEGIN:
{
setState(48);
loop();
}
break;
default:
throw new NoViableAltException(this);
}
}
}
setState(53);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,3,_ctx);
}
setState(54);
expr(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArgumentContext extends ParserRuleContext {
public ArgumentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_argument; }
public ArgumentContext() { }
public void copyFrom(ArgumentContext ctx) {
super.copyFrom(ctx);
}
}
public static class NumArgumentContext extends ArgumentContext {
public TerminalNode NUM() { return getToken(LtlParser.NUM, 0); }
public NumArgumentContext(ArgumentContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterNumArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitNumArgument(this);
}
}
public static class VarArgumentContext extends ArgumentContext {
public TerminalNode ID() { return getToken(LtlParser.ID, 0); }
public VarArgumentContext(ArgumentContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterVarArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitVarArgument(this);
}
}
public static class SeqArgumentContext extends ArgumentContext {
public Seq_defContext seq_def() {
return getRuleContext(Seq_defContext.class,0);
}
public SeqArgumentContext(ArgumentContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterSeqArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitSeqArgument(this);
}
}
public static class ParArgumentContext extends ArgumentContext {
public TerminalNode LEFT_PAREN() { return getToken(LtlParser.LEFT_PAREN, 0); }
public ArgumentContext argument() {
return getRuleContext(ArgumentContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(LtlParser.RIGHT_PAREN, 0); }
public ParArgumentContext(ArgumentContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterParArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitParArgument(this);
}
}
public static class ExprArgumentContext extends ArgumentContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public ExprArgumentContext(ArgumentContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterExprArgument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitExprArgument(this);
}
}
public final ArgumentContext argument() throws RecognitionException {
ArgumentContext _localctx = new ArgumentContext(_ctx, getState());
enterRule(_localctx, 6, RULE_argument);
try {
setState(64);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
case 1:
_localctx = new VarArgumentContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(56);
match(ID);
}
break;
case 2:
_localctx = new NumArgumentContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(57);
match(NUM);
}
break;
case 3:
_localctx = new SeqArgumentContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(58);
seq_def();
}
break;
case 4:
_localctx = new ParArgumentContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(59);
match(LEFT_PAREN);
setState(60);
argument();
setState(61);
match(RIGHT_PAREN);
}
break;
case 5:
_localctx = new ExprArgumentContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(63);
expr(0);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Pattern_defContext extends ParserRuleContext {
public TerminalNode PATTERN_DEF() { return getToken(LtlParser.PATTERN_DEF, 0); }
public TerminalNode ID() { return getToken(LtlParser.ID, 0); }
public TerminalNode LEFT_PAREN() { return getToken(LtlParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(LtlParser.RIGHT_PAREN, 0); }
public BodyContext body() {
return getRuleContext(BodyContext.class,0);
}
public List pattern_def_param() {
return getRuleContexts(Pattern_def_paramContext.class);
}
public Pattern_def_paramContext pattern_def_param(int i) {
return getRuleContext(Pattern_def_paramContext.class,i);
}
public Pattern_defContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pattern_def; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterPattern_def(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitPattern_def(this);
}
}
public final Pattern_defContext pattern_def() throws RecognitionException {
Pattern_defContext _localctx = new Pattern_defContext(_ctx, getState());
enterRule(_localctx, 8, RULE_pattern_def);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(66);
match(PATTERN_DEF);
setState(67);
match(ID);
setState(68);
match(LEFT_PAREN);
setState(77);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==ID) {
{
setState(69);
pattern_def_param();
setState(74);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__0) {
{
{
setState(70);
match(T__0);
setState(71);
pattern_def_param();
}
}
setState(76);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(79);
match(RIGHT_PAREN);
setState(80);
match(T__1);
setState(81);
body();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Pattern_def_paramContext extends ParserRuleContext {
public Pattern_def_paramContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pattern_def_param; }
public Pattern_def_paramContext() { }
public void copyFrom(Pattern_def_paramContext ctx) {
super.copyFrom(ctx);
}
}
public static class VarParamContext extends Pattern_def_paramContext {
public TerminalNode ID() { return getToken(LtlParser.ID, 0); }
public VarParamContext(Pattern_def_paramContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterVarParam(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitVarParam(this);
}
}
public static class NumVarParamContext extends Pattern_def_paramContext {
public TerminalNode ID() { return getToken(LtlParser.ID, 0); }
public TerminalNode NUM_VAR() { return getToken(LtlParser.NUM_VAR, 0); }
public NumVarParamContext(Pattern_def_paramContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterNumVarParam(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitNumVarParam(this);
}
}
public static class SeqVarParamContext extends Pattern_def_paramContext {
public TerminalNode ID() { return getToken(LtlParser.ID, 0); }
public TerminalNode SEQ_VAR() { return getToken(LtlParser.SEQ_VAR, 0); }
public SeqVarParamContext(Pattern_def_paramContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterSeqVarParam(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitSeqVarParam(this);
}
}
public final Pattern_def_paramContext pattern_def_param() throws RecognitionException {
Pattern_def_paramContext _localctx = new Pattern_def_paramContext(_ctx, getState());
enterRule(_localctx, 10, RULE_pattern_def_param);
try {
setState(90);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
case 1:
_localctx = new VarParamContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(83);
match(ID);
}
break;
case 2:
_localctx = new NumVarParamContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(84);
match(ID);
setState(85);
match(T__1);
setState(86);
match(NUM_VAR);
}
break;
case 3:
_localctx = new SeqVarParamContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(87);
match(ID);
setState(88);
match(T__1);
setState(89);
match(SEQ_VAR);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Pattern_callContext extends ParserRuleContext {
public TerminalNode ID() { return getToken(LtlParser.ID, 0); }
public TerminalNode LEFT_PAREN() { return getToken(LtlParser.LEFT_PAREN, 0); }
public TerminalNode RIGHT_PAREN() { return getToken(LtlParser.RIGHT_PAREN, 0); }
public List argument() {
return getRuleContexts(ArgumentContext.class);
}
public ArgumentContext argument(int i) {
return getRuleContext(ArgumentContext.class,i);
}
public Pattern_callContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pattern_call; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterPattern_call(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitPattern_call(this);
}
}
public final Pattern_callContext pattern_call() throws RecognitionException {
Pattern_callContext _localctx = new Pattern_callContext(_ctx, getState());
enterRule(_localctx, 12, RULE_pattern_call);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(92);
match(ID);
setState(93);
match(LEFT_PAREN);
setState(102);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << TRUE) | (1L << FALSE) | (1L << SINK) | (1L << DEADLOCK) | (1L << CURRENT) | (1L << GLOBALLY) | (1L << FINALLY) | (1L << NEXT) | (1L << HISTORICALLY) | (1L << ONCE) | (1L << YESTERDAY) | (1L << UNARY_COMBINED) | (1L << NOT) | (1L << PREDICATE) | (1L << ACTION) | (1L << ENABLED) | (1L << LEFT_PAREN) | (1L << BEFORE_SCOPE) | (1L << AFTER_SCOPE) | (1L << BETWEEN_SCOPE) | (1L << UNTIL_SCOPE) | (1L << SEQ_VAR) | (1L << NUM) | (1L << ID))) != 0)) {
{
setState(94);
argument();
setState(99);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==T__0) {
{
{
setState(95);
match(T__0);
setState(96);
argument();
}
}
setState(101);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(104);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Scope_callContext extends ParserRuleContext {
public TerminalNode LEFT_PAREN() { return getToken(LtlParser.LEFT_PAREN, 0); }
public List argument() {
return getRuleContexts(ArgumentContext.class);
}
public ArgumentContext argument(int i) {
return getRuleContext(ArgumentContext.class,i);
}
public TerminalNode RIGHT_PAREN() { return getToken(LtlParser.RIGHT_PAREN, 0); }
public TerminalNode BEFORE_SCOPE() { return getToken(LtlParser.BEFORE_SCOPE, 0); }
public TerminalNode AFTER_SCOPE() { return getToken(LtlParser.AFTER_SCOPE, 0); }
public TerminalNode BETWEEN_SCOPE() { return getToken(LtlParser.BETWEEN_SCOPE, 0); }
public TerminalNode UNTIL_SCOPE() { return getToken(LtlParser.UNTIL_SCOPE, 0); }
public Scope_callContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_scope_call; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterScope_call(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitScope_call(this);
}
}
public final Scope_callContext scope_call() throws RecognitionException {
Scope_callContext _localctx = new Scope_callContext(_ctx, getState());
enterRule(_localctx, 14, RULE_scope_call);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(106);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BEFORE_SCOPE) | (1L << AFTER_SCOPE) | (1L << BETWEEN_SCOPE) | (1L << UNTIL_SCOPE))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(107);
match(LEFT_PAREN);
setState(108);
argument();
setState(109);
match(T__0);
setState(110);
argument();
setState(113);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__0) {
{
setState(111);
match(T__0);
setState(112);
argument();
}
}
setState(115);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Var_defContext extends ParserRuleContext {
public TerminalNode ID() { return getToken(LtlParser.ID, 0); }
public ArgumentContext argument() {
return getRuleContext(ArgumentContext.class,0);
}
public TerminalNode VAR() { return getToken(LtlParser.VAR, 0); }
public TerminalNode NUM_VAR() { return getToken(LtlParser.NUM_VAR, 0); }
public TerminalNode SEQ_VAR() { return getToken(LtlParser.SEQ_VAR, 0); }
public Var_defContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_var_def; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterVar_def(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitVar_def(this);
}
}
public final Var_defContext var_def() throws RecognitionException {
Var_defContext _localctx = new Var_defContext(_ctx, getState());
enterRule(_localctx, 16, RULE_var_def);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(117);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << VAR) | (1L << NUM_VAR) | (1L << SEQ_VAR))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(118);
match(ID);
setState(119);
match(T__1);
setState(120);
argument();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Var_assignContext extends ParserRuleContext {
public TerminalNode ID() { return getToken(LtlParser.ID, 0); }
public ArgumentContext argument() {
return getRuleContext(ArgumentContext.class,0);
}
public Var_assignContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_var_assign; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterVar_assign(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitVar_assign(this);
}
}
public final Var_assignContext var_assign() throws RecognitionException {
Var_assignContext _localctx = new Var_assignContext(_ctx, getState());
enterRule(_localctx, 18, RULE_var_assign);
try {
enterOuterAlt(_localctx, 1);
{
setState(122);
match(ID);
setState(123);
match(T__1);
setState(124);
argument();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Seq_defContext extends ParserRuleContext {
public Seq_defContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_seq_def; }
public Seq_defContext() { }
public void copyFrom(Seq_defContext ctx) {
super.copyFrom(ctx);
}
}
public static class SeqDefinitionContext extends Seq_defContext {
public TerminalNode LEFT_PAREN() { return getToken(LtlParser.LEFT_PAREN, 0); }
public List argument() {
return getRuleContexts(ArgumentContext.class);
}
public ArgumentContext argument(int i) {
return getRuleContext(ArgumentContext.class,i);
}
public TerminalNode RIGHT_PAREN() { return getToken(LtlParser.RIGHT_PAREN, 0); }
public TerminalNode SEQ_WITHOUT() { return getToken(LtlParser.SEQ_WITHOUT, 0); }
public SeqDefinitionContext(Seq_defContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterSeqDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitSeqDefinition(this);
}
}
public static class SeqVarExtensionContext extends Seq_defContext {
public TerminalNode ID() { return getToken(LtlParser.ID, 0); }
public TerminalNode SEQ_WITHOUT() { return getToken(LtlParser.SEQ_WITHOUT, 0); }
public ArgumentContext argument() {
return getRuleContext(ArgumentContext.class,0);
}
public SeqVarExtensionContext(Seq_defContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterSeqVarExtension(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitSeqVarExtension(this);
}
}
public final Seq_defContext seq_def() throws RecognitionException {
Seq_defContext _localctx = new Seq_defContext(_ctx, getState());
enterRule(_localctx, 20, RULE_seq_def);
int _la;
try {
setState(143);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LEFT_PAREN:
_localctx = new SeqDefinitionContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(126);
match(LEFT_PAREN);
setState(127);
argument();
setState(130);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(128);
match(T__0);
setState(129);
argument();
}
}
setState(132);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==T__0 );
setState(136);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==SEQ_WITHOUT) {
{
setState(134);
match(SEQ_WITHOUT);
setState(135);
argument();
}
}
setState(138);
match(RIGHT_PAREN);
}
break;
case ID:
_localctx = new SeqVarExtensionContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(140);
match(ID);
setState(141);
match(SEQ_WITHOUT);
setState(142);
argument();
}
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 Seq_callContext extends ParserRuleContext {
public TerminalNode SEQ_VAR() { return getToken(LtlParser.SEQ_VAR, 0); }
public TerminalNode LEFT_PAREN() { return getToken(LtlParser.LEFT_PAREN, 0); }
public ArgumentContext argument() {
return getRuleContext(ArgumentContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(LtlParser.RIGHT_PAREN, 0); }
public Seq_callContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_seq_call; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterSeq_call(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitSeq_call(this);
}
}
public final Seq_callContext seq_call() throws RecognitionException {
Seq_callContext _localctx = new Seq_callContext(_ctx, getState());
enterRule(_localctx, 22, RULE_seq_call);
try {
enterOuterAlt(_localctx, 1);
{
setState(145);
match(SEQ_VAR);
setState(146);
match(LEFT_PAREN);
setState(147);
argument();
setState(148);
match(RIGHT_PAREN);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LoopContext extends ParserRuleContext {
public TerminalNode LOOP_BEGIN() { return getToken(LtlParser.LOOP_BEGIN, 0); }
public List argument() {
return getRuleContexts(ArgumentContext.class);
}
public ArgumentContext argument(int i) {
return getRuleContext(ArgumentContext.class,i);
}
public TerminalNode TO() { return getToken(LtlParser.TO, 0); }
public Loop_bodyContext loop_body() {
return getRuleContext(Loop_bodyContext.class,0);
}
public TerminalNode LOOP_END() { return getToken(LtlParser.LOOP_END, 0); }
public TerminalNode UP() { return getToken(LtlParser.UP, 0); }
public TerminalNode DOWN() { return getToken(LtlParser.DOWN, 0); }
public TerminalNode ID() { return getToken(LtlParser.ID, 0); }
public LoopContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_loop; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterLoop(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitLoop(this);
}
}
public final LoopContext loop() throws RecognitionException {
LoopContext _localctx = new LoopContext(_ctx, getState());
enterRule(_localctx, 24, RULE_loop);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(150);
match(LOOP_BEGIN);
setState(153);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
case 1:
{
setState(151);
match(ID);
setState(152);
match(T__1);
}
break;
}
setState(155);
argument();
setState(156);
_la = _input.LA(1);
if ( !(_la==UP || _la==DOWN) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(157);
match(TO);
setState(158);
argument();
setState(159);
match(T__1);
setState(160);
loop_body();
setState(161);
match(LOOP_END);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Loop_bodyContext extends ParserRuleContext {
public List var_def() {
return getRuleContexts(Var_defContext.class);
}
public Var_defContext var_def(int i) {
return getRuleContext(Var_defContext.class,i);
}
public List var_assign() {
return getRuleContexts(Var_assignContext.class);
}
public Var_assignContext var_assign(int i) {
return getRuleContext(Var_assignContext.class,i);
}
public Loop_bodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_loop_body; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterLoop_body(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitLoop_body(this);
}
}
public final Loop_bodyContext loop_body() throws RecognitionException {
Loop_bodyContext _localctx = new Loop_bodyContext(_ctx, getState());
enterRule(_localctx, 26, RULE_loop_body);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(165);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
setState(165);
_errHandler.sync(this);
switch (_input.LA(1)) {
case VAR:
case NUM_VAR:
case SEQ_VAR:
{
setState(163);
var_def();
}
break;
case ID:
{
setState(164);
var_assign();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(167);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << VAR) | (1L << NUM_VAR) | (1L << SEQ_VAR) | (1L << ID))) != 0) );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExprContext extends ParserRuleContext {
public ExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr; }
public ExprContext() { }
public void copyFrom(ExprContext ctx) {
super.copyFrom(ctx);
}
}
public static class UnaryCombinedExprContext extends ExprContext {
public TerminalNode UNARY_COMBINED() { return getToken(LtlParser.UNARY_COMBINED, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public UnaryCombinedExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterUnaryCombinedExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitUnaryCombinedExpr(this);
}
}
public static class UnaryLtlExprContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode UNTIL() { return getToken(LtlParser.UNTIL, 0); }
public TerminalNode WEAKUNTIL() { return getToken(LtlParser.WEAKUNTIL, 0); }
public TerminalNode RELEASE() { return getToken(LtlParser.RELEASE, 0); }
public TerminalNode SINCE() { return getToken(LtlParser.SINCE, 0); }
public TerminalNode TRIGGER() { return getToken(LtlParser.TRIGGER, 0); }
public UnaryLtlExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterUnaryLtlExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitUnaryLtlExpr(this);
}
}
public static class OnceExprContext extends ExprContext {
public TerminalNode ONCE() { return getToken(LtlParser.ONCE, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public OnceExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterOnceExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitOnceExpr(this);
}
}
public static class NextExprContext extends ExprContext {
public TerminalNode NEXT() { return getToken(LtlParser.NEXT, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public NextExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterNextExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitNextExpr(this);
}
}
public static class AtomExprContext extends ExprContext {
public AtomContext atom() {
return getRuleContext(AtomContext.class,0);
}
public AtomExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterAtomExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitAtomExpr(this);
}
}
public static class OrExprContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode OR() { return getToken(LtlParser.OR, 0); }
public OrExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterOrExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitOrExpr(this);
}
}
public static class GloballyExprContext extends ExprContext {
public TerminalNode GLOBALLY() { return getToken(LtlParser.GLOBALLY, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public GloballyExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterGloballyExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitGloballyExpr(this);
}
}
public static class HistoricallyExprContext extends ExprContext {
public TerminalNode HISTORICALLY() { return getToken(LtlParser.HISTORICALLY, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public HistoricallyExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterHistoricallyExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitHistoricallyExpr(this);
}
}
public static class NotExprContext extends ExprContext {
public TerminalNode NOT() { return getToken(LtlParser.NOT, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public NotExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterNotExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitNotExpr(this);
}
}
public static class ImpliesExprContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode IMPLIES() { return getToken(LtlParser.IMPLIES, 0); }
public ImpliesExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterImpliesExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitImpliesExpr(this);
}
}
public static class FinallyExprContext extends ExprContext {
public TerminalNode FINALLY() { return getToken(LtlParser.FINALLY, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public FinallyExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterFinallyExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitFinallyExpr(this);
}
}
public static class YesterdayExprContext extends ExprContext {
public TerminalNode YESTERDAY() { return getToken(LtlParser.YESTERDAY, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public YesterdayExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterYesterdayExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitYesterdayExpr(this);
}
}
public static class AndExprContext extends ExprContext {
public List expr() {
return getRuleContexts(ExprContext.class);
}
public ExprContext expr(int i) {
return getRuleContext(ExprContext.class,i);
}
public TerminalNode AND() { return getToken(LtlParser.AND, 0); }
public AndExprContext(ExprContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterAndExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitAndExpr(this);
}
}
public final ExprContext expr() throws RecognitionException {
return expr(0);
}
private ExprContext expr(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ExprContext _localctx = new ExprContext(_ctx, _parentState);
ExprContext _prevctx = _localctx;
int _startState = 28;
enterRecursionRule(_localctx, 28, RULE_expr, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(187);
_errHandler.sync(this);
switch (_input.LA(1)) {
case NOT:
{
_localctx = new NotExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(170);
match(NOT);
setState(171);
expr(13);
}
break;
case GLOBALLY:
{
_localctx = new GloballyExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(172);
match(GLOBALLY);
setState(173);
expr(12);
}
break;
case FINALLY:
{
_localctx = new FinallyExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(174);
match(FINALLY);
setState(175);
expr(11);
}
break;
case NEXT:
{
_localctx = new NextExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(176);
match(NEXT);
setState(177);
expr(10);
}
break;
case HISTORICALLY:
{
_localctx = new HistoricallyExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(178);
match(HISTORICALLY);
setState(179);
expr(9);
}
break;
case ONCE:
{
_localctx = new OnceExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(180);
match(ONCE);
setState(181);
expr(8);
}
break;
case YESTERDAY:
{
_localctx = new YesterdayExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(182);
match(YESTERDAY);
setState(183);
expr(7);
}
break;
case UNARY_COMBINED:
{
_localctx = new UnaryCombinedExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(184);
match(UNARY_COMBINED);
setState(185);
expr(6);
}
break;
case TRUE:
case FALSE:
case SINK:
case DEADLOCK:
case CURRENT:
case PREDICATE:
case ACTION:
case ENABLED:
case LEFT_PAREN:
case BEFORE_SCOPE:
case AFTER_SCOPE:
case BETWEEN_SCOPE:
case UNTIL_SCOPE:
case SEQ_VAR:
case ID:
{
_localctx = new AtomExprContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(186);
atom();
}
break;
default:
throw new NoViableAltException(this);
}
_ctx.stop = _input.LT(-1);
setState(203);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,19,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(201);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
case 1:
{
_localctx = new UnaryLtlExprContext(new ExprContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(189);
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
setState(190);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << UNTIL) | (1L << WEAKUNTIL) | (1L << RELEASE) | (1L << SINCE) | (1L << TRIGGER))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(191);
expr(6);
}
break;
case 2:
{
_localctx = new AndExprContext(new ExprContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(192);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(193);
match(AND);
setState(194);
expr(5);
}
break;
case 3:
{
_localctx = new OrExprContext(new ExprContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(195);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(196);
match(OR);
setState(197);
expr(4);
}
break;
case 4:
{
_localctx = new ImpliesExprContext(new ExprContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_expr);
setState(198);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(199);
match(IMPLIES);
setState(200);
expr(3);
}
break;
}
}
}
setState(205);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,19,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class AtomContext extends ParserRuleContext {
public AtomContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_atom; }
public AtomContext() { }
public void copyFrom(AtomContext ctx) {
super.copyFrom(ctx);
}
}
public static class BooleanAtomContext extends AtomContext {
public TerminalNode TRUE() { return getToken(LtlParser.TRUE, 0); }
public TerminalNode FALSE() { return getToken(LtlParser.FALSE, 0); }
public BooleanAtomContext(AtomContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterBooleanAtom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitBooleanAtom(this);
}
}
public static class StateAtomContext extends AtomContext {
public TerminalNode SINK() { return getToken(LtlParser.SINK, 0); }
public TerminalNode DEADLOCK() { return getToken(LtlParser.DEADLOCK, 0); }
public TerminalNode CURRENT() { return getToken(LtlParser.CURRENT, 0); }
public StateAtomContext(AtomContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterStateAtom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitStateAtom(this);
}
}
public static class ScopeCallAtomContext extends AtomContext {
public Scope_callContext scope_call() {
return getRuleContext(Scope_callContext.class,0);
}
public ScopeCallAtomContext(AtomContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterScopeCallAtom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitScopeCallAtom(this);
}
}
public static class PredicateAtomContext extends AtomContext {
public TerminalNode PREDICATE() { return getToken(LtlParser.PREDICATE, 0); }
public PredicateAtomContext(AtomContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterPredicateAtom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitPredicateAtom(this);
}
}
public static class EnabledAtomContext extends AtomContext {
public TerminalNode ENABLED() { return getToken(LtlParser.ENABLED, 0); }
public EnabledAtomContext(AtomContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterEnabledAtom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitEnabledAtom(this);
}
}
public static class ParAtomContext extends AtomContext {
public TerminalNode LEFT_PAREN() { return getToken(LtlParser.LEFT_PAREN, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public TerminalNode RIGHT_PAREN() { return getToken(LtlParser.RIGHT_PAREN, 0); }
public ParAtomContext(AtomContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterParAtom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitParAtom(this);
}
}
public static class VariableCallAtomContext extends AtomContext {
public TerminalNode ID() { return getToken(LtlParser.ID, 0); }
public VariableCallAtomContext(AtomContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterVariableCallAtom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitVariableCallAtom(this);
}
}
public static class PatternCallAtomContext extends AtomContext {
public Pattern_callContext pattern_call() {
return getRuleContext(Pattern_callContext.class,0);
}
public PatternCallAtomContext(AtomContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterPatternCallAtom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitPatternCallAtom(this);
}
}
public static class SeqCallAtomContext extends AtomContext {
public Seq_callContext seq_call() {
return getRuleContext(Seq_callContext.class,0);
}
public SeqCallAtomContext(AtomContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterSeqCallAtom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitSeqCallAtom(this);
}
}
public static class ActionAtomContext extends AtomContext {
public TerminalNode ACTION() { return getToken(LtlParser.ACTION, 0); }
public ActionAtomContext(AtomContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).enterActionAtom(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof LtlListener ) ((LtlListener)listener).exitActionAtom(this);
}
}
public final AtomContext atom() throws RecognitionException {
AtomContext _localctx = new AtomContext(_ctx, getState());
enterRule(_localctx, 30, RULE_atom);
int _la;
try {
setState(219);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
case 1:
_localctx = new VariableCallAtomContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(206);
match(ID);
}
break;
case 2:
_localctx = new PatternCallAtomContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(207);
pattern_call();
}
break;
case 3:
_localctx = new ScopeCallAtomContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(208);
scope_call();
}
break;
case 4:
_localctx = new SeqCallAtomContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(209);
seq_call();
}
break;
case 5:
_localctx = new PredicateAtomContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(210);
match(PREDICATE);
}
break;
case 6:
_localctx = new ActionAtomContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(211);
match(ACTION);
}
break;
case 7:
_localctx = new EnabledAtomContext(_localctx);
enterOuterAlt(_localctx, 7);
{
setState(212);
match(ENABLED);
}
break;
case 8:
_localctx = new ParAtomContext(_localctx);
enterOuterAlt(_localctx, 8);
{
setState(213);
match(LEFT_PAREN);
setState(214);
expr(0);
setState(215);
match(RIGHT_PAREN);
}
break;
case 9:
_localctx = new BooleanAtomContext(_localctx);
enterOuterAlt(_localctx, 9);
{
setState(217);
_la = _input.LA(1);
if ( !(_la==TRUE || _la==FALSE) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case 10:
_localctx = new StateAtomContext(_localctx);
enterOuterAlt(_localctx, 10);
{
setState(218);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << SINK) | (1L << DEADLOCK) | (1L << CURRENT))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
switch (ruleIndex) {
case 14:
return expr_sempred((ExprContext)_localctx, predIndex);
}
return true;
}
private boolean expr_sempred(ExprContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return precpred(_ctx, 5);
case 1:
return precpred(_ctx, 4);
case 2:
return precpred(_ctx, 3);
case 3:
return precpred(_ctx, 2);
}
return true;
}
public static final String _serializedATN =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\64\u00e0\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\3\2\5\2"+
"$\n\2\3\2\3\2\3\3\7\3)\n\3\f\3\16\3,\13\3\3\3\3\3\3\4\3\4\3\4\3\4\7\4"+
"\64\n\4\f\4\16\4\67\13\4\3\4\3\4\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\5\5C"+
"\n\5\3\6\3\6\3\6\3\6\3\6\3\6\7\6K\n\6\f\6\16\6N\13\6\5\6P\n\6\3\6\3\6"+
"\3\6\3\6\3\7\3\7\3\7\3\7\3\7\3\7\3\7\5\7]\n\7\3\b\3\b\3\b\3\b\3\b\7\b"+
"d\n\b\f\b\16\bg\13\b\5\bi\n\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\5\t"+
"t\n\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f"+
"\6\f\u0085\n\f\r\f\16\f\u0086\3\f\3\f\5\f\u008b\n\f\3\f\3\f\3\f\3\f\3"+
"\f\5\f\u0092\n\f\3\r\3\r\3\r\3\r\3\r\3\16\3\16\3\16\5\16\u009c\n\16\3"+
"\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\17\3\17\6\17\u00a8\n\17\r\17"+
"\16\17\u00a9\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3"+
"\20\3\20\3\20\3\20\3\20\3\20\3\20\5\20\u00be\n\20\3\20\3\20\3\20\3\20"+
"\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\7\20\u00cc\n\20\f\20\16\20\u00cf"+
"\13\20\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21"+
"\5\21\u00de\n\21\3\21\2\3\36\22\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36"+
" \2\b\3\2%(\3\2)+\3\2/\60\3\2\21\25\3\2\5\6\3\2\7\t\2\u00fb\2#\3\2\2\2"+
"\4*\3\2\2\2\6\65\3\2\2\2\bB\3\2\2\2\nD\3\2\2\2\f\\\3\2\2\2\16^\3\2\2\2"+
"\20l\3\2\2\2\22w\3\2\2\2\24|\3\2\2\2\26\u0091\3\2\2\2\30\u0093\3\2\2\2"+
"\32\u0098\3\2\2\2\34\u00a7\3\2\2\2\36\u00bd\3\2\2\2 \u00dd\3\2\2\2\"$"+
"\5\6\4\2#\"\3\2\2\2#$\3\2\2\2$%\3\2\2\2%&\7\2\2\3&\3\3\2\2\2\')\5\n\6"+
"\2(\'\3\2\2\2),\3\2\2\2*(\3\2\2\2*+\3\2\2\2+-\3\2\2\2,*\3\2\2\2-.\7\2"+
"\2\3.\5\3\2\2\2/\64\5\n\6\2\60\64\5\22\n\2\61\64\5\24\13\2\62\64\5\32"+
"\16\2\63/\3\2\2\2\63\60\3\2\2\2\63\61\3\2\2\2\63\62\3\2\2\2\64\67\3\2"+
"\2\2\65\63\3\2\2\2\65\66\3\2\2\2\668\3\2\2\2\67\65\3\2\2\289\5\36\20\2"+
"9\7\3\2\2\2:C\7\63\2\2;C\7\62\2\2\7!\2\2>?\5\b\5\2?@\7\""+
"\2\2@C\3\2\2\2AC\5\36\20\2B:\3\2\2\2B;\3\2\2\2B<\3\2\2\2B=\3\2\2\2BA\3"+
"\2\2\2C\t\3\2\2\2DE\7$\2\2EF\7\63\2\2FO\7!\2\2GL\5\f\7\2HI\7\3\2\2IK\5"+
"\f\7\2JH\3\2\2\2KN\3\2\2\2LJ\3\2\2\2LM\3\2\2\2MP\3\2\2\2NL\3\2\2\2OG\3"+
"\2\2\2OP\3\2\2\2PQ\3\2\2\2QR\7\"\2\2RS\7\4\2\2ST\5\6\4\2T\13\3\2\2\2U"+
"]\7\63\2\2VW\7\63\2\2WX\7\4\2\2X]\7*\2\2YZ\7\63\2\2Z[\7\4\2\2[]\7+\2\2"+
"\\U\3\2\2\2\\V\3\2\2\2\\Y\3\2\2\2]\r\3\2\2\2^_\7\63\2\2_h\7!\2\2`e\5\b"+
"\5\2ab\7\3\2\2bd\5\b\5\2ca\3\2\2\2dg\3\2\2\2ec\3\2\2\2ef\3\2\2\2fi\3\2"+
"\2\2ge\3\2\2\2h`\3\2\2\2hi\3\2\2\2ij\3\2\2\2jk\7\"\2\2k\17\3\2\2\2lm\t"+
"\2\2\2mn\7!\2\2no\5\b\5\2op\7\3\2\2ps\5\b\5\2qr\7\3\2\2rt\5\b\5\2sq\3"+
"\2\2\2st\3\2\2\2tu\3\2\2\2uv\7\"\2\2v\21\3\2\2\2wx\t\3\2\2xy\7\63\2\2"+
"yz\7\4\2\2z{\5\b\5\2{\23\3\2\2\2|}\7\63\2\2}~\7\4\2\2~\177\5\b\5\2\177"+
"\25\3\2\2\2\u0080\u0081\7!\2\2\u0081\u0084\5\b\5\2\u0082\u0083\7\3\2\2"+
"\u0083\u0085\5\b\5\2\u0084\u0082\3\2\2\2\u0085\u0086\3\2\2\2\u0086\u0084"+
"\3\2\2\2\u0086\u0087\3\2\2\2\u0087\u008a\3\2\2\2\u0088\u0089\7,\2\2\u0089"+
"\u008b\5\b\5\2\u008a\u0088\3\2\2\2\u008a\u008b\3\2\2\2\u008b\u008c\3\2"+
"\2\2\u008c\u008d\7\"\2\2\u008d\u0092\3\2\2\2\u008e\u008f\7\63\2\2\u008f"+
"\u0090\7,\2\2\u0090\u0092\5\b\5\2\u0091\u0080\3\2\2\2\u0091\u008e\3\2"+
"\2\2\u0092\27\3\2\2\2\u0093\u0094\7+\2\2\u0094\u0095\7!\2\2\u0095\u0096"+
"\5\b\5\2\u0096\u0097\7\"\2\2\u0097\31\3\2\2\2\u0098\u009b\7-\2\2\u0099"+
"\u009a\7\63\2\2\u009a\u009c\7\4\2\2\u009b\u0099\3\2\2\2\u009b\u009c\3"+
"\2\2\2\u009c\u009d\3\2\2\2\u009d\u009e\5\b\5\2\u009e\u009f\t\4\2\2\u009f"+
"\u00a0\7\61\2\2\u00a0\u00a1\5\b\5\2\u00a1\u00a2\7\4\2\2\u00a2\u00a3\5"+
"\34\17\2\u00a3\u00a4\7.\2\2\u00a4\33\3\2\2\2\u00a5\u00a8\5\22\n\2\u00a6"+
"\u00a8\5\24\13\2\u00a7\u00a5\3\2\2\2\u00a7\u00a6\3\2\2\2\u00a8\u00a9\3"+
"\2\2\2\u00a9\u00a7\3\2\2\2\u00a9\u00aa\3\2\2\2\u00aa\35\3\2\2\2\u00ab"+
"\u00ac\b\20\1\2\u00ac\u00ad\7\26\2\2\u00ad\u00be\5\36\20\17\u00ae\u00af"+
"\7\n\2\2\u00af\u00be\5\36\20\16\u00b0\u00b1\7\13\2\2\u00b1\u00be\5\36"+
"\20\r\u00b2\u00b3\7\f\2\2\u00b3\u00be\5\36\20\f\u00b4\u00b5\7\r\2\2\u00b5"+
"\u00be\5\36\20\13\u00b6\u00b7\7\16\2\2\u00b7\u00be\5\36\20\n\u00b8\u00b9"+
"\7\17\2\2\u00b9\u00be\5\36\20\t\u00ba\u00bb\7\20\2\2\u00bb\u00be\5\36"+
"\20\b\u00bc\u00be\5 \21\2\u00bd\u00ab\3\2\2\2\u00bd\u00ae\3\2\2\2\u00bd"+
"\u00b0\3\2\2\2\u00bd\u00b2\3\2\2\2\u00bd\u00b4\3\2\2\2\u00bd\u00b6\3\2"+
"\2\2\u00bd\u00b8\3\2\2\2\u00bd\u00ba\3\2\2\2\u00bd\u00bc\3\2\2\2\u00be"+
"\u00cd\3\2\2\2\u00bf\u00c0\f\7\2\2\u00c0\u00c1\t\5\2\2\u00c1\u00cc\5\36"+
"\20\b\u00c2\u00c3\f\6\2\2\u00c3\u00c4\7\27\2\2\u00c4\u00cc\5\36\20\7\u00c5"+
"\u00c6\f\5\2\2\u00c6\u00c7\7\30\2\2\u00c7\u00cc\5\36\20\6\u00c8\u00c9"+
"\f\4\2\2\u00c9\u00ca\7\31\2\2\u00ca\u00cc\5\36\20\5\u00cb\u00bf\3\2\2"+
"\2\u00cb\u00c2\3\2\2\2\u00cb\u00c5\3\2\2\2\u00cb\u00c8\3\2\2\2\u00cc\u00cf"+
"\3\2\2\2\u00cd\u00cb\3\2\2\2\u00cd\u00ce\3\2\2\2\u00ce\37\3\2\2\2\u00cf"+
"\u00cd\3\2\2\2\u00d0\u00de\7\63\2\2\u00d1\u00de\5\16\b\2\u00d2\u00de\5"+
"\20\t\2\u00d3\u00de\5\30\r\2\u00d4\u00de\7\32\2\2\u00d5\u00de\7\33\2\2"+
"\u00d6\u00de\7\34\2\2\u00d7\u00d8\7!\2\2\u00d8\u00d9\5\36\20\2\u00d9\u00da"+
"\7\"\2\2\u00da\u00de\3\2\2\2\u00db\u00de\t\6\2\2\u00dc\u00de\t\7\2\2\u00dd"+
"\u00d0\3\2\2\2\u00dd\u00d1\3\2\2\2\u00dd\u00d2\3\2\2\2\u00dd\u00d3\3\2"+
"\2\2\u00dd\u00d4\3\2\2\2\u00dd\u00d5\3\2\2\2\u00dd\u00d6\3\2\2\2\u00dd"+
"\u00d7\3\2\2\2\u00dd\u00db\3\2\2\2\u00dd\u00dc\3\2\2\2\u00de!\3\2\2\2"+
"\27#*\63\65BLO\\ehs\u0086\u008a\u0091\u009b\u00a7\u00a9\u00bd\u00cb\u00cd"+
"\u00dd";
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