wfs-operator-experiment/grammars/HMKNFParser.py

841 lines
27 KiB
Python

# Generated from HMKNF.g4 by ANTLR 4.10.1
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys
if sys.version_info[1] > 5:
from typing import TextIO
else:
from typing.io import TextIO
def serializedATN():
return [
4,1,12,96,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,
6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,1,0,1,0,5,0,25,8,0,10,0,12,0,
28,9,0,1,1,1,1,1,1,1,1,1,1,3,1,35,8,1,1,1,1,1,1,2,1,2,1,2,5,2,42,
8,2,10,2,12,2,45,9,2,1,3,1,3,1,3,1,3,5,3,51,8,3,10,3,12,3,54,9,3,
3,3,56,8,3,1,4,1,4,1,4,1,5,1,5,1,5,1,5,1,5,1,5,3,5,67,8,5,1,5,1,
5,1,5,1,5,1,5,1,5,5,5,75,8,5,10,5,12,5,78,9,5,1,6,1,6,3,6,82,8,6,
1,7,1,7,3,7,86,8,7,1,8,1,8,1,9,1,9,1,9,1,10,1,10,1,10,1,10,0,1,10,
11,0,2,4,6,8,10,12,14,16,18,20,0,1,1,0,6,7,96,0,26,1,0,0,0,2,34,
1,0,0,0,4,38,1,0,0,0,6,46,1,0,0,0,8,57,1,0,0,0,10,66,1,0,0,0,12,
81,1,0,0,0,14,85,1,0,0,0,16,87,1,0,0,0,18,89,1,0,0,0,20,92,1,0,0,
0,22,25,3,2,1,0,23,25,3,8,4,0,24,22,1,0,0,0,24,23,1,0,0,0,25,28,
1,0,0,0,26,24,1,0,0,0,26,27,1,0,0,0,27,1,1,0,0,0,28,26,1,0,0,0,29,
30,3,4,2,0,30,31,3,6,3,0,31,35,1,0,0,0,32,35,3,4,2,0,33,35,3,6,3,
0,34,29,1,0,0,0,34,32,1,0,0,0,34,33,1,0,0,0,35,36,1,0,0,0,36,37,
5,1,0,0,37,3,1,0,0,0,38,43,5,12,0,0,39,40,5,2,0,0,40,42,5,12,0,0,
41,39,1,0,0,0,42,45,1,0,0,0,43,41,1,0,0,0,43,44,1,0,0,0,44,5,1,0,
0,0,45,43,1,0,0,0,46,55,5,3,0,0,47,52,3,12,6,0,48,49,5,2,0,0,49,
51,3,12,6,0,50,48,1,0,0,0,51,54,1,0,0,0,52,50,1,0,0,0,52,53,1,0,
0,0,53,56,1,0,0,0,54,52,1,0,0,0,55,47,1,0,0,0,55,56,1,0,0,0,56,7,
1,0,0,0,57,58,3,10,5,0,58,59,5,1,0,0,59,9,1,0,0,0,60,61,6,5,-1,0,
61,62,5,4,0,0,62,63,3,10,5,0,63,64,5,5,0,0,64,67,1,0,0,0,65,67,3,
14,7,0,66,60,1,0,0,0,66,65,1,0,0,0,67,76,1,0,0,0,68,69,10,2,0,0,
69,70,7,0,0,0,70,75,3,10,5,3,71,72,10,1,0,0,72,73,5,8,0,0,73,75,
3,10,5,2,74,68,1,0,0,0,74,71,1,0,0,0,75,78,1,0,0,0,76,74,1,0,0,0,
76,77,1,0,0,0,77,11,1,0,0,0,78,76,1,0,0,0,79,82,3,16,8,0,80,82,3,
18,9,0,81,79,1,0,0,0,81,80,1,0,0,0,82,13,1,0,0,0,83,86,3,16,8,0,
84,86,3,20,10,0,85,83,1,0,0,0,85,84,1,0,0,0,86,15,1,0,0,0,87,88,
5,12,0,0,88,17,1,0,0,0,89,90,5,9,0,0,90,91,5,12,0,0,91,19,1,0,0,
0,92,93,5,10,0,0,93,94,5,12,0,0,94,21,1,0,0,0,11,24,26,34,43,52,
55,66,74,76,81,85
]
class HMKNFParser ( Parser ):
grammarFileName = "HMKNF.g4"
atn = ATNDeserializer().deserialize(serializedATN())
decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
sharedContextCache = PredictionContextCache()
literalNames = [ "<INVALID>", "'.'", "','", "':-'", "'('", "')'", "'|'",
"'&'", "'->'", "'not'", "'-'" ]
symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
"<INVALID>", "<INVALID>", "<INVALID>", "WS", "IDENTIFIER" ]
RULE_kb = 0
RULE_lrule = 1
RULE_head = 2
RULE_body = 3
RULE_orule = 4
RULE_oformula = 5
RULE_katom = 6
RULE_oatom = 7
RULE_patom = 8
RULE_natom = 9
RULE_fatom = 10
ruleNames = [ "kb", "lrule", "head", "body", "orule", "oformula", "katom",
"oatom", "patom", "natom", "fatom" ]
EOF = Token.EOF
T__0=1
T__1=2
T__2=3
T__3=4
T__4=5
T__5=6
T__6=7
T__7=8
T__8=9
T__9=10
WS=11
IDENTIFIER=12
def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
super().__init__(input, output)
self.checkVersion("4.10.1")
self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
self._predicates = None
class KbContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def lrule(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(HMKNFParser.LruleContext)
else:
return self.getTypedRuleContext(HMKNFParser.LruleContext,i)
def orule(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(HMKNFParser.OruleContext)
else:
return self.getTypedRuleContext(HMKNFParser.OruleContext,i)
def getRuleIndex(self):
return HMKNFParser.RULE_kb
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitKb" ):
return visitor.visitKb(self)
else:
return visitor.visitChildren(self)
def kb(self):
localctx = HMKNFParser.KbContext(self, self._ctx, self.state)
self.enterRule(localctx, 0, self.RULE_kb)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 26
self._errHandler.sync(self)
_la = self._input.LA(1)
while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << HMKNFParser.T__2) | (1 << HMKNFParser.T__3) | (1 << HMKNFParser.T__9) | (1 << HMKNFParser.IDENTIFIER))) != 0):
self.state = 24
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
if la_ == 1:
self.state = 22
self.lrule()
pass
elif la_ == 2:
self.state = 23
self.orule()
pass
self.state = 28
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class LruleContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def head(self):
return self.getTypedRuleContext(HMKNFParser.HeadContext,0)
def body(self):
return self.getTypedRuleContext(HMKNFParser.BodyContext,0)
def getRuleIndex(self):
return HMKNFParser.RULE_lrule
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLrule" ):
return visitor.visitLrule(self)
else:
return visitor.visitChildren(self)
def lrule(self):
localctx = HMKNFParser.LruleContext(self, self._ctx, self.state)
self.enterRule(localctx, 2, self.RULE_lrule)
try:
self.enterOuterAlt(localctx, 1)
self.state = 34
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
if la_ == 1:
self.state = 29
self.head()
self.state = 30
self.body()
pass
elif la_ == 2:
self.state = 32
self.head()
pass
elif la_ == 3:
self.state = 33
self.body()
pass
self.state = 36
self.match(HMKNFParser.T__0)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class HeadContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def IDENTIFIER(self, i:int=None):
if i is None:
return self.getTokens(HMKNFParser.IDENTIFIER)
else:
return self.getToken(HMKNFParser.IDENTIFIER, i)
def getRuleIndex(self):
return HMKNFParser.RULE_head
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitHead" ):
return visitor.visitHead(self)
else:
return visitor.visitChildren(self)
def head(self):
localctx = HMKNFParser.HeadContext(self, self._ctx, self.state)
self.enterRule(localctx, 4, self.RULE_head)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 38
self.match(HMKNFParser.IDENTIFIER)
self.state = 43
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==HMKNFParser.T__1:
self.state = 39
self.match(HMKNFParser.T__1)
self.state = 40
self.match(HMKNFParser.IDENTIFIER)
self.state = 45
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class BodyContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def katom(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(HMKNFParser.KatomContext)
else:
return self.getTypedRuleContext(HMKNFParser.KatomContext,i)
def getRuleIndex(self):
return HMKNFParser.RULE_body
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitBody" ):
return visitor.visitBody(self)
else:
return visitor.visitChildren(self)
def body(self):
localctx = HMKNFParser.BodyContext(self, self._ctx, self.state)
self.enterRule(localctx, 6, self.RULE_body)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 46
self.match(HMKNFParser.T__2)
self.state = 55
self._errHandler.sync(self)
_la = self._input.LA(1)
if _la==HMKNFParser.T__8 or _la==HMKNFParser.IDENTIFIER:
self.state = 47
self.katom()
self.state = 52
self._errHandler.sync(self)
_la = self._input.LA(1)
while _la==HMKNFParser.T__1:
self.state = 48
self.match(HMKNFParser.T__1)
self.state = 49
self.katom()
self.state = 54
self._errHandler.sync(self)
_la = self._input.LA(1)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class OruleContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def oformula(self):
return self.getTypedRuleContext(HMKNFParser.OformulaContext,0)
def getRuleIndex(self):
return HMKNFParser.RULE_orule
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitOrule" ):
return visitor.visitOrule(self)
else:
return visitor.visitChildren(self)
def orule(self):
localctx = HMKNFParser.OruleContext(self, self._ctx, self.state)
self.enterRule(localctx, 8, self.RULE_orule)
try:
self.enterOuterAlt(localctx, 1)
self.state = 57
self.oformula(0)
self.state = 58
self.match(HMKNFParser.T__0)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class OformulaContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def getRuleIndex(self):
return HMKNFParser.RULE_oformula
def copyFrom(self, ctx:ParserRuleContext):
super().copyFrom(ctx)
class DisjOrConjContext(OformulaContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a HMKNFParser.OformulaContext
super().__init__(parser)
self.operator = None # Token
self.copyFrom(ctx)
def oformula(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(HMKNFParser.OformulaContext)
else:
return self.getTypedRuleContext(HMKNFParser.OformulaContext,i)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitDisjOrConj" ):
return visitor.visitDisjOrConj(self)
else:
return visitor.visitChildren(self)
class ParenthContext(OformulaContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a HMKNFParser.OformulaContext
super().__init__(parser)
self.copyFrom(ctx)
def oformula(self):
return self.getTypedRuleContext(HMKNFParser.OformulaContext,0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitParenth" ):
return visitor.visitParenth(self)
else:
return visitor.visitChildren(self)
class ImpContext(OformulaContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a HMKNFParser.OformulaContext
super().__init__(parser)
self.copyFrom(ctx)
def oformula(self, i:int=None):
if i is None:
return self.getTypedRuleContexts(HMKNFParser.OformulaContext)
else:
return self.getTypedRuleContext(HMKNFParser.OformulaContext,i)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitImp" ):
return visitor.visitImp(self)
else:
return visitor.visitChildren(self)
class LiteralContext(OformulaContext):
def __init__(self, parser, ctx:ParserRuleContext): # actually a HMKNFParser.OformulaContext
super().__init__(parser)
self.copyFrom(ctx)
def oatom(self):
return self.getTypedRuleContext(HMKNFParser.OatomContext,0)
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitLiteral" ):
return visitor.visitLiteral(self)
else:
return visitor.visitChildren(self)
def oformula(self, _p:int=0):
_parentctx = self._ctx
_parentState = self.state
localctx = HMKNFParser.OformulaContext(self, self._ctx, _parentState)
_prevctx = localctx
_startState = 10
self.enterRecursionRule(localctx, 10, self.RULE_oformula, _p)
self._la = 0 # Token type
try:
self.enterOuterAlt(localctx, 1)
self.state = 66
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [HMKNFParser.T__3]:
localctx = HMKNFParser.ParenthContext(self, localctx)
self._ctx = localctx
_prevctx = localctx
self.state = 61
self.match(HMKNFParser.T__3)
self.state = 62
self.oformula(0)
self.state = 63
self.match(HMKNFParser.T__4)
pass
elif token in [HMKNFParser.T__9, HMKNFParser.IDENTIFIER]:
localctx = HMKNFParser.LiteralContext(self, localctx)
self._ctx = localctx
_prevctx = localctx
self.state = 65
self.oatom()
pass
else:
raise NoViableAltException(self)
self._ctx.stop = self._input.LT(-1)
self.state = 76
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,8,self._ctx)
while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
if _alt==1:
if self._parseListeners is not None:
self.triggerExitRuleEvent()
_prevctx = localctx
self.state = 74
self._errHandler.sync(self)
la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
if la_ == 1:
localctx = HMKNFParser.DisjOrConjContext(self, HMKNFParser.OformulaContext(self, _parentctx, _parentState))
self.pushNewRecursionContext(localctx, _startState, self.RULE_oformula)
self.state = 68
if not self.precpred(self._ctx, 2):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
self.state = 69
localctx.operator = self._input.LT(1)
_la = self._input.LA(1)
if not(_la==HMKNFParser.T__5 or _la==HMKNFParser.T__6):
localctx.operator = self._errHandler.recoverInline(self)
else:
self._errHandler.reportMatch(self)
self.consume()
self.state = 70
self.oformula(3)
pass
elif la_ == 2:
localctx = HMKNFParser.ImpContext(self, HMKNFParser.OformulaContext(self, _parentctx, _parentState))
self.pushNewRecursionContext(localctx, _startState, self.RULE_oformula)
self.state = 71
if not self.precpred(self._ctx, 1):
from antlr4.error.Errors import FailedPredicateException
raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
self.state = 72
self.match(HMKNFParser.T__7)
self.state = 73
self.oformula(2)
pass
self.state = 78
self._errHandler.sync(self)
_alt = self._interp.adaptivePredict(self._input,8,self._ctx)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.unrollRecursionContexts(_parentctx)
return localctx
class KatomContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def patom(self):
return self.getTypedRuleContext(HMKNFParser.PatomContext,0)
def natom(self):
return self.getTypedRuleContext(HMKNFParser.NatomContext,0)
def getRuleIndex(self):
return HMKNFParser.RULE_katom
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitKatom" ):
return visitor.visitKatom(self)
else:
return visitor.visitChildren(self)
def katom(self):
localctx = HMKNFParser.KatomContext(self, self._ctx, self.state)
self.enterRule(localctx, 12, self.RULE_katom)
try:
self.state = 81
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [HMKNFParser.IDENTIFIER]:
self.enterOuterAlt(localctx, 1)
self.state = 79
self.patom()
pass
elif token in [HMKNFParser.T__8]:
self.enterOuterAlt(localctx, 2)
self.state = 80
self.natom()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class OatomContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def patom(self):
return self.getTypedRuleContext(HMKNFParser.PatomContext,0)
def fatom(self):
return self.getTypedRuleContext(HMKNFParser.FatomContext,0)
def getRuleIndex(self):
return HMKNFParser.RULE_oatom
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitOatom" ):
return visitor.visitOatom(self)
else:
return visitor.visitChildren(self)
def oatom(self):
localctx = HMKNFParser.OatomContext(self, self._ctx, self.state)
self.enterRule(localctx, 14, self.RULE_oatom)
try:
self.state = 85
self._errHandler.sync(self)
token = self._input.LA(1)
if token in [HMKNFParser.IDENTIFIER]:
self.enterOuterAlt(localctx, 1)
self.state = 83
self.patom()
pass
elif token in [HMKNFParser.T__9]:
self.enterOuterAlt(localctx, 2)
self.state = 84
self.fatom()
pass
else:
raise NoViableAltException(self)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class PatomContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def IDENTIFIER(self):
return self.getToken(HMKNFParser.IDENTIFIER, 0)
def getRuleIndex(self):
return HMKNFParser.RULE_patom
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitPatom" ):
return visitor.visitPatom(self)
else:
return visitor.visitChildren(self)
def patom(self):
localctx = HMKNFParser.PatomContext(self, self._ctx, self.state)
self.enterRule(localctx, 16, self.RULE_patom)
try:
self.enterOuterAlt(localctx, 1)
self.state = 87
self.match(HMKNFParser.IDENTIFIER)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class NatomContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def IDENTIFIER(self):
return self.getToken(HMKNFParser.IDENTIFIER, 0)
def getRuleIndex(self):
return HMKNFParser.RULE_natom
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitNatom" ):
return visitor.visitNatom(self)
else:
return visitor.visitChildren(self)
def natom(self):
localctx = HMKNFParser.NatomContext(self, self._ctx, self.state)
self.enterRule(localctx, 18, self.RULE_natom)
try:
self.enterOuterAlt(localctx, 1)
self.state = 89
self.match(HMKNFParser.T__8)
self.state = 90
self.match(HMKNFParser.IDENTIFIER)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
class FatomContext(ParserRuleContext):
__slots__ = 'parser'
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
super().__init__(parent, invokingState)
self.parser = parser
def IDENTIFIER(self):
return self.getToken(HMKNFParser.IDENTIFIER, 0)
def getRuleIndex(self):
return HMKNFParser.RULE_fatom
def accept(self, visitor:ParseTreeVisitor):
if hasattr( visitor, "visitFatom" ):
return visitor.visitFatom(self)
else:
return visitor.visitChildren(self)
def fatom(self):
localctx = HMKNFParser.FatomContext(self, self._ctx, self.state)
self.enterRule(localctx, 20, self.RULE_fatom)
try:
self.enterOuterAlt(localctx, 1)
self.state = 92
self.match(HMKNFParser.T__9)
self.state = 93
self.match(HMKNFParser.IDENTIFIER)
except RecognitionException as re:
localctx.exception = re
self._errHandler.reportError(self, re)
self._errHandler.recover(self, re)
finally:
self.exitRule()
return localctx
def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
if self._predicates == None:
self._predicates = dict()
self._predicates[5] = self.oformula_sempred
pred = self._predicates.get(ruleIndex, None)
if pred is None:
raise Exception("No predicate with index:" + str(ruleIndex))
else:
return pred(localctx, predIndex)
def oformula_sempred(self, localctx:OformulaContext, predIndex:int):
if predIndex == 0:
return self.precpred(self._ctx, 2)
if predIndex == 1:
return self.precpred(self._ctx, 1)