# Generated from /home/erik/PycharmProjects/pythonProject/grammar/ANF.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,14,60,2,0,7,0,2,1,7,1,2,2,7,2,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,
        0,1,0,3,0,16,8,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,
        5,0,30,8,0,10,0,12,0,33,9,0,1,1,1,1,1,1,1,1,1,1,5,1,40,8,1,10,1,
        12,1,43,9,1,1,1,1,1,1,1,3,1,48,8,1,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,
        2,3,2,58,8,2,1,2,0,1,0,3,0,2,4,0,0,65,0,15,1,0,0,0,2,47,1,0,0,0,
        4,57,1,0,0,0,6,7,6,0,-1,0,7,16,5,12,0,0,8,16,5,13,0,0,9,10,5,5,0,
        0,10,11,5,12,0,0,11,12,5,6,0,0,12,13,3,4,2,0,13,14,5,7,0,0,14,16,
        1,0,0,0,15,6,1,0,0,0,15,8,1,0,0,0,15,9,1,0,0,0,16,31,1,0,0,0,17,
        18,10,5,0,0,18,19,5,1,0,0,19,30,3,0,0,6,20,21,10,4,0,0,21,22,5,2,
        0,0,22,30,3,0,0,5,23,24,10,3,0,0,24,25,5,3,0,0,25,30,3,0,0,4,26,
        27,10,2,0,0,27,28,5,4,0,0,28,30,3,0,0,3,29,17,1,0,0,0,29,20,1,0,
        0,0,29,23,1,0,0,0,29,26,1,0,0,0,30,33,1,0,0,0,31,29,1,0,0,0,31,32,
        1,0,0,0,32,1,1,0,0,0,33,31,1,0,0,0,34,35,5,12,0,0,35,36,5,5,0,0,
        36,41,3,0,0,0,37,38,5,8,0,0,38,40,3,0,0,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,44,1,0,0,0,43,41,1,0,0,0,44,
        45,5,7,0,0,45,48,1,0,0,0,46,48,3,0,0,0,47,34,1,0,0,0,47,46,1,0,0,
        0,48,3,1,0,0,0,49,50,5,9,0,0,50,51,5,12,0,0,51,52,5,10,0,0,52,53,
        3,2,1,0,53,54,5,11,0,0,54,55,3,4,2,0,55,58,1,0,0,0,56,58,3,2,1,0,
        57,49,1,0,0,0,57,56,1,0,0,0,58,5,1,0,0,0,6,15,29,31,41,47,57
    ]

class ANFParser ( Parser ):

    grammarFileName = "ANF.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'+'", "'-'", "'*'", "'/'", "'('", "':'", 
                     "')'", "','", "'let'", "'='", "'in'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "IDENT", "NUMBER", "WS" ]

    RULE_aexp = 0
    RULE_funcall = 1
    RULE_cexp = 2

    ruleNames =  [ "aexp", "funcall", "cexp" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    T__4=5
    T__5=6
    T__6=7
    T__7=8
    T__8=9
    T__9=10
    T__10=11
    IDENT=12
    NUMBER=13
    WS=14

    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 AexpContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def IDENT(self):
            return self.getToken(ANFParser.IDENT, 0)

        def NUMBER(self):
            return self.getToken(ANFParser.NUMBER, 0)

        def cexp(self):
            return self.getTypedRuleContext(ANFParser.CexpContext,0)


        def aexp(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(ANFParser.AexpContext)
            else:
                return self.getTypedRuleContext(ANFParser.AexpContext,i)


        def getRuleIndex(self):
            return ANFParser.RULE_aexp

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

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

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



    def aexp(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = ANFParser.AexpContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 0
        self.enterRecursionRule(localctx, 0, self.RULE_aexp, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 15
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [12]:
                self.state = 7
                self.match(ANFParser.IDENT)
                pass
            elif token in [13]:
                self.state = 8
                self.match(ANFParser.NUMBER)
                pass
            elif token in [5]:
                self.state = 9
                self.match(ANFParser.T__4)
                self.state = 10
                self.match(ANFParser.IDENT)
                self.state = 11
                self.match(ANFParser.T__5)
                self.state = 12
                self.cexp()
                self.state = 13
                self.match(ANFParser.T__6)
                pass
            else:
                raise NoViableAltException(self)

            self._ctx.stop = self._input.LT(-1)
            self.state = 31
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,2,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 29
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,1,self._ctx)
                    if la_ == 1:
                        localctx = ANFParser.AexpContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_aexp)
                        self.state = 17
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 18
                        self.match(ANFParser.T__0)
                        self.state = 19
                        self.aexp(6)
                        pass

                    elif la_ == 2:
                        localctx = ANFParser.AexpContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_aexp)
                        self.state = 20
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 21
                        self.match(ANFParser.T__1)
                        self.state = 22
                        self.aexp(5)
                        pass

                    elif la_ == 3:
                        localctx = ANFParser.AexpContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_aexp)
                        self.state = 23
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 24
                        self.match(ANFParser.T__2)
                        self.state = 25
                        self.aexp(4)
                        pass

                    elif la_ == 4:
                        localctx = ANFParser.AexpContext(self, _parentctx, _parentState)
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_aexp)
                        self.state = 26
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 27
                        self.match(ANFParser.T__3)
                        self.state = 28
                        self.aexp(3)
                        pass

             
                self.state = 33
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,2,self._ctx)

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


    class FuncallContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def IDENT(self):
            return self.getToken(ANFParser.IDENT, 0)

        def aexp(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(ANFParser.AexpContext)
            else:
                return self.getTypedRuleContext(ANFParser.AexpContext,i)


        def getRuleIndex(self):
            return ANFParser.RULE_funcall

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

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

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




    def funcall(self):

        localctx = ANFParser.FuncallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_funcall)
        self._la = 0 # Token type
        try:
            self.state = 47
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,4,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 34
                self.match(ANFParser.IDENT)
                self.state = 35
                self.match(ANFParser.T__4)
                self.state = 36
                self.aexp(0)
                self.state = 41
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==8:
                    self.state = 37
                    self.match(ANFParser.T__7)
                    self.state = 38
                    self.aexp(0)
                    self.state = 43
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 44
                self.match(ANFParser.T__6)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 46
                self.aexp(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 CexpContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def IDENT(self):
            return self.getToken(ANFParser.IDENT, 0)

        def funcall(self):
            return self.getTypedRuleContext(ANFParser.FuncallContext,0)


        def cexp(self):
            return self.getTypedRuleContext(ANFParser.CexpContext,0)


        def getRuleIndex(self):
            return ANFParser.RULE_cexp

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

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

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




    def cexp(self):

        localctx = ANFParser.CexpContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_cexp)
        try:
            self.state = 57
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [9]:
                self.enterOuterAlt(localctx, 1)
                self.state = 49
                self.match(ANFParser.T__8)
                self.state = 50
                self.match(ANFParser.IDENT)
                self.state = 51
                self.match(ANFParser.T__9)
                self.state = 52
                self.funcall()
                self.state = 53
                self.match(ANFParser.T__10)
                self.state = 54
                self.cexp()
                pass
            elif token in [5, 12, 13]:
                self.enterOuterAlt(localctx, 2)
                self.state = 56
                self.funcall()
                pass
            else:
                raise NoViableAltException(self)

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



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[0] = self.aexp_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 aexp_sempred(self, localctx:AexpContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 5)
         

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

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

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