# Generated from grammar/doc/doc.g4 by ANTLR 4.9.3
# 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


from asd import doc


def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\t")
        buf.write("\34\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\3\2\3\2\3\2\3\2\3")
        buf.write("\2\3\3\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\5\3\5\3\5\3\5")
        buf.write("\2\2\6\2\4\6\b\2\2\2\27\2\n\3\2\2\2\4\17\3\2\2\2\6\25")
        buf.write("\3\2\2\2\b\30\3\2\2\2\n\13\7\3\2\2\13\f\5\4\3\2\f\r\7")
        buf.write("\4\2\2\r\16\b\2\1\2\16\3\3\2\2\2\17\20\7\5\2\2\20\21\5")
        buf.write("\6\4\2\21\22\5\b\5\2\22\23\7\6\2\2\23\24\b\3\1\2\24\5")
        buf.write("\3\2\2\2\25\26\7\b\2\2\26\27\b\4\1\2\27\7\3\2\2\2\30\31")
        buf.write("\7\t\2\2\31\32\b\5\1\2\32\t\3\2\2\2\2")
        return buf.getvalue()


class docParser ( Parser ):

    grammarFileName = "doc.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'[D]'", "'[/D]'", "'[S:R1]'", "'[/S]'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "WS", "ORG", "UNL" ]

    RULE_document = 0
    RULE_sentence = 1
    RULE_orgPart = 2
    RULE_unlPart = 3

    ruleNames =  [ "document", "sentence", "orgPart", "unlPart" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    WS=5
    ORG=6
    UNL=7

    def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
        super().__init__(input, output)
        self.checkVersion("4.9.3")
        self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
        self._predicates = None




    class DocumentContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sentence(self):
            return self.getTypedRuleContext(docParser.SentenceContext,0)


        def getRuleIndex(self):
            return docParser.RULE_document

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

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




    def document(self):

        localctx = docParser.DocumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_document)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 8
            self.match(docParser.T__0)
            self.state = 9
            localctx.s = self.sentence()
            self.state = 10
            self.match(docParser.T__1)
            localctx.out = doc.Document(localctx.s.out)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SentenceContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser
            self.out = None
            self.o = None # OrgPartContext
            self.u = None # UnlPartContext

        def orgPart(self):
            return self.getTypedRuleContext(docParser.OrgPartContext,0)


        def unlPart(self):
            return self.getTypedRuleContext(docParser.UnlPartContext,0)


        def getRuleIndex(self):
            return docParser.RULE_sentence

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

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




    def sentence(self):

        localctx = docParser.SentenceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_sentence)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 13
            self.match(docParser.T__2)
            self.state = 14
            localctx.o = self.orgPart()
            self.state = 15
            localctx.u = self.unlPart()
            self.state = 16
            self.match(docParser.T__3)
            localctx.out = doc.Sentence(localctx.o.out, localctx.u.out)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OrgPartContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ORG(self):
            return self.getToken(docParser.ORG, 0)

        def getRuleIndex(self):
            return docParser.RULE_orgPart

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

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




    def orgPart(self):

        localctx = docParser.OrgPartContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_orgPart)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 19
            localctx.o = self.match(docParser.ORG)
            localctx.out = doc.OrgPart((None if localctx.o is None else localctx.o.text))
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class UnlPartContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def UNL(self):
            return self.getToken(docParser.UNL, 0)

        def getRuleIndex(self):
            return docParser.RULE_unlPart

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

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




    def unlPart(self):

        localctx = docParser.UnlPartContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_unlPart)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 22
            localctx.u = self.match(docParser.UNL)
            localctx.out = doc.UnlPart((None if localctx.u is None else localctx.u.text))
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx