369 lines
13 KiB
Python
369 lines
13 KiB
Python
# Generated from O.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,9,30,2,0,7,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,3,0,11,8,0,1,0,
|
|
1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,5,0,25,8,0,10,0,12,0,
|
|
28,9,0,1,0,0,1,0,1,0,0,0,34,0,10,1,0,0,0,2,3,6,0,-1,0,3,4,5,1,0,
|
|
0,4,5,3,0,0,0,5,6,5,2,0,0,6,11,1,0,0,0,7,8,5,3,0,0,8,11,3,0,0,6,
|
|
9,11,5,9,0,0,10,2,1,0,0,0,10,7,1,0,0,0,10,9,1,0,0,0,11,26,1,0,0,
|
|
0,12,13,10,5,0,0,13,14,5,4,0,0,14,25,3,0,0,6,15,16,10,4,0,0,16,17,
|
|
5,5,0,0,17,25,3,0,0,5,18,19,10,3,0,0,19,20,5,6,0,0,20,25,3,0,0,4,
|
|
21,22,10,2,0,0,22,23,5,7,0,0,23,25,3,0,0,3,24,12,1,0,0,0,24,15,1,
|
|
0,0,0,24,18,1,0,0,0,24,21,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,3,10,24,26
|
|
]
|
|
|
|
class OParser ( Parser ):
|
|
|
|
grammarFileName = "O.g4"
|
|
|
|
atn = ATNDeserializer().deserialize(serializedATN())
|
|
|
|
decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
|
|
|
|
sharedContextCache = PredictionContextCache()
|
|
|
|
literalNames = [ "<INVALID>", "'('", "')'", "'-'", "'->'", "'<->'",
|
|
"'|'", "'&'" ]
|
|
|
|
symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"WS", "ATOM" ]
|
|
|
|
RULE_expr = 0
|
|
|
|
ruleNames = [ "expr" ]
|
|
|
|
EOF = Token.EOF
|
|
T__0=1
|
|
T__1=2
|
|
T__2=3
|
|
T__3=4
|
|
T__4=5
|
|
T__5=6
|
|
T__6=7
|
|
WS=8
|
|
ATOM=9
|
|
|
|
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 ExprContext(ParserRuleContext):
|
|
__slots__ = 'parser'
|
|
|
|
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return OParser.RULE_expr
|
|
|
|
|
|
def copyFrom(self, ctx:ParserRuleContext):
|
|
super().copyFrom(ctx)
|
|
|
|
|
|
class Log_negContext(ExprContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a OParser.ExprContext
|
|
super().__init__(parser)
|
|
self.copyFrom(ctx)
|
|
|
|
def expr(self):
|
|
return self.getTypedRuleContext(OParser.ExprContext,0)
|
|
|
|
|
|
def accept(self, visitor:ParseTreeVisitor):
|
|
if hasattr( visitor, "visitLog_neg" ):
|
|
return visitor.visitLog_neg(self)
|
|
else:
|
|
return visitor.visitChildren(self)
|
|
|
|
|
|
class ParenthContext(ExprContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a OParser.ExprContext
|
|
super().__init__(parser)
|
|
self.copyFrom(ctx)
|
|
|
|
def expr(self):
|
|
return self.getTypedRuleContext(OParser.ExprContext,0)
|
|
|
|
|
|
def accept(self, visitor:ParseTreeVisitor):
|
|
if hasattr( visitor, "visitParenth" ):
|
|
return visitor.visitParenth(self)
|
|
else:
|
|
return visitor.visitChildren(self)
|
|
|
|
|
|
class Log_orContext(ExprContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a OParser.ExprContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.copyFrom(ctx)
|
|
|
|
def expr(self, i:int=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(OParser.ExprContext)
|
|
else:
|
|
return self.getTypedRuleContext(OParser.ExprContext,i)
|
|
|
|
|
|
def accept(self, visitor:ParseTreeVisitor):
|
|
if hasattr( visitor, "visitLog_or" ):
|
|
return visitor.visitLog_or(self)
|
|
else:
|
|
return visitor.visitChildren(self)
|
|
|
|
|
|
class Log_implContext(ExprContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a OParser.ExprContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.copyFrom(ctx)
|
|
|
|
def expr(self, i:int=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(OParser.ExprContext)
|
|
else:
|
|
return self.getTypedRuleContext(OParser.ExprContext,i)
|
|
|
|
|
|
def accept(self, visitor:ParseTreeVisitor):
|
|
if hasattr( visitor, "visitLog_impl" ):
|
|
return visitor.visitLog_impl(self)
|
|
else:
|
|
return visitor.visitChildren(self)
|
|
|
|
|
|
class AtomContext(ExprContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a OParser.ExprContext
|
|
super().__init__(parser)
|
|
self.copyFrom(ctx)
|
|
|
|
def ATOM(self):
|
|
return self.getToken(OParser.ATOM, 0)
|
|
|
|
def accept(self, visitor:ParseTreeVisitor):
|
|
if hasattr( visitor, "visitAtom" ):
|
|
return visitor.visitAtom(self)
|
|
else:
|
|
return visitor.visitChildren(self)
|
|
|
|
|
|
class Log_iffContext(ExprContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a OParser.ExprContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.copyFrom(ctx)
|
|
|
|
def expr(self, i:int=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(OParser.ExprContext)
|
|
else:
|
|
return self.getTypedRuleContext(OParser.ExprContext,i)
|
|
|
|
|
|
def accept(self, visitor:ParseTreeVisitor):
|
|
if hasattr( visitor, "visitLog_iff" ):
|
|
return visitor.visitLog_iff(self)
|
|
else:
|
|
return visitor.visitChildren(self)
|
|
|
|
|
|
class Log_andContext(ExprContext):
|
|
|
|
def __init__(self, parser, ctx:ParserRuleContext): # actually a OParser.ExprContext
|
|
super().__init__(parser)
|
|
self.op = None # Token
|
|
self.copyFrom(ctx)
|
|
|
|
def expr(self, i:int=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(OParser.ExprContext)
|
|
else:
|
|
return self.getTypedRuleContext(OParser.ExprContext,i)
|
|
|
|
|
|
def accept(self, visitor:ParseTreeVisitor):
|
|
if hasattr( visitor, "visitLog_and" ):
|
|
return visitor.visitLog_and(self)
|
|
else:
|
|
return visitor.visitChildren(self)
|
|
|
|
|
|
|
|
def expr(self, _p:int=0):
|
|
_parentctx = self._ctx
|
|
_parentState = self.state
|
|
localctx = OParser.ExprContext(self, self._ctx, _parentState)
|
|
_prevctx = localctx
|
|
_startState = 0
|
|
self.enterRecursionRule(localctx, 0, self.RULE_expr, _p)
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 10
|
|
self._errHandler.sync(self)
|
|
token = self._input.LA(1)
|
|
if token in [OParser.T__0]:
|
|
localctx = OParser.ParenthContext(self, localctx)
|
|
self._ctx = localctx
|
|
_prevctx = localctx
|
|
|
|
self.state = 3
|
|
self.match(OParser.T__0)
|
|
self.state = 4
|
|
self.expr(0)
|
|
self.state = 5
|
|
self.match(OParser.T__1)
|
|
pass
|
|
elif token in [OParser.T__2]:
|
|
localctx = OParser.Log_negContext(self, localctx)
|
|
self._ctx = localctx
|
|
_prevctx = localctx
|
|
self.state = 7
|
|
self.match(OParser.T__2)
|
|
self.state = 8
|
|
self.expr(6)
|
|
pass
|
|
elif token in [OParser.ATOM]:
|
|
localctx = OParser.AtomContext(self, localctx)
|
|
self._ctx = localctx
|
|
_prevctx = localctx
|
|
self.state = 9
|
|
self.match(OParser.ATOM)
|
|
pass
|
|
else:
|
|
raise NoViableAltException(self)
|
|
|
|
self._ctx.stop = self._input.LT(-1)
|
|
self.state = 26
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,2,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 = 24
|
|
self._errHandler.sync(self)
|
|
la_ = self._interp.adaptivePredict(self._input,1,self._ctx)
|
|
if la_ == 1:
|
|
localctx = OParser.Log_implContext(self, OParser.ExprContext(self, _parentctx, _parentState))
|
|
self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
|
|
self.state = 12
|
|
if not self.precpred(self._ctx, 5):
|
|
from antlr4.error.Errors import FailedPredicateException
|
|
raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
|
|
self.state = 13
|
|
localctx.op = self.match(OParser.T__3)
|
|
self.state = 14
|
|
self.expr(6)
|
|
pass
|
|
|
|
elif la_ == 2:
|
|
localctx = OParser.Log_iffContext(self, OParser.ExprContext(self, _parentctx, _parentState))
|
|
self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
|
|
self.state = 15
|
|
if not self.precpred(self._ctx, 4):
|
|
from antlr4.error.Errors import FailedPredicateException
|
|
raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
|
|
self.state = 16
|
|
localctx.op = self.match(OParser.T__4)
|
|
self.state = 17
|
|
self.expr(5)
|
|
pass
|
|
|
|
elif la_ == 3:
|
|
localctx = OParser.Log_orContext(self, OParser.ExprContext(self, _parentctx, _parentState))
|
|
self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
|
|
self.state = 18
|
|
if not self.precpred(self._ctx, 3):
|
|
from antlr4.error.Errors import FailedPredicateException
|
|
raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
|
|
self.state = 19
|
|
localctx.op = self.match(OParser.T__5)
|
|
self.state = 20
|
|
self.expr(4)
|
|
pass
|
|
|
|
elif la_ == 4:
|
|
localctx = OParser.Log_andContext(self, OParser.ExprContext(self, _parentctx, _parentState))
|
|
self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
|
|
self.state = 21
|
|
if not self.precpred(self._ctx, 2):
|
|
from antlr4.error.Errors import FailedPredicateException
|
|
raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
|
|
self.state = 22
|
|
localctx.op = self.match(OParser.T__6)
|
|
self.state = 23
|
|
self.expr(3)
|
|
pass
|
|
|
|
|
|
self.state = 28
|
|
self._errHandler.sync(self)
|
|
_alt = self._interp.adaptivePredict(self._input,2,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
|
|
|
|
|
|
|
|
def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
|
|
if self._predicates == None:
|
|
self._predicates = dict()
|
|
self._predicates[0] = self.expr_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 expr_sempred(self, localctx:ExprContext, predIndex:int):
|
|
if predIndex == 0:
|
|
return self.precpred(self._ctx, 5)
|
|
|
|
|
|
if predIndex == 1:
|
|
return self.precpred(self._ctx, 4)
|
|
|
|
|
|
if predIndex == 2:
|
|
return self.precpred(self._ctx, 3)
|
|
|
|
|
|
if predIndex == 3:
|
|
return self.precpred(self._ctx, 2)
|
|
|
|
|
|
|
|
|
|
|