Add ANTLR grammar for greetings and farewells with corresponding parser and listener implementations

HelloParser.py

@@ -10,8 +10,15 @@ else:
 
 def serializedATN():
     return [
-        4,1,3,6,2,0,7,0,1,0,1,0,1,0,1,0,0,0,1,0,0,0,4,0,2,1,0,0,0,2,3,5,
-        1,0,0,3,4,5,2,0,0,4,1,1,0,0,0,0
+        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 ):
@@ -24,18 +31,26 @@ class HelloParser ( Parser ):
 
     sharedContextCache = PredictionContextCache()
 
-    literalNames = [ "<INVALID>", "'hello'" ]
+    literalNames = [ "<INVALID>", "'hello'", "'hi'", "'bye'", "'goodbye'" ]
 
-    symbolicNames = [ "<INVALID>", "<INVALID>", "ID", "WS" ]
+    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
+                      "<INVALID>", "ID", "WS" ]
 
-    RULE_start = 0
+    RULE_greeting = 0
+    RULE_leaving = 1
+    RULE_greet = 2
+    RULE_start = 3
+    RULE_bye = 4
 
-    ruleNames =  [ "start" ]
+    ruleNames =  [ "greeting", "leaving", "greet", "start", "bye" ]
 
     EOF = Token.EOF
     T__0=1
-    ID=2
-    WS=3
+    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)
@@ -46,6 +61,163 @@ class HelloParser ( Parser ):
 
 
 
+    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'
 
@@ -73,12 +245,61 @@ class HelloParser ( Parser ):
     def start(self):
 
         localctx = HelloParser.StartContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 0, self.RULE_start)
+        self.enterRule(localctx, 6, self.RULE_start)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 2
+            self.state = 22
             self.match(HelloParser.T__0)
-            self.state = 3
+            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