# 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 = [ "", "'('", "')'", "'-'", "'->'", "'<->'", "'|'", "'&'" ] symbolicNames = [ "", "", "", "", "", "", "", "", "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)