| # Generated from Expr.g4 by ANTLR 4.13.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,17,81,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,1,0,4,0,16,8,0,11,0,12,0,17,1,1,1,1,1,1,1,1,1,1,1,1,5,1,26,8,1, |
| 10,1,12,1,29,9,1,1,1,1,1,1,1,1,2,1,2,4,2,36,8,2,11,2,12,2,37,1,2, |
| 1,2,1,3,1,3,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4, |
| 3,4,57,8,4,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,1,5,5,5,68,8,5,10,5,12, |
| 5,71,9,5,1,6,1,6,1,6,1,6,1,6,1,6,3,6,79,8,6,1,6,0,1,10,7,0,2,4,6, |
| 8,10,12,0,2,1,0,9,10,1,0,11,12,83,0,15,1,0,0,0,2,19,1,0,0,0,4,33, |
| 1,0,0,0,6,41,1,0,0,0,8,56,1,0,0,0,10,58,1,0,0,0,12,78,1,0,0,0,14, |
| 16,3,2,1,0,15,14,1,0,0,0,16,17,1,0,0,0,17,15,1,0,0,0,17,18,1,0,0, |
| 0,18,1,1,0,0,0,19,20,5,1,0,0,20,21,5,14,0,0,21,22,5,2,0,0,22,27, |
| 3,6,3,0,23,24,5,3,0,0,24,26,3,6,3,0,25,23,1,0,0,0,26,29,1,0,0,0, |
| 27,25,1,0,0,0,27,28,1,0,0,0,28,30,1,0,0,0,29,27,1,0,0,0,30,31,5, |
| 4,0,0,31,32,3,4,2,0,32,3,1,0,0,0,33,35,5,5,0,0,34,36,3,8,4,0,35, |
| 34,1,0,0,0,36,37,1,0,0,0,37,35,1,0,0,0,37,38,1,0,0,0,38,39,1,0,0, |
| 0,39,40,5,6,0,0,40,5,1,0,0,0,41,42,5,14,0,0,42,7,1,0,0,0,43,44,3, |
| 10,5,0,44,45,5,7,0,0,45,57,1,0,0,0,46,47,5,14,0,0,47,48,5,8,0,0, |
| 48,49,3,10,5,0,49,50,5,7,0,0,50,57,1,0,0,0,51,52,5,13,0,0,52,53, |
| 3,10,5,0,53,54,5,7,0,0,54,57,1,0,0,0,55,57,5,7,0,0,56,43,1,0,0,0, |
| 56,46,1,0,0,0,56,51,1,0,0,0,56,55,1,0,0,0,57,9,1,0,0,0,58,59,6,5, |
| -1,0,59,60,3,12,6,0,60,69,1,0,0,0,61,62,10,3,0,0,62,63,7,0,0,0,63, |
| 68,3,10,5,4,64,65,10,2,0,0,65,66,7,1,0,0,66,68,3,10,5,3,67,61,1, |
| 0,0,0,67,64,1,0,0,0,68,71,1,0,0,0,69,67,1,0,0,0,69,70,1,0,0,0,70, |
| 11,1,0,0,0,71,69,1,0,0,0,72,79,5,15,0,0,73,79,5,14,0,0,74,75,5,2, |
| 0,0,75,76,3,10,5,0,76,77,5,4,0,0,77,79,1,0,0,0,78,72,1,0,0,0,78, |
| 73,1,0,0,0,78,74,1,0,0,0,79,13,1,0,0,0,7,17,27,37,56,67,69,78 |
| ] |
| |
| class ExprParser ( Parser ): |
| |
| grammarFileName = "Expr.g4" |
| |
| atn = ATNDeserializer().deserialize(serializedATN()) |
| |
| decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ] |
| |
| sharedContextCache = PredictionContextCache() |
| |
| literalNames = [ "<INVALID>", "'def'", "'('", "','", "')'", "'{'", "'}'", |
| "';'", "'='", "'*'", "'/'", "'+'", "'-'", "'return'" ] |
| |
| symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", |
| "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", |
| "<INVALID>", "MUL", "DIV", "ADD", "SUB", "RETURN", |
| "ID", "INT", "NEWLINE", "WS" ] |
| |
| RULE_prog = 0 |
| RULE_func = 1 |
| RULE_body = 2 |
| RULE_arg = 3 |
| RULE_stat = 4 |
| RULE_expr = 5 |
| RULE_primary = 6 |
| |
| ruleNames = [ "prog", "func", "body", "arg", "stat", "expr", "primary" ] |
| |
| 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 |
| MUL=9 |
| DIV=10 |
| ADD=11 |
| SUB=12 |
| RETURN=13 |
| ID=14 |
| INT=15 |
| NEWLINE=16 |
| WS=17 |
| |
| def __init__(self, input:TokenStream, output:TextIO = sys.stdout): |
| super().__init__(input, output) |
| self.checkVersion("4.13.1") |
| self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache) |
| self._predicates = None |
| |
| |
| |
| |
| class ProgContext(ParserRuleContext): |
| __slots__ = 'parser' |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def func(self, i:int=None): |
| if i is None: |
| return self.getTypedRuleContexts(ExprParser.FuncContext) |
| else: |
| return self.getTypedRuleContext(ExprParser.FuncContext,i) |
| |
| |
| def getRuleIndex(self): |
| return ExprParser.RULE_prog |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterProg" ): |
| listener.enterProg(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitProg" ): |
| listener.exitProg(self) |
| |
| |
| |
| |
| def prog(self): |
| |
| localctx = ExprParser.ProgContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 0, self.RULE_prog) |
| self._la = 0 # Token type |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 15 |
| self._errHandler.sync(self) |
| _la = self._input.LA(1) |
| while True: |
| self.state = 14 |
| self.func() |
| self.state = 17 |
| self._errHandler.sync(self) |
| _la = self._input.LA(1) |
| if not (_la==1): |
| break |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| |
| class FuncContext(ParserRuleContext): |
| __slots__ = 'parser' |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def ID(self): |
| return self.getToken(ExprParser.ID, 0) |
| |
| def arg(self, i:int=None): |
| if i is None: |
| return self.getTypedRuleContexts(ExprParser.ArgContext) |
| else: |
| return self.getTypedRuleContext(ExprParser.ArgContext,i) |
| |
| |
| def body(self): |
| return self.getTypedRuleContext(ExprParser.BodyContext,0) |
| |
| |
| def getRuleIndex(self): |
| return ExprParser.RULE_func |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterFunc" ): |
| listener.enterFunc(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitFunc" ): |
| listener.exitFunc(self) |
| |
| |
| |
| |
| def func(self): |
| |
| localctx = ExprParser.FuncContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 2, self.RULE_func) |
| self._la = 0 # Token type |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 19 |
| self.match(ExprParser.T__0) |
| self.state = 20 |
| self.match(ExprParser.ID) |
| self.state = 21 |
| self.match(ExprParser.T__1) |
| self.state = 22 |
| self.arg() |
| self.state = 27 |
| self._errHandler.sync(self) |
| _la = self._input.LA(1) |
| while _la==3: |
| self.state = 23 |
| self.match(ExprParser.T__2) |
| self.state = 24 |
| self.arg() |
| self.state = 29 |
| self._errHandler.sync(self) |
| _la = self._input.LA(1) |
| |
| self.state = 30 |
| self.match(ExprParser.T__3) |
| self.state = 31 |
| self.body() |
| 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 stat(self, i:int=None): |
| if i is None: |
| return self.getTypedRuleContexts(ExprParser.StatContext) |
| else: |
| return self.getTypedRuleContext(ExprParser.StatContext,i) |
| |
| |
| def getRuleIndex(self): |
| return ExprParser.RULE_body |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterBody" ): |
| listener.enterBody(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitBody" ): |
| listener.exitBody(self) |
| |
| |
| |
| |
| def body(self): |
| |
| localctx = ExprParser.BodyContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 4, self.RULE_body) |
| self._la = 0 # Token type |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 33 |
| self.match(ExprParser.T__4) |
| self.state = 35 |
| self._errHandler.sync(self) |
| _la = self._input.LA(1) |
| while True: |
| self.state = 34 |
| self.stat() |
| self.state = 37 |
| self._errHandler.sync(self) |
| _la = self._input.LA(1) |
| if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 57476) != 0)): |
| break |
| |
| self.state = 39 |
| self.match(ExprParser.T__5) |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| |
| class ArgContext(ParserRuleContext): |
| __slots__ = 'parser' |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| def ID(self): |
| return self.getToken(ExprParser.ID, 0) |
| |
| def getRuleIndex(self): |
| return ExprParser.RULE_arg |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterArg" ): |
| listener.enterArg(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitArg" ): |
| listener.exitArg(self) |
| |
| |
| |
| |
| def arg(self): |
| |
| localctx = ExprParser.ArgContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 6, self.RULE_arg) |
| try: |
| self.enterOuterAlt(localctx, 1) |
| self.state = 41 |
| self.match(ExprParser.ID) |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| |
| class StatContext(ParserRuleContext): |
| __slots__ = 'parser' |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| |
| def getRuleIndex(self): |
| return ExprParser.RULE_stat |
| |
| |
| def copyFrom(self, ctx:ParserRuleContext): |
| super().copyFrom(ctx) |
| |
| |
| |
| class RetContext(StatContext): |
| |
| def __init__(self, parser, ctx:ParserRuleContext): # actually a ExprParser.StatContext |
| super().__init__(parser) |
| self.copyFrom(ctx) |
| |
| def RETURN(self): |
| return self.getToken(ExprParser.RETURN, 0) |
| def expr(self): |
| return self.getTypedRuleContext(ExprParser.ExprContext,0) |
| |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterRet" ): |
| listener.enterRet(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitRet" ): |
| listener.exitRet(self) |
| |
| |
| class BlankContext(StatContext): |
| |
| def __init__(self, parser, ctx:ParserRuleContext): # actually a ExprParser.StatContext |
| super().__init__(parser) |
| self.copyFrom(ctx) |
| |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterBlank" ): |
| listener.enterBlank(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitBlank" ): |
| listener.exitBlank(self) |
| |
| |
| class PrintExprContext(StatContext): |
| |
| def __init__(self, parser, ctx:ParserRuleContext): # actually a ExprParser.StatContext |
| super().__init__(parser) |
| self.copyFrom(ctx) |
| |
| def expr(self): |
| return self.getTypedRuleContext(ExprParser.ExprContext,0) |
| |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterPrintExpr" ): |
| listener.enterPrintExpr(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitPrintExpr" ): |
| listener.exitPrintExpr(self) |
| |
| |
| class AssignContext(StatContext): |
| |
| def __init__(self, parser, ctx:ParserRuleContext): # actually a ExprParser.StatContext |
| super().__init__(parser) |
| self.copyFrom(ctx) |
| |
| def ID(self): |
| return self.getToken(ExprParser.ID, 0) |
| def expr(self): |
| return self.getTypedRuleContext(ExprParser.ExprContext,0) |
| |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterAssign" ): |
| listener.enterAssign(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitAssign" ): |
| listener.exitAssign(self) |
| |
| |
| |
| def stat(self): |
| |
| localctx = ExprParser.StatContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 8, self.RULE_stat) |
| try: |
| self.state = 56 |
| self._errHandler.sync(self) |
| la_ = self._interp.adaptivePredict(self._input,3,self._ctx) |
| if la_ == 1: |
| localctx = ExprParser.PrintExprContext(self, localctx) |
| self.enterOuterAlt(localctx, 1) |
| self.state = 43 |
| self.expr(0) |
| self.state = 44 |
| self.match(ExprParser.T__6) |
| pass |
| |
| elif la_ == 2: |
| localctx = ExprParser.AssignContext(self, localctx) |
| self.enterOuterAlt(localctx, 2) |
| self.state = 46 |
| self.match(ExprParser.ID) |
| self.state = 47 |
| self.match(ExprParser.T__7) |
| self.state = 48 |
| self.expr(0) |
| self.state = 49 |
| self.match(ExprParser.T__6) |
| pass |
| |
| elif la_ == 3: |
| localctx = ExprParser.RetContext(self, localctx) |
| self.enterOuterAlt(localctx, 3) |
| self.state = 51 |
| self.match(ExprParser.RETURN) |
| self.state = 52 |
| self.expr(0) |
| self.state = 53 |
| self.match(ExprParser.T__6) |
| pass |
| |
| elif la_ == 4: |
| localctx = ExprParser.BlankContext(self, localctx) |
| self.enterOuterAlt(localctx, 4) |
| self.state = 55 |
| self.match(ExprParser.T__6) |
| pass |
| |
| |
| except RecognitionException as re: |
| localctx.exception = re |
| self._errHandler.reportError(self, re) |
| self._errHandler.recover(self, re) |
| finally: |
| self.exitRule() |
| return localctx |
| |
| |
| 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 ExprParser.RULE_expr |
| |
| |
| def copyFrom(self, ctx:ParserRuleContext): |
| super().copyFrom(ctx) |
| |
| |
| class PrimContext(ExprContext): |
| |
| def __init__(self, parser, ctx:ParserRuleContext): # actually a ExprParser.ExprContext |
| super().__init__(parser) |
| self.copyFrom(ctx) |
| |
| def primary(self): |
| return self.getTypedRuleContext(ExprParser.PrimaryContext,0) |
| |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterPrim" ): |
| listener.enterPrim(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitPrim" ): |
| listener.exitPrim(self) |
| |
| |
| class MulDivContext(ExprContext): |
| |
| def __init__(self, parser, ctx:ParserRuleContext): # actually a ExprParser.ExprContext |
| super().__init__(parser) |
| self.copyFrom(ctx) |
| |
| def expr(self, i:int=None): |
| if i is None: |
| return self.getTypedRuleContexts(ExprParser.ExprContext) |
| else: |
| return self.getTypedRuleContext(ExprParser.ExprContext,i) |
| |
| def MUL(self): |
| return self.getToken(ExprParser.MUL, 0) |
| def DIV(self): |
| return self.getToken(ExprParser.DIV, 0) |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterMulDiv" ): |
| listener.enterMulDiv(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitMulDiv" ): |
| listener.exitMulDiv(self) |
| |
| |
| class AddSubContext(ExprContext): |
| |
| def __init__(self, parser, ctx:ParserRuleContext): # actually a ExprParser.ExprContext |
| super().__init__(parser) |
| self.copyFrom(ctx) |
| |
| def expr(self, i:int=None): |
| if i is None: |
| return self.getTypedRuleContexts(ExprParser.ExprContext) |
| else: |
| return self.getTypedRuleContext(ExprParser.ExprContext,i) |
| |
| def ADD(self): |
| return self.getToken(ExprParser.ADD, 0) |
| def SUB(self): |
| return self.getToken(ExprParser.SUB, 0) |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterAddSub" ): |
| listener.enterAddSub(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitAddSub" ): |
| listener.exitAddSub(self) |
| |
| |
| |
| def expr(self, _p:int=0): |
| _parentctx = self._ctx |
| _parentState = self.state |
| localctx = ExprParser.ExprContext(self, self._ctx, _parentState) |
| _prevctx = localctx |
| _startState = 10 |
| self.enterRecursionRule(localctx, 10, self.RULE_expr, _p) |
| self._la = 0 # Token type |
| try: |
| self.enterOuterAlt(localctx, 1) |
| localctx = ExprParser.PrimContext(self, localctx) |
| self._ctx = localctx |
| _prevctx = localctx |
| |
| self.state = 59 |
| self.primary() |
| self._ctx.stop = self._input.LT(-1) |
| self.state = 69 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,5,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 = 67 |
| self._errHandler.sync(self) |
| la_ = self._interp.adaptivePredict(self._input,4,self._ctx) |
| if la_ == 1: |
| localctx = ExprParser.MulDivContext(self, ExprParser.ExprContext(self, _parentctx, _parentState)) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) |
| self.state = 61 |
| if not self.precpred(self._ctx, 3): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 3)") |
| self.state = 62 |
| _la = self._input.LA(1) |
| if not(_la==9 or _la==10): |
| self._errHandler.recoverInline(self) |
| else: |
| self._errHandler.reportMatch(self) |
| self.consume() |
| self.state = 63 |
| self.expr(4) |
| pass |
| |
| elif la_ == 2: |
| localctx = ExprParser.AddSubContext(self, ExprParser.ExprContext(self, _parentctx, _parentState)) |
| self.pushNewRecursionContext(localctx, _startState, self.RULE_expr) |
| self.state = 64 |
| if not self.precpred(self._ctx, 2): |
| from antlr4.error.Errors import FailedPredicateException |
| raise FailedPredicateException(self, "self.precpred(self._ctx, 2)") |
| self.state = 65 |
| _la = self._input.LA(1) |
| if not(_la==11 or _la==12): |
| self._errHandler.recoverInline(self) |
| else: |
| self._errHandler.reportMatch(self) |
| self.consume() |
| self.state = 66 |
| self.expr(3) |
| pass |
| |
| |
| self.state = 71 |
| self._errHandler.sync(self) |
| _alt = self._interp.adaptivePredict(self._input,5,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 PrimaryContext(ParserRuleContext): |
| __slots__ = 'parser' |
| |
| def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1): |
| super().__init__(parent, invokingState) |
| self.parser = parser |
| |
| |
| def getRuleIndex(self): |
| return ExprParser.RULE_primary |
| |
| |
| def copyFrom(self, ctx:ParserRuleContext): |
| super().copyFrom(ctx) |
| |
| |
| |
| class ParensContext(PrimaryContext): |
| |
| def __init__(self, parser, ctx:ParserRuleContext): # actually a ExprParser.PrimaryContext |
| super().__init__(parser) |
| self.copyFrom(ctx) |
| |
| def expr(self): |
| return self.getTypedRuleContext(ExprParser.ExprContext,0) |
| |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterParens" ): |
| listener.enterParens(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitParens" ): |
| listener.exitParens(self) |
| |
| |
| class IdContext(PrimaryContext): |
| |
| def __init__(self, parser, ctx:ParserRuleContext): # actually a ExprParser.PrimaryContext |
| super().__init__(parser) |
| self.copyFrom(ctx) |
| |
| def ID(self): |
| return self.getToken(ExprParser.ID, 0) |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterId" ): |
| listener.enterId(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitId" ): |
| listener.exitId(self) |
| |
| |
| class IntContext(PrimaryContext): |
| |
| def __init__(self, parser, ctx:ParserRuleContext): # actually a ExprParser.PrimaryContext |
| super().__init__(parser) |
| self.copyFrom(ctx) |
| |
| def INT(self): |
| return self.getToken(ExprParser.INT, 0) |
| |
| def enterRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "enterInt" ): |
| listener.enterInt(self) |
| |
| def exitRule(self, listener:ParseTreeListener): |
| if hasattr( listener, "exitInt" ): |
| listener.exitInt(self) |
| |
| |
| |
| def primary(self): |
| |
| localctx = ExprParser.PrimaryContext(self, self._ctx, self.state) |
| self.enterRule(localctx, 12, self.RULE_primary) |
| try: |
| self.state = 78 |
| self._errHandler.sync(self) |
| token = self._input.LA(1) |
| if token in [15]: |
| localctx = ExprParser.IntContext(self, localctx) |
| self.enterOuterAlt(localctx, 1) |
| self.state = 72 |
| self.match(ExprParser.INT) |
| pass |
| elif token in [14]: |
| localctx = ExprParser.IdContext(self, localctx) |
| self.enterOuterAlt(localctx, 2) |
| self.state = 73 |
| self.match(ExprParser.ID) |
| pass |
| elif token in [2]: |
| localctx = ExprParser.ParensContext(self, localctx) |
| self.enterOuterAlt(localctx, 3) |
| self.state = 74 |
| self.match(ExprParser.T__1) |
| self.state = 75 |
| self.expr(0) |
| self.state = 76 |
| self.match(ExprParser.T__3) |
| 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 |
| |
| |
| |
| def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int): |
| if self._predicates == None: |
| self._predicates = dict() |
| self._predicates[5] = 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, 3) |
| |
| |
| if predIndex == 1: |
| return self.precpred(self._ctx, 2) |
| |
| |
| |
| |
| |
