YAPLParser.py

# Generated from YAPL.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,48,210,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,1,0,1,0,1,0,4,
        0,14,8,0,11,0,12,0,15,1,1,1,1,1,1,1,1,3,1,22,8,1,1,1,1,1,1,1,1,1,
        5,1,28,8,1,10,1,12,1,31,9,1,1,1,1,1,1,2,1,2,1,2,1,2,1,2,5,2,40,8,
        2,10,2,12,2,43,9,2,3,2,45,8,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,
        2,1,2,1,2,1,2,3,2,59,8,2,3,2,61,8,2,1,3,1,3,1,3,1,3,1,4,1,4,1,4,
        1,4,1,4,1,4,5,4,73,8,4,10,4,12,4,76,9,4,3,4,78,8,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,1,4,1,4,1,4,1,4,1,4,1,4,1,4,4,
        4,99,8,4,11,4,12,4,100,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,3,4,111,8,
        4,1,4,1,4,1,4,1,4,1,4,1,4,3,4,119,8,4,5,4,121,8,4,10,4,12,4,124,
        9,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,1,4,1,4,1,4,
        1,4,1,4,1,4,1,4,1,4,1,4,1,4,3,4,148,8,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,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,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,3,4,186,
        8,4,1,4,1,4,1,4,1,4,1,4,1,4,5,4,194,8,4,10,4,12,4,197,9,4,3,4,199,
        8,4,1,4,1,4,1,4,1,4,5,4,205,8,4,10,4,12,4,208,9,4,1,4,0,1,8,5,0,
        2,4,6,8,0,1,1,0,23,24,248,0,13,1,0,0,0,2,17,1,0,0,0,4,60,1,0,0,0,
        6,62,1,0,0,0,8,147,1,0,0,0,10,11,3,2,1,0,11,12,5,1,0,0,12,14,1,0,
        0,0,13,10,1,0,0,0,14,15,1,0,0,0,15,13,1,0,0,0,15,16,1,0,0,0,16,1,
        1,0,0,0,17,18,5,9,0,0,18,21,5,28,0,0,19,20,5,19,0,0,20,22,5,28,0,
        0,21,19,1,0,0,0,21,22,1,0,0,0,22,23,1,0,0,0,23,29,5,41,0,0,24,25,
        3,4,2,0,25,26,5,1,0,0,26,28,1,0,0,0,27,24,1,0,0,0,28,31,1,0,0,0,
        29,27,1,0,0,0,29,30,1,0,0,0,30,32,1,0,0,0,31,29,1,0,0,0,32,33,5,
        42,0,0,33,3,1,0,0,0,34,35,5,29,0,0,35,44,5,39,0,0,36,41,3,6,3,0,
        37,38,5,48,0,0,38,40,3,6,3,0,39,37,1,0,0,0,40,43,1,0,0,0,41,39,1,
        0,0,0,41,42,1,0,0,0,42,45,1,0,0,0,43,41,1,0,0,0,44,36,1,0,0,0,44,
        45,1,0,0,0,45,46,1,0,0,0,46,47,5,40,0,0,47,48,5,47,0,0,48,49,5,28,
        0,0,49,50,5,41,0,0,50,51,3,8,4,0,51,52,5,42,0,0,52,61,1,0,0,0,53,
        54,5,29,0,0,54,55,5,47,0,0,55,58,5,28,0,0,56,57,5,30,0,0,57,59,3,
        8,4,0,58,56,1,0,0,0,58,59,1,0,0,0,59,61,1,0,0,0,60,34,1,0,0,0,60,
        53,1,0,0,0,61,5,1,0,0,0,62,63,5,29,0,0,63,64,5,47,0,0,64,65,5,28,
        0,0,65,7,1,0,0,0,66,67,6,4,-1,0,67,68,5,29,0,0,68,77,5,39,0,0,69,
        74,3,8,4,0,70,71,5,48,0,0,71,73,3,8,4,0,72,70,1,0,0,0,73,76,1,0,
        0,0,74,72,1,0,0,0,74,75,1,0,0,0,75,78,1,0,0,0,76,74,1,0,0,0,77,69,
        1,0,0,0,77,78,1,0,0,0,78,79,1,0,0,0,79,148,5,40,0,0,80,81,5,12,0,
        0,81,82,3,8,4,0,82,83,5,14,0,0,83,84,3,8,4,0,84,85,5,15,0,0,85,86,
        3,8,4,0,86,87,5,13,0,0,87,148,1,0,0,0,88,89,5,16,0,0,89,90,3,8,4,
        0,90,91,5,20,0,0,91,92,3,8,4,0,92,93,5,21,0,0,93,148,1,0,0,0,94,
        98,5,41,0,0,95,96,3,8,4,0,96,97,5,1,0,0,97,99,1,0,0,0,98,95,1,0,
        0,0,99,100,1,0,0,0,100,98,1,0,0,0,100,101,1,0,0,0,101,102,1,0,0,
        0,102,103,5,42,0,0,103,148,1,0,0,0,104,105,5,17,0,0,105,106,5,29,
        0,0,106,107,5,47,0,0,107,110,5,28,0,0,108,109,5,30,0,0,109,111,3,
        8,4,0,110,108,1,0,0,0,110,111,1,0,0,0,111,122,1,0,0,0,112,113,5,
        48,0,0,113,114,5,29,0,0,114,115,5,47,0,0,115,118,5,28,0,0,116,117,
        5,30,0,0,117,119,3,8,4,0,118,116,1,0,0,0,118,119,1,0,0,0,119,121,
        1,0,0,0,120,112,1,0,0,0,121,124,1,0,0,0,122,120,1,0,0,0,122,123,
        1,0,0,0,123,125,1,0,0,0,124,122,1,0,0,0,125,126,5,18,0,0,126,148,
        3,8,4,23,127,128,5,22,0,0,128,148,5,28,0,0,129,130,5,35,0,0,130,
        148,3,8,4,21,131,132,5,11,0,0,132,148,3,8,4,20,133,134,5,10,0,0,
        134,148,3,8,4,8,135,136,5,39,0,0,136,137,3,8,4,0,137,138,5,40,0,
        0,138,148,1,0,0,0,139,140,5,29,0,0,140,141,5,30,0,0,141,148,3,8,
        4,6,142,148,5,29,0,0,143,148,5,27,0,0,144,148,5,26,0,0,145,148,7,
        0,0,0,146,148,5,25,0,0,147,66,1,0,0,0,147,80,1,0,0,0,147,88,1,0,
        0,0,147,94,1,0,0,0,147,104,1,0,0,0,147,127,1,0,0,0,147,129,1,0,0,
        0,147,131,1,0,0,0,147,133,1,0,0,0,147,135,1,0,0,0,147,139,1,0,0,
        0,147,142,1,0,0,0,147,143,1,0,0,0,147,144,1,0,0,0,147,145,1,0,0,
        0,147,146,1,0,0,0,148,206,1,0,0,0,149,150,10,19,0,0,150,151,5,31,
        0,0,151,205,3,8,4,20,152,153,10,18,0,0,153,154,5,32,0,0,154,205,
        3,8,4,19,155,156,10,17,0,0,156,157,5,33,0,0,157,205,3,8,4,18,158,
        159,10,16,0,0,159,160,5,34,0,0,160,205,3,8,4,17,161,162,10,15,0,
        0,162,163,5,37,0,0,163,205,3,8,4,16,164,165,10,14,0,0,165,166,5,
        36,0,0,166,205,3,8,4,15,167,168,10,13,0,0,168,169,5,2,0,0,169,205,
        3,8,4,14,170,171,10,12,0,0,171,172,5,3,0,0,172,205,3,8,4,13,173,
        174,10,11,0,0,174,175,5,38,0,0,175,205,3,8,4,12,176,177,10,10,0,
        0,177,178,5,4,0,0,178,205,3,8,4,11,179,180,10,9,0,0,180,181,5,5,
        0,0,181,205,3,8,4,10,182,185,10,29,0,0,183,184,5,46,0,0,184,186,
        5,28,0,0,185,183,1,0,0,0,185,186,1,0,0,0,186,187,1,0,0,0,187,188,
        5,45,0,0,188,189,5,29,0,0,189,198,5,39,0,0,190,195,3,8,4,0,191,192,
        5,48,0,0,192,194,3,8,4,0,193,191,1,0,0,0,194,197,1,0,0,0,195,193,
        1,0,0,0,195,196,1,0,0,0,196,199,1,0,0,0,197,195,1,0,0,0,198,190,
        1,0,0,0,198,199,1,0,0,0,199,200,1,0,0,0,200,205,5,40,0,0,201,202,
        10,27,0,0,202,203,5,45,0,0,203,205,5,29,0,0,204,149,1,0,0,0,204,
        152,1,0,0,0,204,155,1,0,0,0,204,158,1,0,0,0,204,161,1,0,0,0,204,
        164,1,0,0,0,204,167,1,0,0,0,204,170,1,0,0,0,204,173,1,0,0,0,204,
        176,1,0,0,0,204,179,1,0,0,0,204,182,1,0,0,0,204,201,1,0,0,0,205,
        208,1,0,0,0,206,204,1,0,0,0,206,207,1,0,0,0,207,9,1,0,0,0,208,206,
        1,0,0,0,19,15,21,29,41,44,58,60,74,77,100,110,118,122,147,185,195,
        198,204,206
    ]

class YAPLParser ( Parser ):

    grammarFileName = "YAPL.g4"

    atn = ATNDeserializer().deserialize(serializedATN())

    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "';'", "'>'", "'>='", "'&'", "'|'", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "'<-'", "'*'", 
                     "'/'", "'+'", "'-'", "'~'", "'<'", "'<='", "'='", "'('", 
                     "')'", "'{'", "'}'", "'['", "']'", "'.'", "'@'", "':'", 
                     "','" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "BLOCK_COMMENT", "LINE_COMMENT", 
                      "WS", "CLASS_N", "NOT", "ISVOID", "IF", "FI", "THEN", 
                      "ELSE", "WHILE", "LET", "IN", "INHERITS", "LOOP", 
                      "POOL", "NEW", "TRUE", "FALSE", "SELF", "STRING", 
                      "INT", "TYPE", "ID", "ASSIGNMENT", "TIMES", "DIV", 
                      "PLUS", "MINUS", "TILDE", "LESS", "EQLESS", "EQ", 
                      "LPAR", "RPAR", "LCBRACE", "RCBRACE", "LBRACKET", 
                      "RBRACKET", "DOT", "AT", "COLON", "COMA" ]

    RULE_prog = 0
    RULE_class_def = 1
    RULE_feature = 2
    RULE_formal = 3
    RULE_expr = 4

    ruleNames =  [ "prog", "class_def", "feature", "formal", "expr" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    T__4=5
    BLOCK_COMMENT=6
    LINE_COMMENT=7
    WS=8
    CLASS_N=9
    NOT=10
    ISVOID=11
    IF=12
    FI=13
    THEN=14
    ELSE=15
    WHILE=16
    LET=17
    IN=18
    INHERITS=19
    LOOP=20
    POOL=21
    NEW=22
    TRUE=23
    FALSE=24
    SELF=25
    STRING=26
    INT=27
    TYPE=28
    ID=29
    ASSIGNMENT=30
    TIMES=31
    DIV=32
    PLUS=33
    MINUS=34
    TILDE=35
    LESS=36
    EQLESS=37
    EQ=38
    LPAR=39
    RPAR=40
    LCBRACE=41
    RCBRACE=42
    LBRACKET=43
    RBRACKET=44
    DOT=45
    AT=46
    COLON=47
    COMA=48

    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 getRuleIndex(self):
            return YAPLParser.RULE_prog

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class StartContext(ProgContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.ProgContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def class_def(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(YAPLParser.Class_defContext)
            else:
                return self.getTypedRuleContext(YAPLParser.Class_defContext,i)


        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStart" ):
                return visitor.visitStart(self)
            else:
                return visitor.visitChildren(self)



    def prog(self):

        localctx = YAPLParser.ProgContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_prog)
        self._la = 0 # Token type
        try:
            localctx = YAPLParser.StartContext(self, localctx)
            self.enterOuterAlt(localctx, 1)
            self.state = 13 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 10
                self.class_def()
                self.state = 11
                self.match(YAPLParser.T__0)
                self.state = 15 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==9):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Class_defContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return YAPLParser.RULE_class_def

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class DefClassContext(Class_defContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.Class_defContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def CLASS_N(self):
            return self.getToken(YAPLParser.CLASS_N, 0)
        def TYPE(self, i:int=None):
            if i is None:
                return self.getTokens(YAPLParser.TYPE)
            else:
                return self.getToken(YAPLParser.TYPE, i)
        def LCBRACE(self):
            return self.getToken(YAPLParser.LCBRACE, 0)
        def RCBRACE(self):
            return self.getToken(YAPLParser.RCBRACE, 0)
        def INHERITS(self):
            return self.getToken(YAPLParser.INHERITS, 0)
        def feature(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(YAPLParser.FeatureContext)
            else:
                return self.getTypedRuleContext(YAPLParser.FeatureContext,i)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDefClass" ):
                listener.enterDefClass(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDefClass" ):
                listener.exitDefClass(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDefClass" ):
                return visitor.visitDefClass(self)
            else:
                return visitor.visitChildren(self)



    def class_def(self):

        localctx = YAPLParser.Class_defContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_class_def)
        self._la = 0 # Token type
        try:
            localctx = YAPLParser.DefClassContext(self, localctx)
            self.enterOuterAlt(localctx, 1)
            self.state = 17
            self.match(YAPLParser.CLASS_N)
            self.state = 18
            self.match(YAPLParser.TYPE)
            self.state = 21
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==19:
                self.state = 19
                self.match(YAPLParser.INHERITS)
                self.state = 20
                self.match(YAPLParser.TYPE)


            self.state = 23
            self.match(YAPLParser.LCBRACE)
            self.state = 29
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==29:
                self.state = 24
                self.feature()
                self.state = 25
                self.match(YAPLParser.T__0)
                self.state = 31
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 32
            self.match(YAPLParser.RCBRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FeatureContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return YAPLParser.RULE_feature

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class DefAssignContext(FeatureContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.FeatureContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ID(self):
            return self.getToken(YAPLParser.ID, 0)
        def COLON(self):
            return self.getToken(YAPLParser.COLON, 0)
        def TYPE(self):
            return self.getToken(YAPLParser.TYPE, 0)
        def ASSIGNMENT(self):
            return self.getToken(YAPLParser.ASSIGNMENT, 0)
        def expr(self):
            return self.getTypedRuleContext(YAPLParser.ExprContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDefAssign" ):
                listener.enterDefAssign(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDefAssign" ):
                listener.exitDefAssign(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDefAssign" ):
                return visitor.visitDefAssign(self)
            else:
                return visitor.visitChildren(self)


    class DefFuncContext(FeatureContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.FeatureContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ID(self):
            return self.getToken(YAPLParser.ID, 0)
        def LPAR(self):
            return self.getToken(YAPLParser.LPAR, 0)
        def RPAR(self):
            return self.getToken(YAPLParser.RPAR, 0)
        def COLON(self):
            return self.getToken(YAPLParser.COLON, 0)
        def TYPE(self):
            return self.getToken(YAPLParser.TYPE, 0)
        def LCBRACE(self):
            return self.getToken(YAPLParser.LCBRACE, 0)
        def expr(self):
            return self.getTypedRuleContext(YAPLParser.ExprContext,0)

        def RCBRACE(self):
            return self.getToken(YAPLParser.RCBRACE, 0)
        def formal(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(YAPLParser.FormalContext)
            else:
                return self.getTypedRuleContext(YAPLParser.FormalContext,i)

        def COMA(self, i:int=None):
            if i is None:
                return self.getTokens(YAPLParser.COMA)
            else:
                return self.getToken(YAPLParser.COMA, i)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDefFunc" ):
                listener.enterDefFunc(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDefFunc" ):
                listener.exitDefFunc(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDefFunc" ):
                return visitor.visitDefFunc(self)
            else:
                return visitor.visitChildren(self)



    def feature(self):

        localctx = YAPLParser.FeatureContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_feature)
        self._la = 0 # Token type
        try:
            self.state = 60
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
            if la_ == 1:
                localctx = YAPLParser.DefFuncContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 34
                self.match(YAPLParser.ID)
                self.state = 35
                self.match(YAPLParser.LPAR)
                self.state = 44
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==29:
                    self.state = 36
                    self.formal()
                    self.state = 41
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==48:
                        self.state = 37
                        self.match(YAPLParser.COMA)
                        self.state = 38
                        self.formal()
                        self.state = 43
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 46
                self.match(YAPLParser.RPAR)
                self.state = 47
                self.match(YAPLParser.COLON)
                self.state = 48
                self.match(YAPLParser.TYPE)
                self.state = 49
                self.match(YAPLParser.LCBRACE)
                self.state = 50
                self.expr(0)
                self.state = 51
                self.match(YAPLParser.RCBRACE)
                pass

            elif la_ == 2:
                localctx = YAPLParser.DefAssignContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 53
                self.match(YAPLParser.ID)
                self.state = 54
                self.match(YAPLParser.COLON)
                self.state = 55
                self.match(YAPLParser.TYPE)
                self.state = 58
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==30:
                    self.state = 56
                    self.match(YAPLParser.ASSIGNMENT)
                    self.state = 57
                    self.expr(0)


                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class FormalContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return YAPLParser.RULE_formal

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class FormalAssignContext(FormalContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.FormalContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ID(self):
            return self.getToken(YAPLParser.ID, 0)
        def COLON(self):
            return self.getToken(YAPLParser.COLON, 0)
        def TYPE(self):
            return self.getToken(YAPLParser.TYPE, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFormalAssign" ):
                listener.enterFormalAssign(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFormalAssign" ):
                listener.exitFormalAssign(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFormalAssign" ):
                return visitor.visitFormalAssign(self)
            else:
                return visitor.visitChildren(self)



    def formal(self):

        localctx = YAPLParser.FormalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_formal)
        try:
            localctx = YAPLParser.FormalAssignContext(self, localctx)
            self.enterOuterAlt(localctx, 1)
            self.state = 62
            self.match(YAPLParser.ID)
            self.state = 63
            self.match(YAPLParser.COLON)
            self.state = 64
            self.match(YAPLParser.TYPE)
        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 YAPLParser.RULE_expr

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)


    class MinusContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(YAPLParser.ExprContext)
            else:
                return self.getTypedRuleContext(YAPLParser.ExprContext,i)

        def MINUS(self):
            return self.getToken(YAPLParser.MINUS, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMinus" ):
                listener.enterMinus(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMinus" ):
                listener.exitMinus(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMinus" ):
                return visitor.visitMinus(self)
            else:
                return visitor.visitChildren(self)


    class ParensContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def LPAR(self):
            return self.getToken(YAPLParser.LPAR, 0)
        def expr(self):
            return self.getTypedRuleContext(YAPLParser.ExprContext,0)

        def RPAR(self):
            return self.getToken(YAPLParser.RPAR, 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)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitParens" ):
                return visitor.visitParens(self)
            else:
                return visitor.visitChildren(self)


    class StringContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def STRING(self):
            return self.getToken(YAPLParser.STRING, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterString" ):
                listener.enterString(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitString" ):
                listener.exitString(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitString" ):
                return visitor.visitString(self)
            else:
                return visitor.visitChildren(self)


    class IsvoidContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ISVOID(self):
            return self.getToken(YAPLParser.ISVOID, 0)
        def expr(self):
            return self.getTypedRuleContext(YAPLParser.ExprContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIsvoid" ):
                listener.enterIsvoid(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIsvoid" ):
                listener.exitIsvoid(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIsvoid" ):
                return visitor.visitIsvoid(self)
            else:
                return visitor.visitChildren(self)


    class WhileContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def WHILE(self):
            return self.getToken(YAPLParser.WHILE, 0)
        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(YAPLParser.ExprContext)
            else:
                return self.getTypedRuleContext(YAPLParser.ExprContext,i)

        def LOOP(self):
            return self.getToken(YAPLParser.LOOP, 0)
        def POOL(self):
            return self.getToken(YAPLParser.POOL, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterWhile" ):
                listener.enterWhile(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitWhile" ):
                listener.exitWhile(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitWhile" ):
                return visitor.visitWhile(self)
            else:
                return visitor.visitChildren(self)


    class DivContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(YAPLParser.ExprContext)
            else:
                return self.getTypedRuleContext(YAPLParser.ExprContext,i)

        def DIV(self):
            return self.getToken(YAPLParser.DIV, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDiv" ):
                listener.enterDiv(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDiv" ):
                listener.exitDiv(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDiv" ):
                return visitor.visitDiv(self)
            else:
                return visitor.visitChildren(self)


    class NegContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def NOT(self):
            return self.getToken(YAPLParser.NOT, 0)
        def expr(self):
            return self.getTypedRuleContext(YAPLParser.ExprContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNeg" ):
                listener.enterNeg(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNeg" ):
                listener.exitNeg(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNeg" ):
                return visitor.visitNeg(self)
            else:
                return visitor.visitChildren(self)


    class NegativeContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def TILDE(self):
            return self.getToken(YAPLParser.TILDE, 0)
        def expr(self):
            return self.getTypedRuleContext(YAPLParser.ExprContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNegative" ):
                listener.enterNegative(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNegative" ):
                listener.exitNegative(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNegative" ):
                return visitor.visitNegative(self)
            else:
                return visitor.visitChildren(self)


    class TimesContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(YAPLParser.ExprContext)
            else:
                return self.getTypedRuleContext(YAPLParser.ExprContext,i)

        def TIMES(self):
            return self.getToken(YAPLParser.TIMES, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTimes" ):
                listener.enterTimes(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTimes" ):
                listener.exitTimes(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTimes" ):
                return visitor.visitTimes(self)
            else:
                return visitor.visitChildren(self)


    class AndContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(YAPLParser.ExprContext)
            else:
                return self.getTypedRuleContext(YAPLParser.ExprContext,i)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAnd" ):
                listener.enterAnd(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAnd" ):
                listener.exitAnd(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAnd" ):
                return visitor.visitAnd(self)
            else:
                return visitor.visitChildren(self)


    class LessThanContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(YAPLParser.ExprContext)
            else:
                return self.getTypedRuleContext(YAPLParser.ExprContext,i)

        def LESS(self):
            return self.getToken(YAPLParser.LESS, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLessThan" ):
                listener.enterLessThan(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLessThan" ):
                listener.exitLessThan(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLessThan" ):
                return visitor.visitLessThan(self)
            else:
                return visitor.visitChildren(self)


    class BlockContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def LCBRACE(self):
            return self.getToken(YAPLParser.LCBRACE, 0)
        def RCBRACE(self):
            return self.getToken(YAPLParser.RCBRACE, 0)
        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(YAPLParser.ExprContext)
            else:
                return self.getTypedRuleContext(YAPLParser.ExprContext,i)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBlock" ):
                listener.enterBlock(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBlock" ):
                listener.exitBlock(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBlock" ):
                return visitor.visitBlock(self)
            else:
                return visitor.visitChildren(self)


    class IdContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ID(self):
            return self.getToken(YAPLParser.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)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitId" ):
                return visitor.visitId(self)
            else:
                return visitor.visitChildren(self)


    class IfContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def IF(self):
            return self.getToken(YAPLParser.IF, 0)
        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(YAPLParser.ExprContext)
            else:
                return self.getTypedRuleContext(YAPLParser.ExprContext,i)

        def THEN(self):
            return self.getToken(YAPLParser.THEN, 0)
        def ELSE(self):
            return self.getToken(YAPLParser.ELSE, 0)
        def FI(self):
            return self.getToken(YAPLParser.FI, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIf" ):
                listener.enterIf(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIf" ):
                listener.exitIf(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIf" ):
                return visitor.visitIf(self)
            else:
                return visitor.visitChildren(self)


    class GreaterThanContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(YAPLParser.ExprContext)
            else:
                return self.getTypedRuleContext(YAPLParser.ExprContext,i)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterGreaterThan" ):
                listener.enterGreaterThan(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitGreaterThan" ):
                listener.exitGreaterThan(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitGreaterThan" ):
                return visitor.visitGreaterThan(self)
            else:
                return visitor.visitChildren(self)


    class NewContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def NEW(self):
            return self.getToken(YAPLParser.NEW, 0)
        def TYPE(self):
            return self.getToken(YAPLParser.TYPE, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNew" ):
                listener.enterNew(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNew" ):
                listener.exitNew(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNew" ):
                return visitor.visitNew(self)
            else:
                return visitor.visitChildren(self)


    class OrContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(YAPLParser.ExprContext)
            else:
                return self.getTypedRuleContext(YAPLParser.ExprContext,i)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOr" ):
                listener.enterOr(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOr" ):
                listener.exitOr(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitOr" ):
                return visitor.visitOr(self)
            else:
                return visitor.visitChildren(self)


    class AssignmentContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ID(self):
            return self.getToken(YAPLParser.ID, 0)
        def ASSIGNMENT(self):
            return self.getToken(YAPLParser.ASSIGNMENT, 0)
        def expr(self):
            return self.getTypedRuleContext(YAPLParser.ExprContext,0)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssignment" ):
                listener.enterAssignment(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssignment" ):
                listener.exitAssignment(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssignment" ):
                return visitor.visitAssignment(self)
            else:
                return visitor.visitChildren(self)


    class DispatchImplicitContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ID(self):
            return self.getToken(YAPLParser.ID, 0)
        def LPAR(self):
            return self.getToken(YAPLParser.LPAR, 0)
        def RPAR(self):
            return self.getToken(YAPLParser.RPAR, 0)
        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(YAPLParser.ExprContext)
            else:
                return self.getTypedRuleContext(YAPLParser.ExprContext,i)

        def COMA(self, i:int=None):
            if i is None:
                return self.getTokens(YAPLParser.COMA)
            else:
                return self.getToken(YAPLParser.COMA, i)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDispatchImplicit" ):
                listener.enterDispatchImplicit(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDispatchImplicit" ):
                listener.exitDispatchImplicit(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDispatchImplicit" ):
                return visitor.visitDispatchImplicit(self)
            else:
                return visitor.visitChildren(self)


    class IntContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def INT(self):
            return self.getToken(YAPLParser.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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInt" ):
                return visitor.visitInt(self)
            else:
                return visitor.visitChildren(self)


    class PlusContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(YAPLParser.ExprContext)
            else:
                return self.getTypedRuleContext(YAPLParser.ExprContext,i)

        def PLUS(self):
            return self.getToken(YAPLParser.PLUS, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPlus" ):
                listener.enterPlus(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPlus" ):
                listener.exitPlus(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitPlus" ):
                return visitor.visitPlus(self)
            else:
                return visitor.visitChildren(self)


    class DispatchAttributeContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expr(self):
            return self.getTypedRuleContext(YAPLParser.ExprContext,0)

        def DOT(self):
            return self.getToken(YAPLParser.DOT, 0)
        def ID(self):
            return self.getToken(YAPLParser.ID, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDispatchAttribute" ):
                listener.enterDispatchAttribute(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDispatchAttribute" ):
                listener.exitDispatchAttribute(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDispatchAttribute" ):
                return visitor.visitDispatchAttribute(self)
            else:
                return visitor.visitChildren(self)


    class GreaterThanOrEqualContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(YAPLParser.ExprContext)
            else:
                return self.getTypedRuleContext(YAPLParser.ExprContext,i)


        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterGreaterThanOrEqual" ):
                listener.enterGreaterThanOrEqual(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitGreaterThanOrEqual" ):
                listener.exitGreaterThanOrEqual(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitGreaterThanOrEqual" ):
                return visitor.visitGreaterThanOrEqual(self)
            else:
                return visitor.visitChildren(self)


    class EqualContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(YAPLParser.ExprContext)
            else:
                return self.getTypedRuleContext(YAPLParser.ExprContext,i)

        def EQ(self):
            return self.getToken(YAPLParser.EQ, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterEqual" ):
                listener.enterEqual(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitEqual" ):
                listener.exitEqual(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitEqual" ):
                return visitor.visitEqual(self)
            else:
                return visitor.visitChildren(self)


    class BooleanContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.ExprContext
            super().__init__(parser)
            self.bool_ = None # Token
            self.copyFrom(ctx)

        def TRUE(self):
            return self.getToken(YAPLParser.TRUE, 0)
        def FALSE(self):
            return self.getToken(YAPLParser.FALSE, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBoolean" ):
                listener.enterBoolean(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBoolean" ):
                listener.exitBoolean(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBoolean" ):
                return visitor.visitBoolean(self)
            else:
                return visitor.visitChildren(self)


    class LetIdContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def LET(self):
            return self.getToken(YAPLParser.LET, 0)
        def ID(self, i:int=None):
            if i is None:
                return self.getTokens(YAPLParser.ID)
            else:
                return self.getToken(YAPLParser.ID, i)
        def COLON(self, i:int=None):
            if i is None:
                return self.getTokens(YAPLParser.COLON)
            else:
                return self.getToken(YAPLParser.COLON, i)
        def TYPE(self, i:int=None):
            if i is None:
                return self.getTokens(YAPLParser.TYPE)
            else:
                return self.getToken(YAPLParser.TYPE, i)
        def IN(self):
            return self.getToken(YAPLParser.IN, 0)
        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(YAPLParser.ExprContext)
            else:
                return self.getTypedRuleContext(YAPLParser.ExprContext,i)

        def ASSIGNMENT(self, i:int=None):
            if i is None:
                return self.getTokens(YAPLParser.ASSIGNMENT)
            else:
                return self.getToken(YAPLParser.ASSIGNMENT, i)
        def COMA(self, i:int=None):
            if i is None:
                return self.getTokens(YAPLParser.COMA)
            else:
                return self.getToken(YAPLParser.COMA, i)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLetId" ):
                listener.enterLetId(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLetId" ):
                listener.exitLetId(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLetId" ):
                return visitor.visitLetId(self)
            else:
                return visitor.visitChildren(self)


    class LessThanOrEqualContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(YAPLParser.ExprContext)
            else:
                return self.getTypedRuleContext(YAPLParser.ExprContext,i)

        def EQLESS(self):
            return self.getToken(YAPLParser.EQLESS, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLessThanOrEqual" ):
                listener.enterLessThanOrEqual(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLessThanOrEqual" ):
                listener.exitLessThanOrEqual(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLessThanOrEqual" ):
                return visitor.visitLessThanOrEqual(self)
            else:
                return visitor.visitChildren(self)


    class SelfContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def SELF(self):
            return self.getToken(YAPLParser.SELF, 0)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSelf" ):
                listener.enterSelf(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSelf" ):
                listener.exitSelf(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSelf" ):
                return visitor.visitSelf(self)
            else:
                return visitor.visitChildren(self)


    class DispatchExplicitContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a YAPLParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(YAPLParser.ExprContext)
            else:
                return self.getTypedRuleContext(YAPLParser.ExprContext,i)

        def DOT(self):
            return self.getToken(YAPLParser.DOT, 0)
        def ID(self):
            return self.getToken(YAPLParser.ID, 0)
        def LPAR(self):
            return self.getToken(YAPLParser.LPAR, 0)
        def RPAR(self):
            return self.getToken(YAPLParser.RPAR, 0)
        def AT(self):
            return self.getToken(YAPLParser.AT, 0)
        def TYPE(self):
            return self.getToken(YAPLParser.TYPE, 0)
        def COMA(self, i:int=None):
            if i is None:
                return self.getTokens(YAPLParser.COMA)
            else:
                return self.getToken(YAPLParser.COMA, i)

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDispatchExplicit" ):
                listener.enterDispatchExplicit(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDispatchExplicit" ):
                listener.exitDispatchExplicit(self)

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDispatchExplicit" ):
                return visitor.visitDispatchExplicit(self)
            else:
                return visitor.visitChildren(self)



    def expr(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = YAPLParser.ExprContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 8
        self.enterRecursionRule(localctx, 8, self.RULE_expr, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 147
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,13,self._ctx)
            if la_ == 1:
                localctx = YAPLParser.DispatchImplicitContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 67
                self.match(YAPLParser.ID)
                self.state = 68
                self.match(YAPLParser.LPAR)
                self.state = 77
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2783940123648) != 0):
                    self.state = 69
                    self.expr(0)
                    self.state = 74
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while _la==48:
                        self.state = 70
                        self.match(YAPLParser.COMA)
                        self.state = 71
                        self.expr(0)
                        self.state = 76
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)



                self.state = 79
                self.match(YAPLParser.RPAR)
                pass

            elif la_ == 2:
                localctx = YAPLParser.IfContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 80
                self.match(YAPLParser.IF)
                self.state = 81
                self.expr(0)
                self.state = 82
                self.match(YAPLParser.THEN)
                self.state = 83
                self.expr(0)
                self.state = 84
                self.match(YAPLParser.ELSE)
                self.state = 85
                self.expr(0)
                self.state = 86
                self.match(YAPLParser.FI)
                pass

            elif la_ == 3:
                localctx = YAPLParser.WhileContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 88
                self.match(YAPLParser.WHILE)
                self.state = 89
                self.expr(0)
                self.state = 90
                self.match(YAPLParser.LOOP)
                self.state = 91
                self.expr(0)
                self.state = 92
                self.match(YAPLParser.POOL)
                pass

            elif la_ == 4:
                localctx = YAPLParser.BlockContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 94
                self.match(YAPLParser.LCBRACE)
                self.state = 98 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 95
                    self.expr(0)
                    self.state = 96
                    self.match(YAPLParser.T__0)
                    self.state = 100 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & 2783940123648) != 0)):
                        break

                self.state = 102
                self.match(YAPLParser.RCBRACE)
                pass

            elif la_ == 5:
                localctx = YAPLParser.LetIdContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 104
                self.match(YAPLParser.LET)
                self.state = 105
                self.match(YAPLParser.ID)
                self.state = 106
                self.match(YAPLParser.COLON)
                self.state = 107
                self.match(YAPLParser.TYPE)
                self.state = 110
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==30:
                    self.state = 108
                    self.match(YAPLParser.ASSIGNMENT)
                    self.state = 109
                    self.expr(0)


                self.state = 122
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==48:
                    self.state = 112
                    self.match(YAPLParser.COMA)
                    self.state = 113
                    self.match(YAPLParser.ID)
                    self.state = 114
                    self.match(YAPLParser.COLON)
                    self.state = 115
                    self.match(YAPLParser.TYPE)
                    self.state = 118
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==30:
                        self.state = 116
                        self.match(YAPLParser.ASSIGNMENT)
                        self.state = 117
                        self.expr(0)


                    self.state = 124
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 125
                self.match(YAPLParser.IN)
                self.state = 126
                self.expr(23)
                pass

            elif la_ == 6:
                localctx = YAPLParser.NewContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 127
                self.match(YAPLParser.NEW)
                self.state = 128
                self.match(YAPLParser.TYPE)
                pass

            elif la_ == 7:
                localctx = YAPLParser.NegativeContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 129
                self.match(YAPLParser.TILDE)
                self.state = 130
                self.expr(21)
                pass

            elif la_ == 8:
                localctx = YAPLParser.IsvoidContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 131
                self.match(YAPLParser.ISVOID)
                self.state = 132
                self.expr(20)
                pass

            elif la_ == 9:
                localctx = YAPLParser.NegContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 133
                self.match(YAPLParser.NOT)
                self.state = 134
                self.expr(8)
                pass

            elif la_ == 10:
                localctx = YAPLParser.ParensContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 135
                self.match(YAPLParser.LPAR)
                self.state = 136
                self.expr(0)
                self.state = 137
                self.match(YAPLParser.RPAR)
                pass

            elif la_ == 11:
                localctx = YAPLParser.AssignmentContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 139
                self.match(YAPLParser.ID)
                self.state = 140
                self.match(YAPLParser.ASSIGNMENT)
                self.state = 141
                self.expr(6)
                pass

            elif la_ == 12:
                localctx = YAPLParser.IdContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 142
                self.match(YAPLParser.ID)
                pass

            elif la_ == 13:
                localctx = YAPLParser.IntContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 143
                self.match(YAPLParser.INT)
                pass

            elif la_ == 14:
                localctx = YAPLParser.StringContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 144
                self.match(YAPLParser.STRING)
                pass

            elif la_ == 15:
                localctx = YAPLParser.BooleanContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 145
                localctx.bool_ = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==23 or _la==24):
                    localctx.bool_ = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass

            elif la_ == 16:
                localctx = YAPLParser.SelfContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 146
                self.match(YAPLParser.SELF)
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 206
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,18,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 = 204
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,17,self._ctx)
                    if la_ == 1:
                        localctx = YAPLParser.TimesContext(self, YAPLParser.ExprContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 149
                        if not self.precpred(self._ctx, 19):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 19)")
                        self.state = 150
                        self.match(YAPLParser.TIMES)
                        self.state = 151
                        self.expr(20)
                        pass

                    elif la_ == 2:
                        localctx = YAPLParser.DivContext(self, YAPLParser.ExprContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 152
                        if not self.precpred(self._ctx, 18):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 18)")
                        self.state = 153
                        self.match(YAPLParser.DIV)
                        self.state = 154
                        self.expr(19)
                        pass

                    elif la_ == 3:
                        localctx = YAPLParser.PlusContext(self, YAPLParser.ExprContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 155
                        if not self.precpred(self._ctx, 17):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 17)")
                        self.state = 156
                        self.match(YAPLParser.PLUS)
                        self.state = 157
                        self.expr(18)
                        pass

                    elif la_ == 4:
                        localctx = YAPLParser.MinusContext(self, YAPLParser.ExprContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 158
                        if not self.precpred(self._ctx, 16):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 16)")
                        self.state = 159
                        self.match(YAPLParser.MINUS)
                        self.state = 160
                        self.expr(17)
                        pass

                    elif la_ == 5:
                        localctx = YAPLParser.LessThanOrEqualContext(self, YAPLParser.ExprContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 161
                        if not self.precpred(self._ctx, 15):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 15)")
                        self.state = 162
                        self.match(YAPLParser.EQLESS)
                        self.state = 163
                        self.expr(16)
                        pass

                    elif la_ == 6:
                        localctx = YAPLParser.LessThanContext(self, YAPLParser.ExprContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 164
                        if not self.precpred(self._ctx, 14):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 14)")
                        self.state = 165
                        self.match(YAPLParser.LESS)
                        self.state = 166
                        self.expr(15)
                        pass

                    elif la_ == 7:
                        localctx = YAPLParser.GreaterThanContext(self, YAPLParser.ExprContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 167
                        if not self.precpred(self._ctx, 13):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 13)")
                        self.state = 168
                        self.match(YAPLParser.T__1)
                        self.state = 169
                        self.expr(14)
                        pass

                    elif la_ == 8:
                        localctx = YAPLParser.GreaterThanOrEqualContext(self, YAPLParser.ExprContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 170
                        if not self.precpred(self._ctx, 12):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 12)")
                        self.state = 171
                        self.match(YAPLParser.T__2)
                        self.state = 172
                        self.expr(13)
                        pass

                    elif la_ == 9:
                        localctx = YAPLParser.EqualContext(self, YAPLParser.ExprContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 173
                        if not self.precpred(self._ctx, 11):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 11)")
                        self.state = 174
                        self.match(YAPLParser.EQ)
                        self.state = 175
                        self.expr(12)
                        pass

                    elif la_ == 10:
                        localctx = YAPLParser.AndContext(self, YAPLParser.ExprContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 176
                        if not self.precpred(self._ctx, 10):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 10)")
                        self.state = 177
                        self.match(YAPLParser.T__3)
                        self.state = 178
                        self.expr(11)
                        pass

                    elif la_ == 11:
                        localctx = YAPLParser.OrContext(self, YAPLParser.ExprContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 179
                        if not self.precpred(self._ctx, 9):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 9)")
                        self.state = 180
                        self.match(YAPLParser.T__4)
                        self.state = 181
                        self.expr(10)
                        pass

                    elif la_ == 12:
                        localctx = YAPLParser.DispatchExplicitContext(self, YAPLParser.ExprContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 182
                        if not self.precpred(self._ctx, 29):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 29)")
                        self.state = 185
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==46:
                            self.state = 183
                            self.match(YAPLParser.AT)
                            self.state = 184
                            self.match(YAPLParser.TYPE)


                        self.state = 187
                        self.match(YAPLParser.DOT)
                        self.state = 188
                        self.match(YAPLParser.ID)
                        self.state = 189
                        self.match(YAPLParser.LPAR)
                        self.state = 198
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if (((_la) & ~0x3f) == 0 and ((1 << _la) & 2783940123648) != 0):
                            self.state = 190
                            self.expr(0)
                            self.state = 195
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)
                            while _la==48:
                                self.state = 191
                                self.match(YAPLParser.COMA)
                                self.state = 192
                                self.expr(0)
                                self.state = 197
                                self._errHandler.sync(self)
                                _la = self._input.LA(1)



                        self.state = 200
                        self.match(YAPLParser.RPAR)
                        pass

                    elif la_ == 13:
                        localctx = YAPLParser.DispatchAttributeContext(self, YAPLParser.ExprContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 201
                        if not self.precpred(self._ctx, 27):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 27)")
                        self.state = 202
                        self.match(YAPLParser.DOT)
                        self.state = 203
                        self.match(YAPLParser.ID)
                        pass

             
                self.state = 208
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,18,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[4] = 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, 19)
         

            if predIndex == 1:
                return self.precpred(self._ctx, 18)
         

            if predIndex == 2:
                return self.precpred(self._ctx, 17)
         

            if predIndex == 3:
                return self.precpred(self._ctx, 16)
         

            if predIndex == 4:
                return self.precpred(self._ctx, 15)
         

            if predIndex == 5:
                return self.precpred(self._ctx, 14)
         

            if predIndex == 6:
                return self.precpred(self._ctx, 13)
         

            if predIndex == 7:
                return self.precpred(self._ctx, 12)
         

            if predIndex == 8:
                return self.precpred(self._ctx, 11)
         

            if predIndex == 9:
                return self.precpred(self._ctx, 10)
         

            if predIndex == 10:
                return self.precpred(self._ctx, 9)
         

            if predIndex == 11:
                return self.precpred(self._ctx, 29)
         

            if predIndex == 12:
                return self.precpred(self._ctx, 27)