# Generated from T.g4 by ANTLR 4.6
# encoding: utf-8
from antlr4 import *
from io import StringIO

def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3$")
        buf.write("\u0120\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
        buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\3\2")
        buf.write("\3\2\7\2\63\n\2\f\2\16\2\66\13\2\3\3\3\3\7\3:\n\3\f\3")
        buf.write("\16\3=\13\3\3\4\3\4\3\4\3\4\5\4C\n\4\3\5\5\5F\n\5\3\5")
        buf.write("\7\5I\n\5\f\5\16\5L\13\5\3\5\3\5\3\5\3\5\5\5R\n\5\3\6")
        buf.write("\3\6\3\6\5\6W\n\6\3\7\5\7Z\n\7\3\7\7\7]\n\7\f\7\16\7`")
        buf.write("\13\7\3\7\3\7\3\7\3\7\7\7f\n\7\f\7\16\7i\13\7\3\7\3\7")
        buf.write("\5\7m\n\7\3\b\3\b\5\bq\n\b\3\t\5\tt\n\t\3\t\7\tw\n\t\f")
        buf.write("\t\16\tz\13\t\3\t\5\t}\n\t\3\t\3\t\5\t\u0081\n\t\3\t\3")
        buf.write("\t\3\t\7\t\u0086\n\t\f\t\16\t\u0089\13\t\3\t\3\t\5\t\u008d")
        buf.write("\n\t\3\n\5\n\u0090\n\n\3\n\7\n\u0093\n\n\f\n\16\n\u0096")
        buf.write("\13\n\3\n\5\n\u0099\n\n\3\n\3\n\3\n\5\n\u009e\n\n\3\13")
        buf.write("\3\13\3\13\5\13\u00a3\n\13\3\f\3\f\3\f\7\f\u00a8\n\f\f")
        buf.write("\f\16\f\u00ab\13\f\3\f\3\f\3\r\3\r\3\r\5\r\u00b2\n\r\3")
        buf.write("\16\3\16\3\16\3\16\5\16\u00b8\n\16\3\17\3\17\3\20\3\20")
        buf.write("\3\20\3\20\3\20\5\20\u00c1\n\20\3\21\3\21\3\21\3\21\3")
        buf.write("\21\3\22\3\22\3\22\3\22\3\22\3\23\5\23\u00ce\n\23\3\23")
        buf.write("\7\23\u00d1\n\23\f\23\16\23\u00d4\13\23\3\23\3\23\3\23")
        buf.write("\3\23\7\23\u00da\n\23\f\23\16\23\u00dd\13\23\3\23\3\23")
        buf.write("\5\23\u00e1\n\23\3\24\5\24\u00e4\n\24\3\24\7\24\u00e7")
        buf.write("\n\24\f\24\16\24\u00ea\13\24\3\24\3\24\3\24\5\24\u00ef")
        buf.write("\n\24\3\25\5\25\u00f2\n\25\3\25\7\25\u00f5\n\25\f\25\16")
        buf.write("\25\u00f8\13\25\3\25\3\25\3\25\3\25\7\25\u00fe\n\25\f")
        buf.write("\25\16\25\u0101\13\25\3\25\3\25\5\25\u0105\n\25\3\26\3")
        buf.write("\26\5\26\u0109\n\26\3\27\5\27\u010c\n\27\3\27\7\27\u010f")
        buf.write("\n\27\f\27\16\27\u0112\13\27\3\27\3\27\3\27\5\27\u0117")
        buf.write("\n\27\3\27\5\27\u011a\n\27\3\30\3\30\5\30\u011e\n\30\3")
        buf.write("\30\2\2\31\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$")
        buf.write("&(*,.\2\2\u013a\2\60\3\2\2\2\4\67\3\2\2\2\6>\3\2\2\2\b")
        buf.write("E\3\2\2\2\nV\3\2\2\2\fY\3\2\2\2\16p\3\2\2\2\20s\3\2\2")
        buf.write("\2\22\u008f\3\2\2\2\24\u009f\3\2\2\2\26\u00a4\3\2\2\2")
        buf.write("\30\u00ae\3\2\2\2\32\u00b7\3\2\2\2\34\u00b9\3\2\2\2\36")
        buf.write("\u00c0\3\2\2\2 \u00c2\3\2\2\2\"\u00c7\3\2\2\2$\u00cd\3")
        buf.write("\2\2\2&\u00e3\3\2\2\2(\u00f1\3\2\2\2*\u0108\3\2\2\2,\u010b")
        buf.write("\3\2\2\2.\u011d\3\2\2\2\60\64\5\4\3\2\61\63\5\n\6\2\62")
        buf.write("\61\3\2\2\2\63\66\3\2\2\2\64\62\3\2\2\2\64\65\3\2\2\2")
        buf.write("\65\3\3\2\2\2\66\64\3\2\2\2\67;\5\b\5\28:\5\6\4\298\3")
        buf.write("\2\2\2:=\3\2\2\2;9\3\2\2\2;<\3\2\2\2<\5\3\2\2\2=;\3\2")
        buf.write("\2\2>?\7\3\2\2?@\7\37\2\2@B\7 \2\2AC\7\4\2\2BA\3\2\2\2")
        buf.write("BC\3\2\2\2C\7\3\2\2\2DF\7!\2\2ED\3\2\2\2EF\3\2\2\2FJ\3")
        buf.write("\2\2\2GI\5\26\f\2HG\3\2\2\2IL\3\2\2\2JH\3\2\2\2JK\3\2")
        buf.write("\2\2KM\3\2\2\2LJ\3\2\2\2MN\7\5\2\2NO\7\37\2\2OQ\7 \2\2")
        buf.write("PR\7\4\2\2QP\3\2\2\2QR\3\2\2\2R\t\3\2\2\2SW\5\f\7\2TW")
        buf.write("\5$\23\2UW\5(\25\2VS\3\2\2\2VT\3\2\2\2VU\3\2\2\2W\13\3")
        buf.write("\2\2\2XZ\7!\2\2YX\3\2\2\2YZ\3\2\2\2Z^\3\2\2\2[]\5\26\f")
        buf.write("\2\\[\3\2\2\2]`\3\2\2\2^\\\3\2\2\2^_\3\2\2\2_a\3\2\2\2")
        buf.write("`^\3\2\2\2ab\7\6\2\2bc\7\37\2\2cg\7\7\2\2df\5\16\b\2e")
        buf.write("d\3\2\2\2fi\3\2\2\2ge\3\2\2\2gh\3\2\2\2hj\3\2\2\2ig\3")
        buf.write("\2\2\2jl\7\b\2\2km\7\4\2\2lk\3\2\2\2lm\3\2\2\2m\r\3\2")
        buf.write("\2\2nq\5\20\t\2oq\5\22\n\2pn\3\2\2\2po\3\2\2\2q\17\3\2")
        buf.write("\2\2rt\7!\2\2sr\3\2\2\2st\3\2\2\2tx\3\2\2\2uw\5\26\f\2")
        buf.write("vu\3\2\2\2wz\3\2\2\2xv\3\2\2\2xy\3\2\2\2y|\3\2\2\2zx\3")
        buf.write("\2\2\2{}\7\t\2\2|{\3\2\2\2|}\3\2\2\2}\u0080\3\2\2\2~\u0081")
        buf.write("\5\32\16\2\177\u0081\7\n\2\2\u0080~\3\2\2\2\u0080\177")
        buf.write("\3\2\2\2\u0081\u0082\3\2\2\2\u0082\u0083\7\37\2\2\u0083")
        buf.write("\u0087\7\13\2\2\u0084\u0086\5\24\13\2\u0085\u0084\3\2")
        buf.write("\2\2\u0086\u0089\3\2\2\2\u0087\u0085\3\2\2\2\u0087\u0088")
        buf.write("\3\2\2\2\u0088\u008a\3\2\2\2\u0089\u0087\3\2\2\2\u008a")
        buf.write("\u008c\7\f\2\2\u008b\u008d\7\4\2\2\u008c\u008b\3\2\2\2")
        buf.write("\u008c\u008d\3\2\2\2\u008d\21\3\2\2\2\u008e\u0090\7!\2")
        buf.write("\2\u008f\u008e\3\2\2\2\u008f\u0090\3\2\2\2\u0090\u0094")
        buf.write("\3\2\2\2\u0091\u0093\5\26\f\2\u0092\u0091\3\2\2\2\u0093")
        buf.write("\u0096\3\2\2\2\u0094\u0092\3\2\2\2\u0094\u0095\3\2\2\2")
        buf.write("\u0095\u0098\3\2\2\2\u0096\u0094\3\2\2\2\u0097\u0099\7")
        buf.write("\r\2\2\u0098\u0097\3\2\2\2\u0098\u0099\3\2\2\2\u0099\u009a")
        buf.write("\3\2\2\2\u009a\u009b\5\32\16\2\u009b\u009d\7\37\2\2\u009c")
        buf.write("\u009e\7\4\2\2\u009d\u009c\3\2\2\2\u009d\u009e\3\2\2\2")
        buf.write("\u009e\23\3\2\2\2\u009f\u00a0\5\32\16\2\u00a0\u00a2\7")
        buf.write("\37\2\2\u00a1\u00a3\7\16\2\2\u00a2\u00a1\3\2\2\2\u00a2")
        buf.write("\u00a3\3\2\2\2\u00a3\25\3\2\2\2\u00a4\u00a5\7\36\2\2\u00a5")
        buf.write("\u00a9\7\13\2\2\u00a6\u00a8\5\30\r\2\u00a7\u00a6\3\2\2")
        buf.write("\2\u00a8\u00ab\3\2\2\2\u00a9\u00a7\3\2\2\2\u00a9\u00aa")
        buf.write("\3\2\2\2\u00aa\u00ac\3\2\2\2\u00ab\u00a9\3\2\2\2\u00ac")
        buf.write("\u00ad\7\f\2\2\u00ad\27\3\2\2\2\u00ae\u00b1\7\37\2\2\u00af")
        buf.write("\u00b0\7\17\2\2\u00b0\u00b2\7\37\2\2\u00b1\u00af\3\2\2")
        buf.write("\2\u00b1\u00b2\3\2\2\2\u00b2\31\3\2\2\2\u00b3\u00b8\5")
        buf.write("\36\20\2\u00b4\u00b8\5\34\17\2\u00b5\u00b8\5 \21\2\u00b6")
        buf.write("\u00b8\5\"\22\2\u00b7\u00b3\3\2\2\2\u00b7\u00b4\3\2\2")
        buf.write("\2\u00b7\u00b5\3\2\2\2\u00b7\u00b6\3\2\2\2\u00b8\33\3")
        buf.write("\2\2\2\u00b9\u00ba\7\37\2\2\u00ba\35\3\2\2\2\u00bb\u00c1")
        buf.write("\7\20\2\2\u00bc\u00c1\7\21\2\2\u00bd\u00c1\7\22\2\2\u00be")
        buf.write("\u00c1\7\23\2\2\u00bf\u00c1\7\24\2\2\u00c0\u00bb\3\2\2")
        buf.write("\2\u00c0\u00bc\3\2\2\2\u00c0\u00bd\3\2\2\2\u00c0\u00be")
        buf.write("\3\2\2\2\u00c0\u00bf\3\2\2\2\u00c1\37\3\2\2\2\u00c2\u00c3")
        buf.write("\7\25\2\2\u00c3\u00c4\7\26\2\2\u00c4\u00c5\5\32\16\2\u00c5")
        buf.write("\u00c6\7\27\2\2\u00c6!\3\2\2\2\u00c7\u00c8\7\30\2\2\u00c8")
        buf.write("\u00c9\7\26\2\2\u00c9\u00ca\5\32\16\2\u00ca\u00cb\7\27")
        buf.write("\2\2\u00cb#\3\2\2\2\u00cc\u00ce\7!\2\2\u00cd\u00cc\3\2")
        buf.write("\2\2\u00cd\u00ce\3\2\2\2\u00ce\u00d2\3\2\2\2\u00cf\u00d1")
        buf.write("\5\26\f\2\u00d0\u00cf\3\2\2\2\u00d1\u00d4\3\2\2\2\u00d2")
        buf.write("\u00d0\3\2\2\2\u00d2\u00d3\3\2\2\2\u00d3\u00d5\3\2\2\2")
        buf.write("\u00d4\u00d2\3\2\2\2\u00d5\u00d6\7\31\2\2\u00d6\u00d7")
        buf.write("\7\37\2\2\u00d7\u00db\7\7\2\2\u00d8\u00da\5&\24\2\u00d9")
        buf.write("\u00d8\3\2\2\2\u00da\u00dd\3\2\2\2\u00db\u00d9\3\2\2\2")
        buf.write("\u00db\u00dc\3\2\2\2\u00dc\u00de\3\2\2\2\u00dd\u00db\3")
        buf.write("\2\2\2\u00de\u00e0\7\b\2\2\u00df\u00e1\7\4\2\2\u00e0\u00df")
        buf.write("\3\2\2\2\u00e0\u00e1\3\2\2\2\u00e1%\3\2\2\2\u00e2\u00e4")
        buf.write("\7!\2\2\u00e3\u00e2\3\2\2\2\u00e3\u00e4\3\2\2\2\u00e4")
        buf.write("\u00e8\3\2\2\2\u00e5\u00e7\5\26\f\2\u00e6\u00e5\3\2\2")
        buf.write("\2\u00e7\u00ea\3\2\2\2\u00e8\u00e6\3\2\2\2\u00e8\u00e9")
        buf.write("\3\2\2\2\u00e9\u00eb\3\2\2\2\u00ea\u00e8\3\2\2\2\u00eb")
        buf.write("\u00ec\5\32\16\2\u00ec\u00ee\7\37\2\2\u00ed\u00ef\7\4")
        buf.write("\2\2\u00ee\u00ed\3\2\2\2\u00ee\u00ef\3\2\2\2\u00ef\'\3")
        buf.write("\2\2\2\u00f0\u00f2\7!\2\2\u00f1\u00f0\3\2\2\2\u00f1\u00f2")
        buf.write("\3\2\2\2\u00f2\u00f6\3\2\2\2\u00f3\u00f5\5\26\f\2\u00f4")
        buf.write("\u00f3\3\2\2\2\u00f5\u00f8\3\2\2\2\u00f6\u00f4\3\2\2\2")
        buf.write("\u00f6\u00f7\3\2\2\2\u00f7\u00f9\3\2\2\2\u00f8\u00f6\3")
        buf.write("\2\2\2\u00f9\u00fa\5*\26\2\u00fa\u00fb\7\37\2\2\u00fb")
        buf.write("\u00ff\7\7\2\2\u00fc\u00fe\5,\27\2\u00fd\u00fc\3\2\2\2")
        buf.write("\u00fe\u0101\3\2\2\2\u00ff\u00fd\3\2\2\2\u00ff\u0100\3")
        buf.write("\2\2\2\u0100\u0102\3\2\2\2\u0101\u00ff\3\2\2\2\u0102\u0104")
        buf.write("\7\b\2\2\u0103\u0105\7\4\2\2\u0104\u0103\3\2\2\2\u0104")
        buf.write("\u0105\3\2\2\2\u0105)\3\2\2\2\u0106\u0109\7\32\2\2\u0107")
        buf.write("\u0109\7\33\2\2\u0108\u0106\3\2\2\2\u0108\u0107\3\2\2")
        buf.write("\2\u0109+\3\2\2\2\u010a\u010c\7!\2\2\u010b\u010a\3\2\2")
        buf.write("\2\u010b\u010c\3\2\2\2\u010c\u0110\3\2\2\2\u010d\u010f")
        buf.write("\5\26\f\2\u010e\u010d\3\2\2\2\u010f\u0112\3\2\2\2\u0110")
        buf.write("\u010e\3\2\2\2\u0110\u0111\3\2\2\2\u0111\u0113\3\2\2\2")
        buf.write("\u0112\u0110\3\2\2\2\u0113\u0116\7\37\2\2\u0114\u0115")
        buf.write("\7\17\2\2\u0115\u0117\5.\30\2\u0116\u0114\3\2\2\2\u0116")
        buf.write("\u0117\3\2\2\2\u0117\u0119\3\2\2\2\u0118\u011a\7\16\2")
        buf.write("\2\u0119\u0118\3\2\2\2\u0119\u011a\3\2\2\2\u011a-\3\2")
        buf.write("\2\2\u011b\u011e\7\34\2\2\u011c\u011e\7\35\2\2\u011d\u011b")
        buf.write("\3\2\2\2\u011d\u011c\3\2\2\2\u011e/\3\2\2\2.\64;BEJQV")
        buf.write("Y^glpsx|\u0080\u0087\u008c\u008f\u0094\u0098\u009d\u00a2")
        buf.write("\u00a9\u00b1\u00b7\u00c0\u00cd\u00d2\u00db\u00e0\u00e3")
        buf.write("\u00e8\u00ee\u00f1\u00f6\u00ff\u0104\u0108\u010b\u0110")
        buf.write("\u0116\u0119\u011d")
        return buf.getvalue()


class TParser ( Parser ):

    grammarFileName = "T.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'import'", "';'", "'module'", "'interface'", 
                     "'{'", "'}'", "'event'", "'void'", "'('", "')'", "'readonly'", 
                     "','", "'='", "'bool'", "'int'", "'real'", "'string'", 
                     "'var'", "'list'", "'<'", "'>'", "'model'", "'struct'", 
                     "'enum'", "'flag'" ]

    symbolicNames = [ "<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>", "<INVALID>", "INTCONSTANT", "HEXCONSTANT", 
                      "TAGIDENTIFIER", "IDENTIFIER", "VERSION", "DOCCOMMENT", 
                      "WHITESPACE", "COMMENT", "MULTICOMM" ]

    RULE_documentSymbol = 0
    RULE_headerSymbol = 1
    RULE_importSymbol = 2
    RULE_moduleSymbol = 3
    RULE_definitionSymbol = 4
    RULE_interfaceSymbol = 5
    RULE_interfaceMemberSymbol = 6
    RULE_operationSymbol = 7
    RULE_propertySymbol = 8
    RULE_operationParameterSymbol = 9
    RULE_tagSymbol = 10
    RULE_tagAttributeSymbol = 11
    RULE_typeSymbol = 12
    RULE_complexTypeSymbol = 13
    RULE_primitiveTypeSymbol = 14
    RULE_listTypeSymbol = 15
    RULE_modelTypeSymbol = 16
    RULE_structSymbol = 17
    RULE_structFieldSymbol = 18
    RULE_enumSymbol = 19
    RULE_enumTypeSymbol = 20
    RULE_enumMemberSymbol = 21
    RULE_intSymbol = 22

    ruleNames =  [ "documentSymbol", "headerSymbol", "importSymbol", "moduleSymbol", 
                   "definitionSymbol", "interfaceSymbol", "interfaceMemberSymbol", 
                   "operationSymbol", "propertySymbol", "operationParameterSymbol", 
                   "tagSymbol", "tagAttributeSymbol", "typeSymbol", "complexTypeSymbol", 
                   "primitiveTypeSymbol", "listTypeSymbol", "modelTypeSymbol", 
                   "structSymbol", "structFieldSymbol", "enumSymbol", "enumTypeSymbol", 
                   "enumMemberSymbol", "intSymbol" ]

    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
    T__11=12
    T__12=13
    T__13=14
    T__14=15
    T__15=16
    T__16=17
    T__17=18
    T__18=19
    T__19=20
    T__20=21
    T__21=22
    T__22=23
    T__23=24
    T__24=25
    INTCONSTANT=26
    HEXCONSTANT=27
    TAGIDENTIFIER=28
    IDENTIFIER=29
    VERSION=30
    DOCCOMMENT=31
    WHITESPACE=32
    COMMENT=33
    MULTICOMM=34

    def __init__(self, input:TokenStream):
        super().__init__(input)
        self.checkVersion("4.6")
        self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
        self._predicates = None



    class DocumentSymbolContext(ParserRuleContext):

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

        def headerSymbol(self):
            return self.getTypedRuleContext(TParser.HeaderSymbolContext,0)


        def definitionSymbol(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TParser.DefinitionSymbolContext)
            else:
                return self.getTypedRuleContext(TParser.DefinitionSymbolContext,i)


        def getRuleIndex(self):
            return TParser.RULE_documentSymbol

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

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

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




    def documentSymbol(self):

        localctx = TParser.DocumentSymbolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_documentSymbol)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 46
            self.headerSymbol()
            self.state = 50
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TParser.T__3) | (1 << TParser.T__22) | (1 << TParser.T__23) | (1 << TParser.T__24) | (1 << TParser.TAGIDENTIFIER) | (1 << TParser.DOCCOMMENT))) != 0):
                self.state = 47
                self.definitionSymbol()
                self.state = 52
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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

    class HeaderSymbolContext(ParserRuleContext):

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

        def moduleSymbol(self):
            return self.getTypedRuleContext(TParser.ModuleSymbolContext,0)


        def importSymbol(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TParser.ImportSymbolContext)
            else:
                return self.getTypedRuleContext(TParser.ImportSymbolContext,i)


        def getRuleIndex(self):
            return TParser.RULE_headerSymbol

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

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

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




    def headerSymbol(self):

        localctx = TParser.HeaderSymbolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_headerSymbol)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 53
            self.moduleSymbol()
            self.state = 57
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==TParser.T__0:
                self.state = 54
                self.importSymbol()
                self.state = 59
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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

    class ImportSymbolContext(ParserRuleContext):

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

        def IDENTIFIER(self):
            return self.getToken(TParser.IDENTIFIER, 0)

        def VERSION(self):
            return self.getToken(TParser.VERSION, 0)

        def getRuleIndex(self):
            return TParser.RULE_importSymbol

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

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

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




    def importSymbol(self):

        localctx = TParser.ImportSymbolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_importSymbol)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 60
            self.match(TParser.T__0)
            self.state = 61
            localctx.name = self.match(TParser.IDENTIFIER)
            self.state = 62
            localctx.version = self.match(TParser.VERSION)
            self.state = 64
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==TParser.T__1:
                self.state = 63
                self.match(TParser.T__1)


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

    class ModuleSymbolContext(ParserRuleContext):

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

        def IDENTIFIER(self):
            return self.getToken(TParser.IDENTIFIER, 0)

        def VERSION(self):
            return self.getToken(TParser.VERSION, 0)

        def tagSymbol(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TParser.TagSymbolContext)
            else:
                return self.getTypedRuleContext(TParser.TagSymbolContext,i)


        def DOCCOMMENT(self):
            return self.getToken(TParser.DOCCOMMENT, 0)

        def getRuleIndex(self):
            return TParser.RULE_moduleSymbol

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

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

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




    def moduleSymbol(self):

        localctx = TParser.ModuleSymbolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_moduleSymbol)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 67
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==TParser.DOCCOMMENT:
                self.state = 66
                localctx.comment = self.match(TParser.DOCCOMMENT)


            self.state = 72
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==TParser.TAGIDENTIFIER:
                self.state = 69
                self.tagSymbol()
                self.state = 74
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 75
            self.match(TParser.T__2)
            self.state = 76
            localctx.name = self.match(TParser.IDENTIFIER)
            self.state = 77
            localctx.version = self.match(TParser.VERSION)
            self.state = 79
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==TParser.T__1:
                self.state = 78
                self.match(TParser.T__1)


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

    class DefinitionSymbolContext(ParserRuleContext):

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

        def interfaceSymbol(self):
            return self.getTypedRuleContext(TParser.InterfaceSymbolContext,0)


        def structSymbol(self):
            return self.getTypedRuleContext(TParser.StructSymbolContext,0)


        def enumSymbol(self):
            return self.getTypedRuleContext(TParser.EnumSymbolContext,0)


        def getRuleIndex(self):
            return TParser.RULE_definitionSymbol

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

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

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




    def definitionSymbol(self):

        localctx = TParser.DefinitionSymbolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_definitionSymbol)
        try:
            self.state = 84
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 81
                self.interfaceSymbol()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 82
                self.structSymbol()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 83
                self.enumSymbol()
                pass


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

    class InterfaceSymbolContext(ParserRuleContext):

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

        def IDENTIFIER(self):
            return self.getToken(TParser.IDENTIFIER, 0)

        def tagSymbol(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TParser.TagSymbolContext)
            else:
                return self.getTypedRuleContext(TParser.TagSymbolContext,i)


        def interfaceMemberSymbol(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TParser.InterfaceMemberSymbolContext)
            else:
                return self.getTypedRuleContext(TParser.InterfaceMemberSymbolContext,i)


        def DOCCOMMENT(self):
            return self.getToken(TParser.DOCCOMMENT, 0)

        def getRuleIndex(self):
            return TParser.RULE_interfaceSymbol

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

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

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




    def interfaceSymbol(self):

        localctx = TParser.InterfaceSymbolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_interfaceSymbol)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 87
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==TParser.DOCCOMMENT:
                self.state = 86
                localctx.comment = self.match(TParser.DOCCOMMENT)


            self.state = 92
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==TParser.TAGIDENTIFIER:
                self.state = 89
                self.tagSymbol()
                self.state = 94
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 95
            self.match(TParser.T__3)
            self.state = 96
            localctx.name = self.match(TParser.IDENTIFIER)
            self.state = 97
            self.match(TParser.T__4)
            self.state = 101
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TParser.T__6) | (1 << TParser.T__7) | (1 << TParser.T__10) | (1 << TParser.T__13) | (1 << TParser.T__14) | (1 << TParser.T__15) | (1 << TParser.T__16) | (1 << TParser.T__17) | (1 << TParser.T__18) | (1 << TParser.T__21) | (1 << TParser.TAGIDENTIFIER) | (1 << TParser.IDENTIFIER) | (1 << TParser.DOCCOMMENT))) != 0):
                self.state = 98
                self.interfaceMemberSymbol()
                self.state = 103
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 104
            self.match(TParser.T__5)
            self.state = 106
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==TParser.T__1:
                self.state = 105
                self.match(TParser.T__1)


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

    class InterfaceMemberSymbolContext(ParserRuleContext):

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

        def operationSymbol(self):
            return self.getTypedRuleContext(TParser.OperationSymbolContext,0)


        def propertySymbol(self):
            return self.getTypedRuleContext(TParser.PropertySymbolContext,0)


        def getRuleIndex(self):
            return TParser.RULE_interfaceMemberSymbol

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

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

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




    def interfaceMemberSymbol(self):

        localctx = TParser.InterfaceMemberSymbolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_interfaceMemberSymbol)
        try:
            self.state = 110
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,11,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 108
                self.operationSymbol()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 109
                self.propertySymbol()
                pass


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

    class OperationSymbolContext(ParserRuleContext):

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

        def IDENTIFIER(self):
            return self.getToken(TParser.IDENTIFIER, 0)

        def typeSymbol(self):
            return self.getTypedRuleContext(TParser.TypeSymbolContext,0)


        def tagSymbol(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TParser.TagSymbolContext)
            else:
                return self.getTypedRuleContext(TParser.TagSymbolContext,i)


        def operationParameterSymbol(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TParser.OperationParameterSymbolContext)
            else:
                return self.getTypedRuleContext(TParser.OperationParameterSymbolContext,i)


        def DOCCOMMENT(self):
            return self.getToken(TParser.DOCCOMMENT, 0)

        def getRuleIndex(self):
            return TParser.RULE_operationSymbol

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

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

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




    def operationSymbol(self):

        localctx = TParser.OperationSymbolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_operationSymbol)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 113
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==TParser.DOCCOMMENT:
                self.state = 112
                localctx.comment = self.match(TParser.DOCCOMMENT)


            self.state = 118
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==TParser.TAGIDENTIFIER:
                self.state = 115
                self.tagSymbol()
                self.state = 120
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 122
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==TParser.T__6:
                self.state = 121
                localctx.isEvent = self.match(TParser.T__6)


            self.state = 126
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [TParser.T__13, TParser.T__14, TParser.T__15, TParser.T__16, TParser.T__17, TParser.T__18, TParser.T__21, TParser.IDENTIFIER]:
                self.state = 124
                self.typeSymbol()
                pass
            elif token in [TParser.T__7]:
                self.state = 125
                self.match(TParser.T__7)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 128
            localctx.name = self.match(TParser.IDENTIFIER)
            self.state = 129
            self.match(TParser.T__8)
            self.state = 133
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TParser.T__13) | (1 << TParser.T__14) | (1 << TParser.T__15) | (1 << TParser.T__16) | (1 << TParser.T__17) | (1 << TParser.T__18) | (1 << TParser.T__21) | (1 << TParser.IDENTIFIER))) != 0):
                self.state = 130
                self.operationParameterSymbol()
                self.state = 135
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 136
            self.match(TParser.T__9)
            self.state = 138
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==TParser.T__1:
                self.state = 137
                self.match(TParser.T__1)


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

    class PropertySymbolContext(ParserRuleContext):

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

        def typeSymbol(self):
            return self.getTypedRuleContext(TParser.TypeSymbolContext,0)


        def IDENTIFIER(self):
            return self.getToken(TParser.IDENTIFIER, 0)

        def tagSymbol(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TParser.TagSymbolContext)
            else:
                return self.getTypedRuleContext(TParser.TagSymbolContext,i)


        def DOCCOMMENT(self):
            return self.getToken(TParser.DOCCOMMENT, 0)

        def getRuleIndex(self):
            return TParser.RULE_propertySymbol

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

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

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




    def propertySymbol(self):

        localctx = TParser.PropertySymbolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_propertySymbol)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 141
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==TParser.DOCCOMMENT:
                self.state = 140
                localctx.comment = self.match(TParser.DOCCOMMENT)


            self.state = 146
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==TParser.TAGIDENTIFIER:
                self.state = 143
                self.tagSymbol()
                self.state = 148
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 150
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==TParser.T__10:
                self.state = 149
                localctx.isReadOnly = self.match(TParser.T__10)


            self.state = 152
            self.typeSymbol()
            self.state = 153
            localctx.name = self.match(TParser.IDENTIFIER)
            self.state = 155
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==TParser.T__1:
                self.state = 154
                self.match(TParser.T__1)


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

    class OperationParameterSymbolContext(ParserRuleContext):

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

        def typeSymbol(self):
            return self.getTypedRuleContext(TParser.TypeSymbolContext,0)


        def IDENTIFIER(self):
            return self.getToken(TParser.IDENTIFIER, 0)

        def getRuleIndex(self):
            return TParser.RULE_operationParameterSymbol

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

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

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




    def operationParameterSymbol(self):

        localctx = TParser.OperationParameterSymbolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_operationParameterSymbol)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 157
            self.typeSymbol()
            self.state = 158
            localctx.name = self.match(TParser.IDENTIFIER)
            self.state = 160
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==TParser.T__11:
                self.state = 159
                self.match(TParser.T__11)


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

    class TagSymbolContext(ParserRuleContext):

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

        def TAGIDENTIFIER(self):
            return self.getToken(TParser.TAGIDENTIFIER, 0)

        def tagAttributeSymbol(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TParser.TagAttributeSymbolContext)
            else:
                return self.getTypedRuleContext(TParser.TagAttributeSymbolContext,i)


        def getRuleIndex(self):
            return TParser.RULE_tagSymbol

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

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

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




    def tagSymbol(self):

        localctx = TParser.TagSymbolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_tagSymbol)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 162
            localctx.name = self.match(TParser.TAGIDENTIFIER)
            self.state = 163
            self.match(TParser.T__8)
            self.state = 167
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==TParser.IDENTIFIER:
                self.state = 164
                self.tagAttributeSymbol()
                self.state = 169
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 170
            self.match(TParser.T__9)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class TagAttributeSymbolContext(ParserRuleContext):

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

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

        def getRuleIndex(self):
            return TParser.RULE_tagAttributeSymbol

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

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

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




    def tagAttributeSymbol(self):

        localctx = TParser.TagAttributeSymbolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_tagAttributeSymbol)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 172
            localctx.name = self.match(TParser.IDENTIFIER)
            self.state = 175
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==TParser.T__12:
                self.state = 173
                self.match(TParser.T__12)
                self.state = 174
                localctx.value = self.match(TParser.IDENTIFIER)


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

    class TypeSymbolContext(ParserRuleContext):

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

        def primitiveTypeSymbol(self):
            return self.getTypedRuleContext(TParser.PrimitiveTypeSymbolContext,0)


        def complexTypeSymbol(self):
            return self.getTypedRuleContext(TParser.ComplexTypeSymbolContext,0)


        def listTypeSymbol(self):
            return self.getTypedRuleContext(TParser.ListTypeSymbolContext,0)


        def modelTypeSymbol(self):
            return self.getTypedRuleContext(TParser.ModelTypeSymbolContext,0)


        def getRuleIndex(self):
            return TParser.RULE_typeSymbol

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

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

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




    def typeSymbol(self):

        localctx = TParser.TypeSymbolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_typeSymbol)
        try:
            self.state = 181
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [TParser.T__13, TParser.T__14, TParser.T__15, TParser.T__16, TParser.T__17]:
                self.enterOuterAlt(localctx, 1)
                self.state = 177
                self.primitiveTypeSymbol()
                pass
            elif token in [TParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 178
                self.complexTypeSymbol()
                pass
            elif token in [TParser.T__18]:
                self.enterOuterAlt(localctx, 3)
                self.state = 179
                self.listTypeSymbol()
                pass
            elif token in [TParser.T__21]:
                self.enterOuterAlt(localctx, 4)
                self.state = 180
                self.modelTypeSymbol()
                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

    class ComplexTypeSymbolContext(ParserRuleContext):

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

        def IDENTIFIER(self):
            return self.getToken(TParser.IDENTIFIER, 0)

        def getRuleIndex(self):
            return TParser.RULE_complexTypeSymbol

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

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

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




    def complexTypeSymbol(self):

        localctx = TParser.ComplexTypeSymbolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_complexTypeSymbol)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 183
            localctx.name = self.match(TParser.IDENTIFIER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class PrimitiveTypeSymbolContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return TParser.RULE_primitiveTypeSymbol

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

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

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




    def primitiveTypeSymbol(self):

        localctx = TParser.PrimitiveTypeSymbolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_primitiveTypeSymbol)
        try:
            self.state = 190
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [TParser.T__13]:
                self.enterOuterAlt(localctx, 1)
                self.state = 185
                localctx.name = self.match(TParser.T__13)
                pass
            elif token in [TParser.T__14]:
                self.enterOuterAlt(localctx, 2)
                self.state = 186
                localctx.name = self.match(TParser.T__14)
                pass
            elif token in [TParser.T__15]:
                self.enterOuterAlt(localctx, 3)
                self.state = 187
                localctx.name = self.match(TParser.T__15)
                pass
            elif token in [TParser.T__16]:
                self.enterOuterAlt(localctx, 4)
                self.state = 188
                localctx.name = self.match(TParser.T__16)
                pass
            elif token in [TParser.T__17]:
                self.enterOuterAlt(localctx, 5)
                self.state = 189
                localctx.name = self.match(TParser.T__17)
                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

    class ListTypeSymbolContext(ParserRuleContext):

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

        def typeSymbol(self):
            return self.getTypedRuleContext(TParser.TypeSymbolContext,0)


        def getRuleIndex(self):
            return TParser.RULE_listTypeSymbol

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

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

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




    def listTypeSymbol(self):

        localctx = TParser.ListTypeSymbolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_listTypeSymbol)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 192
            self.match(TParser.T__18)
            self.state = 193
            self.match(TParser.T__19)
            self.state = 194
            localctx.valueType = self.typeSymbol()
            self.state = 195
            self.match(TParser.T__20)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class ModelTypeSymbolContext(ParserRuleContext):

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

        def typeSymbol(self):
            return self.getTypedRuleContext(TParser.TypeSymbolContext,0)


        def getRuleIndex(self):
            return TParser.RULE_modelTypeSymbol

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

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

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




    def modelTypeSymbol(self):

        localctx = TParser.ModelTypeSymbolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_modelTypeSymbol)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 197
            self.match(TParser.T__21)
            self.state = 198
            self.match(TParser.T__19)
            self.state = 199
            localctx.valueType = self.typeSymbol()
            self.state = 200
            self.match(TParser.T__20)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx

    class StructSymbolContext(ParserRuleContext):

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

        def IDENTIFIER(self):
            return self.getToken(TParser.IDENTIFIER, 0)

        def tagSymbol(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TParser.TagSymbolContext)
            else:
                return self.getTypedRuleContext(TParser.TagSymbolContext,i)


        def structFieldSymbol(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TParser.StructFieldSymbolContext)
            else:
                return self.getTypedRuleContext(TParser.StructFieldSymbolContext,i)


        def DOCCOMMENT(self):
            return self.getToken(TParser.DOCCOMMENT, 0)

        def getRuleIndex(self):
            return TParser.RULE_structSymbol

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

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

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




    def structSymbol(self):

        localctx = TParser.StructSymbolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_structSymbol)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 203
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==TParser.DOCCOMMENT:
                self.state = 202
                localctx.comment = self.match(TParser.DOCCOMMENT)


            self.state = 208
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==TParser.TAGIDENTIFIER:
                self.state = 205
                self.tagSymbol()
                self.state = 210
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 211
            self.match(TParser.T__22)
            self.state = 212
            localctx.name = self.match(TParser.IDENTIFIER)
            self.state = 213
            self.match(TParser.T__4)
            self.state = 217
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TParser.T__13) | (1 << TParser.T__14) | (1 << TParser.T__15) | (1 << TParser.T__16) | (1 << TParser.T__17) | (1 << TParser.T__18) | (1 << TParser.T__21) | (1 << TParser.TAGIDENTIFIER) | (1 << TParser.IDENTIFIER) | (1 << TParser.DOCCOMMENT))) != 0):
                self.state = 214
                self.structFieldSymbol()
                self.state = 219
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 220
            self.match(TParser.T__5)
            self.state = 222
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==TParser.T__1:
                self.state = 221
                self.match(TParser.T__1)


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

    class StructFieldSymbolContext(ParserRuleContext):

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

        def typeSymbol(self):
            return self.getTypedRuleContext(TParser.TypeSymbolContext,0)


        def IDENTIFIER(self):
            return self.getToken(TParser.IDENTIFIER, 0)

        def tagSymbol(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TParser.TagSymbolContext)
            else:
                return self.getTypedRuleContext(TParser.TagSymbolContext,i)


        def DOCCOMMENT(self):
            return self.getToken(TParser.DOCCOMMENT, 0)

        def getRuleIndex(self):
            return TParser.RULE_structFieldSymbol

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

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

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




    def structFieldSymbol(self):

        localctx = TParser.StructFieldSymbolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_structFieldSymbol)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 225
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==TParser.DOCCOMMENT:
                self.state = 224
                localctx.comment = self.match(TParser.DOCCOMMENT)


            self.state = 230
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==TParser.TAGIDENTIFIER:
                self.state = 227
                self.tagSymbol()
                self.state = 232
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 233
            self.typeSymbol()
            self.state = 234
            localctx.name = self.match(TParser.IDENTIFIER)
            self.state = 236
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==TParser.T__1:
                self.state = 235
                self.match(TParser.T__1)


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

    class EnumSymbolContext(ParserRuleContext):

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

        def enumTypeSymbol(self):
            return self.getTypedRuleContext(TParser.EnumTypeSymbolContext,0)


        def IDENTIFIER(self):
            return self.getToken(TParser.IDENTIFIER, 0)

        def tagSymbol(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TParser.TagSymbolContext)
            else:
                return self.getTypedRuleContext(TParser.TagSymbolContext,i)


        def enumMemberSymbol(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TParser.EnumMemberSymbolContext)
            else:
                return self.getTypedRuleContext(TParser.EnumMemberSymbolContext,i)


        def DOCCOMMENT(self):
            return self.getToken(TParser.DOCCOMMENT, 0)

        def getRuleIndex(self):
            return TParser.RULE_enumSymbol

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

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

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




    def enumSymbol(self):

        localctx = TParser.EnumSymbolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_enumSymbol)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 239
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==TParser.DOCCOMMENT:
                self.state = 238
                localctx.comment = self.match(TParser.DOCCOMMENT)


            self.state = 244
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==TParser.TAGIDENTIFIER:
                self.state = 241
                self.tagSymbol()
                self.state = 246
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 247
            self.enumTypeSymbol()
            self.state = 248
            localctx.name = self.match(TParser.IDENTIFIER)
            self.state = 249
            self.match(TParser.T__4)
            self.state = 253
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TParser.TAGIDENTIFIER) | (1 << TParser.IDENTIFIER) | (1 << TParser.DOCCOMMENT))) != 0):
                self.state = 250
                self.enumMemberSymbol()
                self.state = 255
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 256
            self.match(TParser.T__5)
            self.state = 258
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==TParser.T__1:
                self.state = 257
                self.match(TParser.T__1)


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

    class EnumTypeSymbolContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return TParser.RULE_enumTypeSymbol

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

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

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




    def enumTypeSymbol(self):

        localctx = TParser.EnumTypeSymbolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_enumTypeSymbol)
        try:
            self.state = 262
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [TParser.T__23]:
                self.enterOuterAlt(localctx, 1)
                self.state = 260
                localctx.isEnum = self.match(TParser.T__23)
                pass
            elif token in [TParser.T__24]:
                self.enterOuterAlt(localctx, 2)
                self.state = 261
                localctx.isFlag = self.match(TParser.T__24)
                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

    class EnumMemberSymbolContext(ParserRuleContext):

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

        def IDENTIFIER(self):
            return self.getToken(TParser.IDENTIFIER, 0)

        def tagSymbol(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TParser.TagSymbolContext)
            else:
                return self.getTypedRuleContext(TParser.TagSymbolContext,i)


        def intSymbol(self):
            return self.getTypedRuleContext(TParser.IntSymbolContext,0)


        def DOCCOMMENT(self):
            return self.getToken(TParser.DOCCOMMENT, 0)

        def getRuleIndex(self):
            return TParser.RULE_enumMemberSymbol

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

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

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




    def enumMemberSymbol(self):

        localctx = TParser.EnumMemberSymbolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_enumMemberSymbol)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 265
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==TParser.DOCCOMMENT:
                self.state = 264
                localctx.comment = self.match(TParser.DOCCOMMENT)


            self.state = 270
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==TParser.TAGIDENTIFIER:
                self.state = 267
                self.tagSymbol()
                self.state = 272
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 273
            localctx.name = self.match(TParser.IDENTIFIER)
            self.state = 276
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==TParser.T__12:
                self.state = 274
                self.match(TParser.T__12)
                self.state = 275
                self.intSymbol()


            self.state = 279
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==TParser.T__11:
                self.state = 278
                self.match(TParser.T__11)


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

    class IntSymbolContext(ParserRuleContext):

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

        def INTCONSTANT(self):
            return self.getToken(TParser.INTCONSTANT, 0)

        def HEXCONSTANT(self):
            return self.getToken(TParser.HEXCONSTANT, 0)

        def getRuleIndex(self):
            return TParser.RULE_intSymbol

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

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

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




    def intSymbol(self):

        localctx = TParser.IntSymbolContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_intSymbol)
        try:
            self.state = 283
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [TParser.INTCONSTANT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 281
                localctx.value = self.match(TParser.INTCONSTANT)
                pass
            elif token in [TParser.HEXCONSTANT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 282
                localctx.value = self.match(TParser.HEXCONSTANT)
                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