mirror of
https://github.com/mudabbir-ahmad/MYOL-TB2-prog3-Py.git
synced 2026-10-07 19:40:21 +00:00
316 lines
9.3 KiB
Python
316 lines
9.3 KiB
Python
# Generated from ./Hello.g4 by ANTLR 4.13.2
|
|
# 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,6,29,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,1,0,4,0,12,8,0,
|
|
11,0,12,0,13,1,1,4,1,17,8,1,11,1,12,1,18,1,2,1,2,1,3,1,3,1,3,1,4,
|
|
1,4,1,4,1,4,0,0,5,0,2,4,6,8,0,2,1,0,1,2,1,0,3,4,25,0,11,1,0,0,0,
|
|
2,16,1,0,0,0,4,20,1,0,0,0,6,22,1,0,0,0,8,25,1,0,0,0,10,12,3,4,2,
|
|
0,11,10,1,0,0,0,12,13,1,0,0,0,13,11,1,0,0,0,13,14,1,0,0,0,14,1,1,
|
|
0,0,0,15,17,3,8,4,0,16,15,1,0,0,0,17,18,1,0,0,0,18,16,1,0,0,0,18,
|
|
19,1,0,0,0,19,3,1,0,0,0,20,21,7,0,0,0,21,5,1,0,0,0,22,23,5,1,0,0,
|
|
23,24,5,5,0,0,24,7,1,0,0,0,25,26,7,1,0,0,26,27,5,5,0,0,27,9,1,0,
|
|
0,0,2,13,18
|
|
]
|
|
|
|
class HelloParser ( Parser ):
|
|
|
|
grammarFileName = "Hello.g4"
|
|
|
|
atn = ATNDeserializer().deserialize(serializedATN())
|
|
|
|
decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
|
|
|
|
sharedContextCache = PredictionContextCache()
|
|
|
|
literalNames = [ "<INVALID>", "'hello'", "'hi'", "'bye'", "'goodbye'" ]
|
|
|
|
symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",
|
|
"<INVALID>", "ID", "WS" ]
|
|
|
|
RULE_greeting = 0
|
|
RULE_leaving = 1
|
|
RULE_greet = 2
|
|
RULE_start = 3
|
|
RULE_bye = 4
|
|
|
|
ruleNames = [ "greeting", "leaving", "greet", "start", "bye" ]
|
|
|
|
EOF = Token.EOF
|
|
T__0=1
|
|
T__1=2
|
|
T__2=3
|
|
T__3=4
|
|
ID=5
|
|
WS=6
|
|
|
|
def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
|
|
super().__init__(input, output)
|
|
self.checkVersion("4.13.2")
|
|
self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
|
|
self._predicates = None
|
|
|
|
|
|
|
|
|
|
class GreetingContext(ParserRuleContext):
|
|
__slots__ = 'parser'
|
|
|
|
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def greet(self, i:int=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(HelloParser.GreetContext)
|
|
else:
|
|
return self.getTypedRuleContext(HelloParser.GreetContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return HelloParser.RULE_greeting
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterGreeting" ):
|
|
listener.enterGreeting(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitGreeting" ):
|
|
listener.exitGreeting(self)
|
|
|
|
|
|
|
|
|
|
def greeting(self):
|
|
|
|
localctx = HelloParser.GreetingContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 0, self.RULE_greeting)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 11
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
while True:
|
|
self.state = 10
|
|
self.greet()
|
|
self.state = 13
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if not (_la==1 or _la==2):
|
|
break
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
|
|
class LeavingContext(ParserRuleContext):
|
|
__slots__ = 'parser'
|
|
|
|
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
def bye(self, i:int=None):
|
|
if i is None:
|
|
return self.getTypedRuleContexts(HelloParser.ByeContext)
|
|
else:
|
|
return self.getTypedRuleContext(HelloParser.ByeContext,i)
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return HelloParser.RULE_leaving
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterLeaving" ):
|
|
listener.enterLeaving(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitLeaving" ):
|
|
listener.exitLeaving(self)
|
|
|
|
|
|
|
|
|
|
def leaving(self):
|
|
|
|
localctx = HelloParser.LeavingContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 2, self.RULE_leaving)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 16
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
while True:
|
|
self.state = 15
|
|
self.bye()
|
|
self.state = 18
|
|
self._errHandler.sync(self)
|
|
_la = self._input.LA(1)
|
|
if not (_la==3 or _la==4):
|
|
break
|
|
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
|
|
class GreetContext(ParserRuleContext):
|
|
__slots__ = 'parser'
|
|
|
|
def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
|
|
super().__init__(parent, invokingState)
|
|
self.parser = parser
|
|
|
|
|
|
def getRuleIndex(self):
|
|
return HelloParser.RULE_greet
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterGreet" ):
|
|
listener.enterGreet(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitGreet" ):
|
|
listener.exitGreet(self)
|
|
|
|
|
|
|
|
|
|
def greet(self):
|
|
|
|
localctx = HelloParser.GreetContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 4, self.RULE_greet)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 20
|
|
_la = self._input.LA(1)
|
|
if not(_la==1 or _la==2):
|
|
self._errHandler.recoverInline(self)
|
|
else:
|
|
self._errHandler.reportMatch(self)
|
|
self.consume()
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
|
|
class StartContext(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(HelloParser.ID, 0)
|
|
|
|
def getRuleIndex(self):
|
|
return HelloParser.RULE_start
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterStart" ):
|
|
listener.enterStart(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitStart" ):
|
|
listener.exitStart(self)
|
|
|
|
|
|
|
|
|
|
def start(self):
|
|
|
|
localctx = HelloParser.StartContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 6, self.RULE_start)
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 22
|
|
self.match(HelloParser.T__0)
|
|
self.state = 23
|
|
self.match(HelloParser.ID)
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
|
|
class ByeContext(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(HelloParser.ID, 0)
|
|
|
|
def getRuleIndex(self):
|
|
return HelloParser.RULE_bye
|
|
|
|
def enterRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "enterBye" ):
|
|
listener.enterBye(self)
|
|
|
|
def exitRule(self, listener:ParseTreeListener):
|
|
if hasattr( listener, "exitBye" ):
|
|
listener.exitBye(self)
|
|
|
|
|
|
|
|
|
|
def bye(self):
|
|
|
|
localctx = HelloParser.ByeContext(self, self._ctx, self.state)
|
|
self.enterRule(localctx, 8, self.RULE_bye)
|
|
self._la = 0 # Token type
|
|
try:
|
|
self.enterOuterAlt(localctx, 1)
|
|
self.state = 25
|
|
_la = self._input.LA(1)
|
|
if not(_la==3 or _la==4):
|
|
self._errHandler.recoverInline(self)
|
|
else:
|
|
self._errHandler.reportMatch(self)
|
|
self.consume()
|
|
self.state = 26
|
|
self.match(HelloParser.ID)
|
|
except RecognitionException as re:
|
|
localctx.exception = re
|
|
self._errHandler.reportError(self, re)
|
|
self._errHandler.recover(self, re)
|
|
finally:
|
|
self.exitRule()
|
|
return localctx
|
|
|
|
|
|
|
|
|
|
|