// [The "BSD 3-clause license"] // Copyright (c) 2005-2007 Terence Parr // Copyright (c) 2012-2015 Terence Parr // Copyright (c) 2012-2015 Sam Harwell // Copyright (c) 2014-2015 Gerald Rosenberg // Copyright (c) 2023 Google LLC // All rights reserved. // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions // are met: // 1. Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // 2. Redistributions in binary form must reproduce the above copyright // notice, this list of conditions and the following disclaimer in the // documentation and/or other materials provided with the distribution. // 3. Neither the name of the copyright holder nor the names of its // contributors may be used to endorse or promote products derived from this // software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // Generated from ANTLRv4Parser.g4 by ANTLR 4.11.2 #include "ANTLRv4Parser.h" #include "ANTLRv4ParserListener.h" using namespace antlrcpp; using namespace antlr4_grammar; using namespace antlr4; namespace { struct ANTLRv4ParserStaticData final { ANTLRv4ParserStaticData(std::vector ruleNames, std::vector literalNames, std::vector symbolicNames) : ruleNames(std::move(ruleNames)), literalNames(std::move(literalNames)), symbolicNames(std::move(symbolicNames)), vocabulary(this->literalNames, this->symbolicNames) {} ANTLRv4ParserStaticData(const ANTLRv4ParserStaticData &) = delete; ANTLRv4ParserStaticData(ANTLRv4ParserStaticData &&) = delete; ANTLRv4ParserStaticData &operator=(const ANTLRv4ParserStaticData &) = delete; ANTLRv4ParserStaticData &operator=(ANTLRv4ParserStaticData &&) = delete; std::vector decisionToDFA; antlr4::atn::PredictionContextCache sharedContextCache; const std::vector ruleNames; const std::vector literalNames; const std::vector symbolicNames; const antlr4::dfa::Vocabulary vocabulary; antlr4::atn::SerializedATNView serializedATN; std::unique_ptr atn; }; ::antlr4::internal::OnceFlag antlrv4parserParserOnceFlag; ANTLRv4ParserStaticData *antlrv4parserParserStaticData = nullptr; void antlrv4parserParserInitialize() { assert(antlrv4parserParserStaticData == nullptr); auto staticData = std::make_unique( std::vector{"grammarSpec", "grammarDecl", "grammarType", "prequelConstruct", "optionsSpec", "option", "optionValue", "delegateGrammars", "delegateGrammar", "tokensSpec", "channelsSpec", "idList", "action_", "actionScopeName", "actionBlock", "argActionBlock", "modeSpec", "rules", "ruleSpec", "parserRuleSpec", "exceptionGroup", "exceptionHandler", "finallyClause", "rulePrequel", "ruleReturns", "throwsSpec", "localsSpec", "ruleAction", "ruleModifiers", "ruleModifier", "ruleBlock", "ruleAltList", "labeledAlt", "lexerRuleSpec", "lexerRuleBlock", "lexerAltList", "lexerAlt", "lexerElements", "lexerElement", "labeledLexerElement", "lexerBlock", "lexerCommands", "lexerCommand", "lexerCommandName", "lexerCommandExpr", "altList", "alternative", "element", "labeledElement", "ebnf", "blockSuffix", "ebnfSuffix", "lexerAtom", "atom", "notSet", "blockSet", "setElement", "block", "ruleref", "characterRange", "terminal", "elementOptions", "elementOption", "identifier"}, std::vector{"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "'import'", "'fragment'", "'lexer'", "'parser'", "'grammar'", "'protected'", "'public'", "'private'", "'returns'", "'locals'", "'throws'", "'catch'", "'finally'", "'mode'"}, std::vector{"", "TOKEN_REF", "RULE_REF", "LEXER_CHAR_SET", "DOC_COMMENT", "BLOCK_COMMENT", "LINE_COMMENT", "INT", "STRING_LITERAL", "UNTERMINATED_STRING_LITERAL", "BEGIN_ARGUMENT", "BEGIN_ACTION", "OPTIONS", "TOKENS", "CHANNELS", "IMPORT", "FRAGMENT", "LEXER", "PARSER", "GRAMMAR", "PROTECTED", "PUBLIC", "PRIVATE", "RETURNS", "LOCALS", "THROWS", "CATCH", "FINALLY", "MODE", "COLON", "COLONCOLON", "COMMA", "SEMI", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "RARROW", "LT", "GT", "ASSIGN", "QUESTION", "STAR", "PLUS_ASSIGN", "PLUS", "OR", "DOLLAR", "RANGE", "DOT", "AT", "POUND", "NOT", "ID", "WS", "ERRCHAR", "END_ARGUMENT", "UNTERMINATED_ARGUMENT", "ARGUMENT_CONTENT", "END_ACTION", "UNTERMINATED_ACTION", "ACTION_CONTENT", "UNTERMINATED_CHAR_SET"}); static const int32_t serializedATNSegment[] = { 4, 1, 61, 626, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 1, 0, 1, 0, 5, 0, 131, 8, 0, 10, 0, 12, 0, 134, 9, 0, 1, 0, 1, 0, 5, 0, 138, 8, 0, 10, 0, 12, 0, 141, 9, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 154, 8, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 161, 8, 3, 1, 4, 1, 4, 1, 4, 1, 4, 5, 4, 167, 8, 4, 10, 4, 12, 4, 170, 9, 4, 1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 5, 6, 181, 8, 6, 10, 6, 12, 6, 184, 9, 6, 1, 6, 1, 6, 1, 6, 3, 6, 189, 8, 6, 1, 7, 1, 7, 1, 7, 1, 7, 5, 7, 195, 8, 7, 10, 7, 12, 7, 198, 9, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 3, 8, 207, 8, 8, 1, 9, 1, 9, 3, 9, 211, 8, 9, 1, 9, 1, 9, 1, 10, 1, 10, 3, 10, 217, 8, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 5, 11, 224, 8, 11, 10, 11, 12, 11, 227, 9, 11, 1, 11, 3, 11, 230, 8, 11, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 236, 8, 12, 1, 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 3, 13, 244, 8, 13, 1, 14, 1, 14, 5, 14, 248, 8, 14, 10, 14, 12, 14, 251, 9, 14, 1, 14, 1, 14, 1, 15, 1, 15, 5, 15, 257, 8, 15, 10, 15, 12, 15, 260, 9, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 16, 1, 16, 5, 16, 268, 8, 16, 10, 16, 12, 16, 271, 9, 16, 1, 17, 5, 17, 274, 8, 17, 10, 17, 12, 17, 277, 9, 17, 1, 18, 1, 18, 3, 18, 281, 8, 18, 1, 19, 3, 19, 284, 8, 19, 1, 19, 1, 19, 3, 19, 288, 8, 19, 1, 19, 3, 19, 291, 8, 19, 1, 19, 3, 19, 294, 8, 19, 1, 19, 3, 19, 297, 8, 19, 1, 19, 5, 19, 300, 8, 19, 10, 19, 12, 19, 303, 9, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 5, 20, 311, 8, 20, 10, 20, 12, 20, 314, 9, 20, 1, 20, 3, 20, 317, 8, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, 3, 23, 328, 8, 23, 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 5, 25, 337, 8, 25, 10, 25, 12, 25, 340, 9, 25, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 28, 4, 28, 350, 8, 28, 11, 28, 12, 28, 351, 1, 29, 1, 29, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 5, 31, 361, 8, 31, 10, 31, 12, 31, 364, 9, 31, 1, 32, 1, 32, 1, 32, 3, 32, 369, 8, 32, 1, 33, 3, 33, 372, 8, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 5, 35, 384, 8, 35, 10, 35, 12, 35, 387, 9, 35, 1, 36, 1, 36, 3, 36, 391, 8, 36, 1, 36, 3, 36, 394, 8, 36, 1, 37, 4, 37, 397, 8, 37, 11, 37, 12, 37, 398, 1, 37, 3, 37, 402, 8, 37, 1, 38, 1, 38, 3, 38, 406, 8, 38, 1, 38, 1, 38, 3, 38, 410, 8, 38, 1, 38, 1, 38, 3, 38, 414, 8, 38, 1, 38, 1, 38, 3, 38, 418, 8, 38, 3, 38, 420, 8, 38, 1, 39, 1, 39, 1, 39, 1, 39, 3, 39, 426, 8, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 5, 41, 436, 8, 41, 10, 41, 12, 41, 439, 9, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 3, 42, 447, 8, 42, 1, 43, 1, 43, 3, 43, 451, 8, 43, 1, 44, 1, 44, 3, 44, 455, 8, 44, 1, 45, 1, 45, 1, 45, 5, 45, 460, 8, 45, 10, 45, 12, 45, 463, 9, 45, 1, 46, 3, 46, 466, 8, 46, 1, 46, 4, 46, 469, 8, 46, 11, 46, 12, 46, 470, 1, 46, 3, 46, 474, 8, 46, 1, 47, 1, 47, 1, 47, 3, 47, 479, 8, 47, 1, 47, 1, 47, 1, 47, 3, 47, 484, 8, 47, 1, 47, 1, 47, 1, 47, 3, 47, 489, 8, 47, 3, 47, 491, 8, 47, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 497, 8, 48, 1, 49, 1, 49, 3, 49, 501, 8, 49, 1, 50, 1, 50, 1, 51, 1, 51, 3, 51, 507, 8, 51, 1, 51, 1, 51, 3, 51, 511, 8, 51, 1, 51, 1, 51, 3, 51, 515, 8, 51, 3, 51, 517, 8, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 525, 8, 52, 3, 52, 527, 8, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 3, 53, 534, 8, 53, 3, 53, 536, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 3, 54, 542, 8, 54, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 548, 8, 55, 10, 55, 12, 55, 551, 9, 55, 1, 55, 1, 55, 1, 56, 1, 56, 3, 56, 557, 8, 56, 1, 56, 1, 56, 3, 56, 561, 8, 56, 1, 56, 1, 56, 3, 56, 565, 8, 56, 1, 57, 1, 57, 3, 57, 569, 8, 57, 1, 57, 5, 57, 572, 8, 57, 10, 57, 12, 57, 575, 9, 57, 1, 57, 3, 57, 578, 8, 57, 1, 57, 1, 57, 1, 57, 1, 58, 1, 58, 3, 58, 585, 8, 58, 1, 58, 3, 58, 588, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 60, 1, 60, 3, 60, 596, 8, 60, 1, 60, 1, 60, 3, 60, 600, 8, 60, 3, 60, 602, 8, 60, 1, 61, 1, 61, 1, 61, 1, 61, 5, 61, 608, 8, 61, 10, 61, 12, 61, 611, 9, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 3, 62, 620, 8, 62, 3, 62, 622, 8, 62, 1, 63, 1, 63, 1, 63, 0, 0, 64, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 0, 3, 2, 0, 16, 16, 20, 22, 2, 0, 40, 40, 43, 43, 1, 0, 1, 2, 663, 0, 128, 1, 0, 0, 0, 2, 144, 1, 0, 0, 0, 4, 153, 1, 0, 0, 0, 6, 160, 1, 0, 0, 0, 8, 162, 1, 0, 0, 0, 10, 173, 1, 0, 0, 0, 12, 188, 1, 0, 0, 0, 14, 190, 1, 0, 0, 0, 16, 206, 1, 0, 0, 0, 18, 208, 1, 0, 0, 0, 20, 214, 1, 0, 0, 0, 22, 220, 1, 0, 0, 0, 24, 231, 1, 0, 0, 0, 26, 243, 1, 0, 0, 0, 28, 245, 1, 0, 0, 0, 30, 254, 1, 0, 0, 0, 32, 263, 1, 0, 0, 0, 34, 275, 1, 0, 0, 0, 36, 280, 1, 0, 0, 0, 38, 283, 1, 0, 0, 0, 40, 312, 1, 0, 0, 0, 42, 318, 1, 0, 0, 0, 44, 322, 1, 0, 0, 0, 46, 327, 1, 0, 0, 0, 48, 329, 1, 0, 0, 0, 50, 332, 1, 0, 0, 0, 52, 341, 1, 0, 0, 0, 54, 344, 1, 0, 0, 0, 56, 349, 1, 0, 0, 0, 58, 353, 1, 0, 0, 0, 60, 355, 1, 0, 0, 0, 62, 357, 1, 0, 0, 0, 64, 365, 1, 0, 0, 0, 66, 371, 1, 0, 0, 0, 68, 378, 1, 0, 0, 0, 70, 380, 1, 0, 0, 0, 72, 393, 1, 0, 0, 0, 74, 401, 1, 0, 0, 0, 76, 419, 1, 0, 0, 0, 78, 421, 1, 0, 0, 0, 80, 427, 1, 0, 0, 0, 82, 431, 1, 0, 0, 0, 84, 446, 1, 0, 0, 0, 86, 450, 1, 0, 0, 0, 88, 454, 1, 0, 0, 0, 90, 456, 1, 0, 0, 0, 92, 473, 1, 0, 0, 0, 94, 490, 1, 0, 0, 0, 96, 492, 1, 0, 0, 0, 98, 498, 1, 0, 0, 0, 100, 502, 1, 0, 0, 0, 102, 516, 1, 0, 0, 0, 104, 526, 1, 0, 0, 0, 106, 535, 1, 0, 0, 0, 108, 541, 1, 0, 0, 0, 110, 543, 1, 0, 0, 0, 112, 564, 1, 0, 0, 0, 114, 566, 1, 0, 0, 0, 116, 582, 1, 0, 0, 0, 118, 589, 1, 0, 0, 0, 120, 601, 1, 0, 0, 0, 122, 603, 1, 0, 0, 0, 124, 621, 1, 0, 0, 0, 126, 623, 1, 0, 0, 0, 128, 132, 3, 2, 1, 0, 129, 131, 3, 6, 3, 0, 130, 129, 1, 0, 0, 0, 131, 134, 1, 0, 0, 0, 132, 130, 1, 0, 0, 0, 132, 133, 1, 0, 0, 0, 133, 135, 1, 0, 0, 0, 134, 132, 1, 0, 0, 0, 135, 139, 3, 34, 17, 0, 136, 138, 3, 32, 16, 0, 137, 136, 1, 0, 0, 0, 138, 141, 1, 0, 0, 0, 139, 137, 1, 0, 0, 0, 139, 140, 1, 0, 0, 0, 140, 142, 1, 0, 0, 0, 141, 139, 1, 0, 0, 0, 142, 143, 5, 0, 0, 1, 143, 1, 1, 0, 0, 0, 144, 145, 3, 4, 2, 0, 145, 146, 3, 126, 63, 0, 146, 147, 5, 32, 0, 0, 147, 3, 1, 0, 0, 0, 148, 149, 5, 17, 0, 0, 149, 154, 5, 19, 0, 0, 150, 151, 5, 18, 0, 0, 151, 154, 5, 19, 0, 0, 152, 154, 5, 19, 0, 0, 153, 148, 1, 0, 0, 0, 153, 150, 1, 0, 0, 0, 153, 152, 1, 0, 0, 0, 154, 5, 1, 0, 0, 0, 155, 161, 3, 8, 4, 0, 156, 161, 3, 14, 7, 0, 157, 161, 3, 18, 9, 0, 158, 161, 3, 20, 10, 0, 159, 161, 3, 24, 12, 0, 160, 155, 1, 0, 0, 0, 160, 156, 1, 0, 0, 0, 160, 157, 1, 0, 0, 0, 160, 158, 1, 0, 0, 0, 160, 159, 1, 0, 0, 0, 161, 7, 1, 0, 0, 0, 162, 168, 5, 12, 0, 0, 163, 164, 3, 10, 5, 0, 164, 165, 5, 32, 0, 0, 165, 167, 1, 0, 0, 0, 166, 163, 1, 0, 0, 0, 167, 170, 1, 0, 0, 0, 168, 166, 1, 0, 0, 0, 168, 169, 1, 0, 0, 0, 169, 171, 1, 0, 0, 0, 170, 168, 1, 0, 0, 0, 171, 172, 5, 36, 0, 0, 172, 9, 1, 0, 0, 0, 173, 174, 3, 126, 63, 0, 174, 175, 5, 40, 0, 0, 175, 176, 3, 12, 6, 0, 176, 11, 1, 0, 0, 0, 177, 182, 3, 126, 63, 0, 178, 179, 5, 48, 0, 0, 179, 181, 3, 126, 63, 0, 180, 178, 1, 0, 0, 0, 181, 184, 1, 0, 0, 0, 182, 180, 1, 0, 0, 0, 182, 183, 1, 0, 0, 0, 183, 189, 1, 0, 0, 0, 184, 182, 1, 0, 0, 0, 185, 189, 5, 8, 0, 0, 186, 189, 3, 28, 14, 0, 187, 189, 5, 7, 0, 0, 188, 177, 1, 0, 0, 0, 188, 185, 1, 0, 0, 0, 188, 186, 1, 0, 0, 0, 188, 187, 1, 0, 0, 0, 189, 13, 1, 0, 0, 0, 190, 191, 5, 15, 0, 0, 191, 196, 3, 16, 8, 0, 192, 193, 5, 31, 0, 0, 193, 195, 3, 16, 8, 0, 194, 192, 1, 0, 0, 0, 195, 198, 1, 0, 0, 0, 196, 194, 1, 0, 0, 0, 196, 197, 1, 0, 0, 0, 197, 199, 1, 0, 0, 0, 198, 196, 1, 0, 0, 0, 199, 200, 5, 32, 0, 0, 200, 15, 1, 0, 0, 0, 201, 202, 3, 126, 63, 0, 202, 203, 5, 40, 0, 0, 203, 204, 3, 126, 63, 0, 204, 207, 1, 0, 0, 0, 205, 207, 3, 126, 63, 0, 206, 201, 1, 0, 0, 0, 206, 205, 1, 0, 0, 0, 207, 17, 1, 0, 0, 0, 208, 210, 5, 13, 0, 0, 209, 211, 3, 22, 11, 0, 210, 209, 1, 0, 0, 0, 210, 211, 1, 0, 0, 0, 211, 212, 1, 0, 0, 0, 212, 213, 5, 36, 0, 0, 213, 19, 1, 0, 0, 0, 214, 216, 5, 14, 0, 0, 215, 217, 3, 22, 11, 0, 216, 215, 1, 0, 0, 0, 216, 217, 1, 0, 0, 0, 217, 218, 1, 0, 0, 0, 218, 219, 5, 36, 0, 0, 219, 21, 1, 0, 0, 0, 220, 225, 3, 126, 63, 0, 221, 222, 5, 31, 0, 0, 222, 224, 3, 126, 63, 0, 223, 221, 1, 0, 0, 0, 224, 227, 1, 0, 0, 0, 225, 223, 1, 0, 0, 0, 225, 226, 1, 0, 0, 0, 226, 229, 1, 0, 0, 0, 227, 225, 1, 0, 0, 0, 228, 230, 5, 31, 0, 0, 229, 228, 1, 0, 0, 0, 229, 230, 1, 0, 0, 0, 230, 23, 1, 0, 0, 0, 231, 235, 5, 49, 0, 0, 232, 233, 3, 26, 13, 0, 233, 234, 5, 30, 0, 0, 234, 236, 1, 0, 0, 0, 235, 232, 1, 0, 0, 0, 235, 236, 1, 0, 0, 0, 236, 237, 1, 0, 0, 0, 237, 238, 3, 126, 63, 0, 238, 239, 3, 28, 14, 0, 239, 25, 1, 0, 0, 0, 240, 244, 3, 126, 63, 0, 241, 244, 5, 17, 0, 0, 242, 244, 5, 18, 0, 0, 243, 240, 1, 0, 0, 0, 243, 241, 1, 0, 0, 0, 243, 242, 1, 0, 0, 0, 244, 27, 1, 0, 0, 0, 245, 249, 5, 11, 0, 0, 246, 248, 5, 60, 0, 0, 247, 246, 1, 0, 0, 0, 248, 251, 1, 0, 0, 0, 249, 247, 1, 0, 0, 0, 249, 250, 1, 0, 0, 0, 250, 252, 1, 0, 0, 0, 251, 249, 1, 0, 0, 0, 252, 253, 5, 58, 0, 0, 253, 29, 1, 0, 0, 0, 254, 258, 5, 10, 0, 0, 255, 257, 5, 57, 0, 0, 256, 255, 1, 0, 0, 0, 257, 260, 1, 0, 0, 0, 258, 256, 1, 0, 0, 0, 258, 259, 1, 0, 0, 0, 259, 261, 1, 0, 0, 0, 260, 258, 1, 0, 0, 0, 261, 262, 5, 55, 0, 0, 262, 31, 1, 0, 0, 0, 263, 264, 5, 28, 0, 0, 264, 265, 3, 126, 63, 0, 265, 269, 5, 32, 0, 0, 266, 268, 3, 66, 33, 0, 267, 266, 1, 0, 0, 0, 268, 271, 1, 0, 0, 0, 269, 267, 1, 0, 0, 0, 269, 270, 1, 0, 0, 0, 270, 33, 1, 0, 0, 0, 271, 269, 1, 0, 0, 0, 272, 274, 3, 36, 18, 0, 273, 272, 1, 0, 0, 0, 274, 277, 1, 0, 0, 0, 275, 273, 1, 0, 0, 0, 275, 276, 1, 0, 0, 0, 276, 35, 1, 0, 0, 0, 277, 275, 1, 0, 0, 0, 278, 281, 3, 38, 19, 0, 279, 281, 3, 66, 33, 0, 280, 278, 1, 0, 0, 0, 280, 279, 1, 0, 0, 0, 281, 37, 1, 0, 0, 0, 282, 284, 3, 56, 28, 0, 283, 282, 1, 0, 0, 0, 283, 284, 1, 0, 0, 0, 284, 285, 1, 0, 0, 0, 285, 287, 5, 2, 0, 0, 286, 288, 3, 30, 15, 0, 287, 286, 1, 0, 0, 0, 287, 288, 1, 0, 0, 0, 288, 290, 1, 0, 0, 0, 289, 291, 3, 48, 24, 0, 290, 289, 1, 0, 0, 0, 290, 291, 1, 0, 0, 0, 291, 293, 1, 0, 0, 0, 292, 294, 3, 50, 25, 0, 293, 292, 1, 0, 0, 0, 293, 294, 1, 0, 0, 0, 294, 296, 1, 0, 0, 0, 295, 297, 3, 52, 26, 0, 296, 295, 1, 0, 0, 0, 296, 297, 1, 0, 0, 0, 297, 301, 1, 0, 0, 0, 298, 300, 3, 46, 23, 0, 299, 298, 1, 0, 0, 0, 300, 303, 1, 0, 0, 0, 301, 299, 1, 0, 0, 0, 301, 302, 1, 0, 0, 0, 302, 304, 1, 0, 0, 0, 303, 301, 1, 0, 0, 0, 304, 305, 5, 29, 0, 0, 305, 306, 3, 60, 30, 0, 306, 307, 5, 32, 0, 0, 307, 308, 3, 40, 20, 0, 308, 39, 1, 0, 0, 0, 309, 311, 3, 42, 21, 0, 310, 309, 1, 0, 0, 0, 311, 314, 1, 0, 0, 0, 312, 310, 1, 0, 0, 0, 312, 313, 1, 0, 0, 0, 313, 316, 1, 0, 0, 0, 314, 312, 1, 0, 0, 0, 315, 317, 3, 44, 22, 0, 316, 315, 1, 0, 0, 0, 316, 317, 1, 0, 0, 0, 317, 41, 1, 0, 0, 0, 318, 319, 5, 26, 0, 0, 319, 320, 3, 30, 15, 0, 320, 321, 3, 28, 14, 0, 321, 43, 1, 0, 0, 0, 322, 323, 5, 27, 0, 0, 323, 324, 3, 28, 14, 0, 324, 45, 1, 0, 0, 0, 325, 328, 3, 8, 4, 0, 326, 328, 3, 54, 27, 0, 327, 325, 1, 0, 0, 0, 327, 326, 1, 0, 0, 0, 328, 47, 1, 0, 0, 0, 329, 330, 5, 23, 0, 0, 330, 331, 3, 30, 15, 0, 331, 49, 1, 0, 0, 0, 332, 333, 5, 25, 0, 0, 333, 338, 3, 126, 63, 0, 334, 335, 5, 31, 0, 0, 335, 337, 3, 126, 63, 0, 336, 334, 1, 0, 0, 0, 337, 340, 1, 0, 0, 0, 338, 336, 1, 0, 0, 0, 338, 339, 1, 0, 0, 0, 339, 51, 1, 0, 0, 0, 340, 338, 1, 0, 0, 0, 341, 342, 5, 24, 0, 0, 342, 343, 3, 30, 15, 0, 343, 53, 1, 0, 0, 0, 344, 345, 5, 49, 0, 0, 345, 346, 3, 126, 63, 0, 346, 347, 3, 28, 14, 0, 347, 55, 1, 0, 0, 0, 348, 350, 3, 58, 29, 0, 349, 348, 1, 0, 0, 0, 350, 351, 1, 0, 0, 0, 351, 349, 1, 0, 0, 0, 351, 352, 1, 0, 0, 0, 352, 57, 1, 0, 0, 0, 353, 354, 7, 0, 0, 0, 354, 59, 1, 0, 0, 0, 355, 356, 3, 62, 31, 0, 356, 61, 1, 0, 0, 0, 357, 362, 3, 64, 32, 0, 358, 359, 5, 45, 0, 0, 359, 361, 3, 64, 32, 0, 360, 358, 1, 0, 0, 0, 361, 364, 1, 0, 0, 0, 362, 360, 1, 0, 0, 0, 362, 363, 1, 0, 0, 0, 363, 63, 1, 0, 0, 0, 364, 362, 1, 0, 0, 0, 365, 368, 3, 92, 46, 0, 366, 367, 5, 50, 0, 0, 367, 369, 3, 126, 63, 0, 368, 366, 1, 0, 0, 0, 368, 369, 1, 0, 0, 0, 369, 65, 1, 0, 0, 0, 370, 372, 5, 16, 0, 0, 371, 370, 1, 0, 0, 0, 371, 372, 1, 0, 0, 0, 372, 373, 1, 0, 0, 0, 373, 374, 5, 1, 0, 0, 374, 375, 5, 29, 0, 0, 375, 376, 3, 68, 34, 0, 376, 377, 5, 32, 0, 0, 377, 67, 1, 0, 0, 0, 378, 379, 3, 70, 35, 0, 379, 69, 1, 0, 0, 0, 380, 385, 3, 72, 36, 0, 381, 382, 5, 45, 0, 0, 382, 384, 3, 72, 36, 0, 383, 381, 1, 0, 0, 0, 384, 387, 1, 0, 0, 0, 385, 383, 1, 0, 0, 0, 385, 386, 1, 0, 0, 0, 386, 71, 1, 0, 0, 0, 387, 385, 1, 0, 0, 0, 388, 390, 3, 74, 37, 0, 389, 391, 3, 82, 41, 0, 390, 389, 1, 0, 0, 0, 390, 391, 1, 0, 0, 0, 391, 394, 1, 0, 0, 0, 392, 394, 1, 0, 0, 0, 393, 388, 1, 0, 0, 0, 393, 392, 1, 0, 0, 0, 394, 73, 1, 0, 0, 0, 395, 397, 3, 76, 38, 0, 396, 395, 1, 0, 0, 0, 397, 398, 1, 0, 0, 0, 398, 396, 1, 0, 0, 0, 398, 399, 1, 0, 0, 0, 399, 402, 1, 0, 0, 0, 400, 402, 1, 0, 0, 0, 401, 396, 1, 0, 0, 0, 401, 400, 1, 0, 0, 0, 402, 75, 1, 0, 0, 0, 403, 405, 3, 78, 39, 0, 404, 406, 3, 102, 51, 0, 405, 404, 1, 0, 0, 0, 405, 406, 1, 0, 0, 0, 406, 420, 1, 0, 0, 0, 407, 409, 3, 104, 52, 0, 408, 410, 3, 102, 51, 0, 409, 408, 1, 0, 0, 0, 409, 410, 1, 0, 0, 0, 410, 420, 1, 0, 0, 0, 411, 413, 3, 80, 40, 0, 412, 414, 3, 102, 51, 0, 413, 412, 1, 0, 0, 0, 413, 414, 1, 0, 0, 0, 414, 420, 1, 0, 0, 0, 415, 417, 3, 28, 14, 0, 416, 418, 5, 41, 0, 0, 417, 416, 1, 0, 0, 0, 417, 418, 1, 0, 0, 0, 418, 420, 1, 0, 0, 0, 419, 403, 1, 0, 0, 0, 419, 407, 1, 0, 0, 0, 419, 411, 1, 0, 0, 0, 419, 415, 1, 0, 0, 0, 420, 77, 1, 0, 0, 0, 421, 422, 3, 126, 63, 0, 422, 425, 7, 1, 0, 0, 423, 426, 3, 104, 52, 0, 424, 426, 3, 80, 40, 0, 425, 423, 1, 0, 0, 0, 425, 424, 1, 0, 0, 0, 426, 79, 1, 0, 0, 0, 427, 428, 5, 33, 0, 0, 428, 429, 3, 70, 35, 0, 429, 430, 5, 34, 0, 0, 430, 81, 1, 0, 0, 0, 431, 432, 5, 37, 0, 0, 432, 437, 3, 84, 42, 0, 433, 434, 5, 31, 0, 0, 434, 436, 3, 84, 42, 0, 435, 433, 1, 0, 0, 0, 436, 439, 1, 0, 0, 0, 437, 435, 1, 0, 0, 0, 437, 438, 1, 0, 0, 0, 438, 83, 1, 0, 0, 0, 439, 437, 1, 0, 0, 0, 440, 441, 3, 86, 43, 0, 441, 442, 5, 33, 0, 0, 442, 443, 3, 88, 44, 0, 443, 444, 5, 34, 0, 0, 444, 447, 1, 0, 0, 0, 445, 447, 3, 86, 43, 0, 446, 440, 1, 0, 0, 0, 446, 445, 1, 0, 0, 0, 447, 85, 1, 0, 0, 0, 448, 451, 3, 126, 63, 0, 449, 451, 5, 28, 0, 0, 450, 448, 1, 0, 0, 0, 450, 449, 1, 0, 0, 0, 451, 87, 1, 0, 0, 0, 452, 455, 3, 126, 63, 0, 453, 455, 5, 7, 0, 0, 454, 452, 1, 0, 0, 0, 454, 453, 1, 0, 0, 0, 455, 89, 1, 0, 0, 0, 456, 461, 3, 92, 46, 0, 457, 458, 5, 45, 0, 0, 458, 460, 3, 92, 46, 0, 459, 457, 1, 0, 0, 0, 460, 463, 1, 0, 0, 0, 461, 459, 1, 0, 0, 0, 461, 462, 1, 0, 0, 0, 462, 91, 1, 0, 0, 0, 463, 461, 1, 0, 0, 0, 464, 466, 3, 122, 61, 0, 465, 464, 1, 0, 0, 0, 465, 466, 1, 0, 0, 0, 466, 468, 1, 0, 0, 0, 467, 469, 3, 94, 47, 0, 468, 467, 1, 0, 0, 0, 469, 470, 1, 0, 0, 0, 470, 468, 1, 0, 0, 0, 470, 471, 1, 0, 0, 0, 471, 474, 1, 0, 0, 0, 472, 474, 1, 0, 0, 0, 473, 465, 1, 0, 0, 0, 473, 472, 1, 0, 0, 0, 474, 93, 1, 0, 0, 0, 475, 478, 3, 96, 48, 0, 476, 479, 3, 102, 51, 0, 477, 479, 1, 0, 0, 0, 478, 476, 1, 0, 0, 0, 478, 477, 1, 0, 0, 0, 479, 491, 1, 0, 0, 0, 480, 483, 3, 106, 53, 0, 481, 484, 3, 102, 51, 0, 482, 484, 1, 0, 0, 0, 483, 481, 1, 0, 0, 0, 483, 482, 1, 0, 0, 0, 484, 491, 1, 0, 0, 0, 485, 491, 3, 98, 49, 0, 486, 488, 3, 28, 14, 0, 487, 489, 5, 41, 0, 0, 488, 487, 1, 0, 0, 0, 488, 489, 1, 0, 0, 0, 489, 491, 1, 0, 0, 0, 490, 475, 1, 0, 0, 0, 490, 480, 1, 0, 0, 0, 490, 485, 1, 0, 0, 0, 490, 486, 1, 0, 0, 0, 491, 95, 1, 0, 0, 0, 492, 493, 3, 126, 63, 0, 493, 496, 7, 1, 0, 0, 494, 497, 3, 106, 53, 0, 495, 497, 3, 114, 57, 0, 496, 494, 1, 0, 0, 0, 496, 495, 1, 0, 0, 0, 497, 97, 1, 0, 0, 0, 498, 500, 3, 114, 57, 0, 499, 501, 3, 100, 50, 0, 500, 499, 1, 0, 0, 0, 500, 501, 1, 0, 0, 0, 501, 99, 1, 0, 0, 0, 502, 503, 3, 102, 51, 0, 503, 101, 1, 0, 0, 0, 504, 506, 5, 41, 0, 0, 505, 507, 5, 41, 0, 0, 506, 505, 1, 0, 0, 0, 506, 507, 1, 0, 0, 0, 507, 517, 1, 0, 0, 0, 508, 510, 5, 42, 0, 0, 509, 511, 5, 41, 0, 0, 510, 509, 1, 0, 0, 0, 510, 511, 1, 0, 0, 0, 511, 517, 1, 0, 0, 0, 512, 514, 5, 44, 0, 0, 513, 515, 5, 41, 0, 0, 514, 513, 1, 0, 0, 0, 514, 515, 1, 0, 0, 0, 515, 517, 1, 0, 0, 0, 516, 504, 1, 0, 0, 0, 516, 508, 1, 0, 0, 0, 516, 512, 1, 0, 0, 0, 517, 103, 1, 0, 0, 0, 518, 527, 3, 118, 59, 0, 519, 527, 3, 120, 60, 0, 520, 527, 3, 108, 54, 0, 521, 527, 5, 3, 0, 0, 522, 524, 5, 48, 0, 0, 523, 525, 3, 122, 61, 0, 524, 523, 1, 0, 0, 0, 524, 525, 1, 0, 0, 0, 525, 527, 1, 0, 0, 0, 526, 518, 1, 0, 0, 0, 526, 519, 1, 0, 0, 0, 526, 520, 1, 0, 0, 0, 526, 521, 1, 0, 0, 0, 526, 522, 1, 0, 0, 0, 527, 105, 1, 0, 0, 0, 528, 536, 3, 120, 60, 0, 529, 536, 3, 116, 58, 0, 530, 536, 3, 108, 54, 0, 531, 533, 5, 48, 0, 0, 532, 534, 3, 122, 61, 0, 533, 532, 1, 0, 0, 0, 533, 534, 1, 0, 0, 0, 534, 536, 1, 0, 0, 0, 535, 528, 1, 0, 0, 0, 535, 529, 1, 0, 0, 0, 535, 530, 1, 0, 0, 0, 535, 531, 1, 0, 0, 0, 536, 107, 1, 0, 0, 0, 537, 538, 5, 51, 0, 0, 538, 542, 3, 112, 56, 0, 539, 540, 5, 51, 0, 0, 540, 542, 3, 110, 55, 0, 541, 537, 1, 0, 0, 0, 541, 539, 1, 0, 0, 0, 542, 109, 1, 0, 0, 0, 543, 544, 5, 33, 0, 0, 544, 549, 3, 112, 56, 0, 545, 546, 5, 45, 0, 0, 546, 548, 3, 112, 56, 0, 547, 545, 1, 0, 0, 0, 548, 551, 1, 0, 0, 0, 549, 547, 1, 0, 0, 0, 549, 550, 1, 0, 0, 0, 550, 552, 1, 0, 0, 0, 551, 549, 1, 0, 0, 0, 552, 553, 5, 34, 0, 0, 553, 111, 1, 0, 0, 0, 554, 556, 5, 1, 0, 0, 555, 557, 3, 122, 61, 0, 556, 555, 1, 0, 0, 0, 556, 557, 1, 0, 0, 0, 557, 565, 1, 0, 0, 0, 558, 560, 5, 8, 0, 0, 559, 561, 3, 122, 61, 0, 560, 559, 1, 0, 0, 0, 560, 561, 1, 0, 0, 0, 561, 565, 1, 0, 0, 0, 562, 565, 3, 118, 59, 0, 563, 565, 5, 3, 0, 0, 564, 554, 1, 0, 0, 0, 564, 558, 1, 0, 0, 0, 564, 562, 1, 0, 0, 0, 564, 563, 1, 0, 0, 0, 565, 113, 1, 0, 0, 0, 566, 577, 5, 33, 0, 0, 567, 569, 3, 8, 4, 0, 568, 567, 1, 0, 0, 0, 568, 569, 1, 0, 0, 0, 569, 573, 1, 0, 0, 0, 570, 572, 3, 54, 27, 0, 571, 570, 1, 0, 0, 0, 572, 575, 1, 0, 0, 0, 573, 571, 1, 0, 0, 0, 573, 574, 1, 0, 0, 0, 574, 576, 1, 0, 0, 0, 575, 573, 1, 0, 0, 0, 576, 578, 5, 29, 0, 0, 577, 568, 1, 0, 0, 0, 577, 578, 1, 0, 0, 0, 578, 579, 1, 0, 0, 0, 579, 580, 3, 90, 45, 0, 580, 581, 5, 34, 0, 0, 581, 115, 1, 0, 0, 0, 582, 584, 5, 2, 0, 0, 583, 585, 3, 30, 15, 0, 584, 583, 1, 0, 0, 0, 584, 585, 1, 0, 0, 0, 585, 587, 1, 0, 0, 0, 586, 588, 3, 122, 61, 0, 587, 586, 1, 0, 0, 0, 587, 588, 1, 0, 0, 0, 588, 117, 1, 0, 0, 0, 589, 590, 5, 8, 0, 0, 590, 591, 5, 47, 0, 0, 591, 592, 5, 8, 0, 0, 592, 119, 1, 0, 0, 0, 593, 595, 5, 1, 0, 0, 594, 596, 3, 122, 61, 0, 595, 594, 1, 0, 0, 0, 595, 596, 1, 0, 0, 0, 596, 602, 1, 0, 0, 0, 597, 599, 5, 8, 0, 0, 598, 600, 3, 122, 61, 0, 599, 598, 1, 0, 0, 0, 599, 600, 1, 0, 0, 0, 600, 602, 1, 0, 0, 0, 601, 593, 1, 0, 0, 0, 601, 597, 1, 0, 0, 0, 602, 121, 1, 0, 0, 0, 603, 604, 5, 38, 0, 0, 604, 609, 3, 124, 62, 0, 605, 606, 5, 31, 0, 0, 606, 608, 3, 124, 62, 0, 607, 605, 1, 0, 0, 0, 608, 611, 1, 0, 0, 0, 609, 607, 1, 0, 0, 0, 609, 610, 1, 0, 0, 0, 610, 612, 1, 0, 0, 0, 611, 609, 1, 0, 0, 0, 612, 613, 5, 39, 0, 0, 613, 123, 1, 0, 0, 0, 614, 622, 3, 126, 63, 0, 615, 616, 3, 126, 63, 0, 616, 619, 5, 40, 0, 0, 617, 620, 3, 126, 63, 0, 618, 620, 5, 8, 0, 0, 619, 617, 1, 0, 0, 0, 619, 618, 1, 0, 0, 0, 620, 622, 1, 0, 0, 0, 621, 614, 1, 0, 0, 0, 621, 615, 1, 0, 0, 0, 622, 125, 1, 0, 0, 0, 623, 624, 7, 2, 0, 0, 624, 127, 1, 0, 0, 0, 83, 132, 139, 153, 160, 168, 182, 188, 196, 206, 210, 216, 225, 229, 235, 243, 249, 258, 269, 275, 280, 283, 287, 290, 293, 296, 301, 312, 316, 327, 338, 351, 362, 368, 371, 385, 390, 393, 398, 401, 405, 409, 413, 417, 419, 425, 437, 446, 450, 454, 461, 465, 470, 473, 478, 483, 488, 490, 496, 500, 506, 510, 514, 516, 524, 526, 533, 535, 541, 549, 556, 560, 564, 568, 573, 577, 584, 587, 595, 599, 601, 609, 619, 621}; staticData->serializedATN = antlr4::atn::SerializedATNView( serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0])); antlr4::atn::ATNDeserializer deserializer; staticData->atn = deserializer.deserialize(staticData->serializedATN); const size_t count = staticData->atn->getNumberOfDecisions(); staticData->decisionToDFA.reserve(count); for (size_t i = 0; i < count; i++) { staticData->decisionToDFA.emplace_back(staticData->atn->getDecisionState(i), i); } antlrv4parserParserStaticData = staticData.release(); } } // namespace ANTLRv4Parser::ANTLRv4Parser(TokenStream *input) : ANTLRv4Parser(input, antlr4::atn::ParserATNSimulatorOptions()) {} ANTLRv4Parser::ANTLRv4Parser( TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options) : Parser(input) { ANTLRv4Parser::initialize(); _interpreter = new atn::ParserATNSimulator( this, *antlrv4parserParserStaticData->atn, antlrv4parserParserStaticData->decisionToDFA, antlrv4parserParserStaticData->sharedContextCache, options); } ANTLRv4Parser::~ANTLRv4Parser() { delete _interpreter; } const atn::ATN &ANTLRv4Parser::getATN() const { return *antlrv4parserParserStaticData->atn; } std::string ANTLRv4Parser::getGrammarFileName() const { return "ANTLRv4Parser.g4"; } const std::vector &ANTLRv4Parser::getRuleNames() const { return antlrv4parserParserStaticData->ruleNames; } const dfa::Vocabulary &ANTLRv4Parser::getVocabulary() const { return antlrv4parserParserStaticData->vocabulary; } antlr4::atn::SerializedATNView ANTLRv4Parser::getSerializedATN() const { return antlrv4parserParserStaticData->serializedATN; } //----------------- GrammarSpecContext //------------------------------------------------------------------ ANTLRv4Parser::GrammarSpecContext::GrammarSpecContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} ANTLRv4Parser::GrammarDeclContext * ANTLRv4Parser::GrammarSpecContext::grammarDecl() { return getRuleContext(0); } ANTLRv4Parser::RulesContext *ANTLRv4Parser::GrammarSpecContext::rules() { return getRuleContext(0); } tree::TerminalNode *ANTLRv4Parser::GrammarSpecContext::EOF() { return getToken(ANTLRv4Parser::EOF, 0); } std::vector ANTLRv4Parser::GrammarSpecContext::prequelConstruct() { return getRuleContexts(); } ANTLRv4Parser::PrequelConstructContext * ANTLRv4Parser::GrammarSpecContext::prequelConstruct(size_t i) { return getRuleContext(i); } std::vector ANTLRv4Parser::GrammarSpecContext::modeSpec() { return getRuleContexts(); } ANTLRv4Parser::ModeSpecContext *ANTLRv4Parser::GrammarSpecContext::modeSpec( size_t i) { return getRuleContext(i); } size_t ANTLRv4Parser::GrammarSpecContext::getRuleIndex() const { return ANTLRv4Parser::RuleGrammarSpec; } void ANTLRv4Parser::GrammarSpecContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterGrammarSpec(this); } void ANTLRv4Parser::GrammarSpecContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitGrammarSpec(this); } ANTLRv4Parser::GrammarSpecContext *ANTLRv4Parser::grammarSpec() { GrammarSpecContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 0, ANTLRv4Parser::RuleGrammarSpec); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(128); grammarDecl(); setState(132); _errHandler->sync(this); _la = _input->LA(1); while ( (((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 562949953482752) != 0)) { setState(129); prequelConstruct(); setState(134); _errHandler->sync(this); _la = _input->LA(1); } setState(135); rules(); setState(139); _errHandler->sync(this); _la = _input->LA(1); while (_la == ANTLRv4Parser::MODE) { setState(136); modeSpec(); setState(141); _errHandler->sync(this); _la = _input->LA(1); } setState(142); match(ANTLRv4Parser::EOF); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- GrammarDeclContext //------------------------------------------------------------------ ANTLRv4Parser::GrammarDeclContext::GrammarDeclContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} ANTLRv4Parser::GrammarTypeContext * ANTLRv4Parser::GrammarDeclContext::grammarType() { return getRuleContext(0); } ANTLRv4Parser::IdentifierContext * ANTLRv4Parser::GrammarDeclContext::identifier() { return getRuleContext(0); } tree::TerminalNode *ANTLRv4Parser::GrammarDeclContext::SEMI() { return getToken(ANTLRv4Parser::SEMI, 0); } size_t ANTLRv4Parser::GrammarDeclContext::getRuleIndex() const { return ANTLRv4Parser::RuleGrammarDecl; } void ANTLRv4Parser::GrammarDeclContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterGrammarDecl(this); } void ANTLRv4Parser::GrammarDeclContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitGrammarDecl(this); } ANTLRv4Parser::GrammarDeclContext *ANTLRv4Parser::grammarDecl() { GrammarDeclContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 2, ANTLRv4Parser::RuleGrammarDecl); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(144); grammarType(); setState(145); identifier(); setState(146); match(ANTLRv4Parser::SEMI); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- GrammarTypeContext //------------------------------------------------------------------ ANTLRv4Parser::GrammarTypeContext::GrammarTypeContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} tree::TerminalNode *ANTLRv4Parser::GrammarTypeContext::LEXER() { return getToken(ANTLRv4Parser::LEXER, 0); } tree::TerminalNode *ANTLRv4Parser::GrammarTypeContext::GRAMMAR() { return getToken(ANTLRv4Parser::GRAMMAR, 0); } tree::TerminalNode *ANTLRv4Parser::GrammarTypeContext::PARSER() { return getToken(ANTLRv4Parser::PARSER, 0); } size_t ANTLRv4Parser::GrammarTypeContext::getRuleIndex() const { return ANTLRv4Parser::RuleGrammarType; } void ANTLRv4Parser::GrammarTypeContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterGrammarType(this); } void ANTLRv4Parser::GrammarTypeContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitGrammarType(this); } ANTLRv4Parser::GrammarTypeContext *ANTLRv4Parser::grammarType() { GrammarTypeContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 4, ANTLRv4Parser::RuleGrammarType); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(153); _errHandler->sync(this); switch (_input->LA(1)) { case ANTLRv4Parser::LEXER: { setState(148); match(ANTLRv4Parser::LEXER); setState(149); match(ANTLRv4Parser::GRAMMAR); break; } case ANTLRv4Parser::PARSER: { setState(150); match(ANTLRv4Parser::PARSER); setState(151); match(ANTLRv4Parser::GRAMMAR); break; } case ANTLRv4Parser::GRAMMAR: { setState(152); match(ANTLRv4Parser::GRAMMAR); break; } default: throw NoViableAltException(this); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- PrequelConstructContext //------------------------------------------------------------------ ANTLRv4Parser::PrequelConstructContext::PrequelConstructContext( ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} ANTLRv4Parser::OptionsSpecContext * ANTLRv4Parser::PrequelConstructContext::optionsSpec() { return getRuleContext(0); } ANTLRv4Parser::DelegateGrammarsContext * ANTLRv4Parser::PrequelConstructContext::delegateGrammars() { return getRuleContext(0); } ANTLRv4Parser::TokensSpecContext * ANTLRv4Parser::PrequelConstructContext::tokensSpec() { return getRuleContext(0); } ANTLRv4Parser::ChannelsSpecContext * ANTLRv4Parser::PrequelConstructContext::channelsSpec() { return getRuleContext(0); } ANTLRv4Parser::Action_Context * ANTLRv4Parser::PrequelConstructContext::action_() { return getRuleContext(0); } size_t ANTLRv4Parser::PrequelConstructContext::getRuleIndex() const { return ANTLRv4Parser::RulePrequelConstruct; } void ANTLRv4Parser::PrequelConstructContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterPrequelConstruct(this); } void ANTLRv4Parser::PrequelConstructContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitPrequelConstruct(this); } ANTLRv4Parser::PrequelConstructContext *ANTLRv4Parser::prequelConstruct() { PrequelConstructContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 6, ANTLRv4Parser::RulePrequelConstruct); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(160); _errHandler->sync(this); switch (_input->LA(1)) { case ANTLRv4Parser::OPTIONS: { enterOuterAlt(_localctx, 1); setState(155); optionsSpec(); break; } case ANTLRv4Parser::IMPORT: { enterOuterAlt(_localctx, 2); setState(156); delegateGrammars(); break; } case ANTLRv4Parser::TOKENS: { enterOuterAlt(_localctx, 3); setState(157); tokensSpec(); break; } case ANTLRv4Parser::CHANNELS: { enterOuterAlt(_localctx, 4); setState(158); channelsSpec(); break; } case ANTLRv4Parser::AT: { enterOuterAlt(_localctx, 5); setState(159); action_(); break; } default: throw NoViableAltException(this); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- OptionsSpecContext //------------------------------------------------------------------ ANTLRv4Parser::OptionsSpecContext::OptionsSpecContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} tree::TerminalNode *ANTLRv4Parser::OptionsSpecContext::OPTIONS() { return getToken(ANTLRv4Parser::OPTIONS, 0); } tree::TerminalNode *ANTLRv4Parser::OptionsSpecContext::RBRACE() { return getToken(ANTLRv4Parser::RBRACE, 0); } std::vector ANTLRv4Parser::OptionsSpecContext::option() { return getRuleContexts(); } ANTLRv4Parser::OptionContext *ANTLRv4Parser::OptionsSpecContext::option( size_t i) { return getRuleContext(i); } std::vector ANTLRv4Parser::OptionsSpecContext::SEMI() { return getTokens(ANTLRv4Parser::SEMI); } tree::TerminalNode *ANTLRv4Parser::OptionsSpecContext::SEMI(size_t i) { return getToken(ANTLRv4Parser::SEMI, i); } size_t ANTLRv4Parser::OptionsSpecContext::getRuleIndex() const { return ANTLRv4Parser::RuleOptionsSpec; } void ANTLRv4Parser::OptionsSpecContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterOptionsSpec(this); } void ANTLRv4Parser::OptionsSpecContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitOptionsSpec(this); } ANTLRv4Parser::OptionsSpecContext *ANTLRv4Parser::optionsSpec() { OptionsSpecContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 8, ANTLRv4Parser::RuleOptionsSpec); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(162); match(ANTLRv4Parser::OPTIONS); setState(168); _errHandler->sync(this); _la = _input->LA(1); while (_la == ANTLRv4Parser::TOKEN_REF || _la == ANTLRv4Parser::RULE_REF) { setState(163); option(); setState(164); match(ANTLRv4Parser::SEMI); setState(170); _errHandler->sync(this); _la = _input->LA(1); } setState(171); match(ANTLRv4Parser::RBRACE); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- OptionContext //------------------------------------------------------------------ ANTLRv4Parser::OptionContext::OptionContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} ANTLRv4Parser::IdentifierContext *ANTLRv4Parser::OptionContext::identifier() { return getRuleContext(0); } tree::TerminalNode *ANTLRv4Parser::OptionContext::ASSIGN() { return getToken(ANTLRv4Parser::ASSIGN, 0); } ANTLRv4Parser::OptionValueContext *ANTLRv4Parser::OptionContext::optionValue() { return getRuleContext(0); } size_t ANTLRv4Parser::OptionContext::getRuleIndex() const { return ANTLRv4Parser::RuleOption; } void ANTLRv4Parser::OptionContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterOption(this); } void ANTLRv4Parser::OptionContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitOption(this); } ANTLRv4Parser::OptionContext *ANTLRv4Parser::option() { OptionContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 10, ANTLRv4Parser::RuleOption); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(173); identifier(); setState(174); match(ANTLRv4Parser::ASSIGN); setState(175); optionValue(); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- OptionValueContext //------------------------------------------------------------------ ANTLRv4Parser::OptionValueContext::OptionValueContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} std::vector ANTLRv4Parser::OptionValueContext::identifier() { return getRuleContexts(); } ANTLRv4Parser::IdentifierContext *ANTLRv4Parser::OptionValueContext::identifier( size_t i) { return getRuleContext(i); } std::vector ANTLRv4Parser::OptionValueContext::DOT() { return getTokens(ANTLRv4Parser::DOT); } tree::TerminalNode *ANTLRv4Parser::OptionValueContext::DOT(size_t i) { return getToken(ANTLRv4Parser::DOT, i); } tree::TerminalNode *ANTLRv4Parser::OptionValueContext::STRING_LITERAL() { return getToken(ANTLRv4Parser::STRING_LITERAL, 0); } ANTLRv4Parser::ActionBlockContext * ANTLRv4Parser::OptionValueContext::actionBlock() { return getRuleContext(0); } tree::TerminalNode *ANTLRv4Parser::OptionValueContext::INT() { return getToken(ANTLRv4Parser::INT, 0); } size_t ANTLRv4Parser::OptionValueContext::getRuleIndex() const { return ANTLRv4Parser::RuleOptionValue; } void ANTLRv4Parser::OptionValueContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterOptionValue(this); } void ANTLRv4Parser::OptionValueContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitOptionValue(this); } ANTLRv4Parser::OptionValueContext *ANTLRv4Parser::optionValue() { OptionValueContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 12, ANTLRv4Parser::RuleOptionValue); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(188); _errHandler->sync(this); switch (_input->LA(1)) { case ANTLRv4Parser::TOKEN_REF: case ANTLRv4Parser::RULE_REF: { enterOuterAlt(_localctx, 1); setState(177); identifier(); setState(182); _errHandler->sync(this); _la = _input->LA(1); while (_la == ANTLRv4Parser::DOT) { setState(178); match(ANTLRv4Parser::DOT); setState(179); identifier(); setState(184); _errHandler->sync(this); _la = _input->LA(1); } break; } case ANTLRv4Parser::STRING_LITERAL: { enterOuterAlt(_localctx, 2); setState(185); match(ANTLRv4Parser::STRING_LITERAL); break; } case ANTLRv4Parser::BEGIN_ACTION: { enterOuterAlt(_localctx, 3); setState(186); actionBlock(); break; } case ANTLRv4Parser::INT: { enterOuterAlt(_localctx, 4); setState(187); match(ANTLRv4Parser::INT); break; } default: throw NoViableAltException(this); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- DelegateGrammarsContext //------------------------------------------------------------------ ANTLRv4Parser::DelegateGrammarsContext::DelegateGrammarsContext( ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} tree::TerminalNode *ANTLRv4Parser::DelegateGrammarsContext::IMPORT() { return getToken(ANTLRv4Parser::IMPORT, 0); } std::vector ANTLRv4Parser::DelegateGrammarsContext::delegateGrammar() { return getRuleContexts(); } ANTLRv4Parser::DelegateGrammarContext * ANTLRv4Parser::DelegateGrammarsContext::delegateGrammar(size_t i) { return getRuleContext(i); } tree::TerminalNode *ANTLRv4Parser::DelegateGrammarsContext::SEMI() { return getToken(ANTLRv4Parser::SEMI, 0); } std::vector ANTLRv4Parser::DelegateGrammarsContext::COMMA() { return getTokens(ANTLRv4Parser::COMMA); } tree::TerminalNode *ANTLRv4Parser::DelegateGrammarsContext::COMMA(size_t i) { return getToken(ANTLRv4Parser::COMMA, i); } size_t ANTLRv4Parser::DelegateGrammarsContext::getRuleIndex() const { return ANTLRv4Parser::RuleDelegateGrammars; } void ANTLRv4Parser::DelegateGrammarsContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterDelegateGrammars(this); } void ANTLRv4Parser::DelegateGrammarsContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitDelegateGrammars(this); } ANTLRv4Parser::DelegateGrammarsContext *ANTLRv4Parser::delegateGrammars() { DelegateGrammarsContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 14, ANTLRv4Parser::RuleDelegateGrammars); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(190); match(ANTLRv4Parser::IMPORT); setState(191); delegateGrammar(); setState(196); _errHandler->sync(this); _la = _input->LA(1); while (_la == ANTLRv4Parser::COMMA) { setState(192); match(ANTLRv4Parser::COMMA); setState(193); delegateGrammar(); setState(198); _errHandler->sync(this); _la = _input->LA(1); } setState(199); match(ANTLRv4Parser::SEMI); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- DelegateGrammarContext //------------------------------------------------------------------ ANTLRv4Parser::DelegateGrammarContext::DelegateGrammarContext( ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} std::vector ANTLRv4Parser::DelegateGrammarContext::identifier() { return getRuleContexts(); } ANTLRv4Parser::IdentifierContext * ANTLRv4Parser::DelegateGrammarContext::identifier(size_t i) { return getRuleContext(i); } tree::TerminalNode *ANTLRv4Parser::DelegateGrammarContext::ASSIGN() { return getToken(ANTLRv4Parser::ASSIGN, 0); } size_t ANTLRv4Parser::DelegateGrammarContext::getRuleIndex() const { return ANTLRv4Parser::RuleDelegateGrammar; } void ANTLRv4Parser::DelegateGrammarContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterDelegateGrammar(this); } void ANTLRv4Parser::DelegateGrammarContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitDelegateGrammar(this); } ANTLRv4Parser::DelegateGrammarContext *ANTLRv4Parser::delegateGrammar() { DelegateGrammarContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 16, ANTLRv4Parser::RuleDelegateGrammar); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(206); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict( _input, 8, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); setState(201); identifier(); setState(202); match(ANTLRv4Parser::ASSIGN); setState(203); identifier(); break; } case 2: { enterOuterAlt(_localctx, 2); setState(205); identifier(); break; } default: break; } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- TokensSpecContext //------------------------------------------------------------------ ANTLRv4Parser::TokensSpecContext::TokensSpecContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} tree::TerminalNode *ANTLRv4Parser::TokensSpecContext::TOKENS() { return getToken(ANTLRv4Parser::TOKENS, 0); } tree::TerminalNode *ANTLRv4Parser::TokensSpecContext::RBRACE() { return getToken(ANTLRv4Parser::RBRACE, 0); } ANTLRv4Parser::IdListContext *ANTLRv4Parser::TokensSpecContext::idList() { return getRuleContext(0); } size_t ANTLRv4Parser::TokensSpecContext::getRuleIndex() const { return ANTLRv4Parser::RuleTokensSpec; } void ANTLRv4Parser::TokensSpecContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterTokensSpec(this); } void ANTLRv4Parser::TokensSpecContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitTokensSpec(this); } ANTLRv4Parser::TokensSpecContext *ANTLRv4Parser::tokensSpec() { TokensSpecContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 18, ANTLRv4Parser::RuleTokensSpec); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(208); match(ANTLRv4Parser::TOKENS); setState(210); _errHandler->sync(this); _la = _input->LA(1); if (_la == ANTLRv4Parser::TOKEN_REF || _la == ANTLRv4Parser::RULE_REF) { setState(209); idList(); } setState(212); match(ANTLRv4Parser::RBRACE); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- ChannelsSpecContext //------------------------------------------------------------------ ANTLRv4Parser::ChannelsSpecContext::ChannelsSpecContext( ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} tree::TerminalNode *ANTLRv4Parser::ChannelsSpecContext::CHANNELS() { return getToken(ANTLRv4Parser::CHANNELS, 0); } tree::TerminalNode *ANTLRv4Parser::ChannelsSpecContext::RBRACE() { return getToken(ANTLRv4Parser::RBRACE, 0); } ANTLRv4Parser::IdListContext *ANTLRv4Parser::ChannelsSpecContext::idList() { return getRuleContext(0); } size_t ANTLRv4Parser::ChannelsSpecContext::getRuleIndex() const { return ANTLRv4Parser::RuleChannelsSpec; } void ANTLRv4Parser::ChannelsSpecContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterChannelsSpec(this); } void ANTLRv4Parser::ChannelsSpecContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitChannelsSpec(this); } ANTLRv4Parser::ChannelsSpecContext *ANTLRv4Parser::channelsSpec() { ChannelsSpecContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 20, ANTLRv4Parser::RuleChannelsSpec); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(214); match(ANTLRv4Parser::CHANNELS); setState(216); _errHandler->sync(this); _la = _input->LA(1); if (_la == ANTLRv4Parser::TOKEN_REF || _la == ANTLRv4Parser::RULE_REF) { setState(215); idList(); } setState(218); match(ANTLRv4Parser::RBRACE); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- IdListContext //------------------------------------------------------------------ ANTLRv4Parser::IdListContext::IdListContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} std::vector ANTLRv4Parser::IdListContext::identifier() { return getRuleContexts(); } ANTLRv4Parser::IdentifierContext *ANTLRv4Parser::IdListContext::identifier( size_t i) { return getRuleContext(i); } std::vector ANTLRv4Parser::IdListContext::COMMA() { return getTokens(ANTLRv4Parser::COMMA); } tree::TerminalNode *ANTLRv4Parser::IdListContext::COMMA(size_t i) { return getToken(ANTLRv4Parser::COMMA, i); } size_t ANTLRv4Parser::IdListContext::getRuleIndex() const { return ANTLRv4Parser::RuleIdList; } void ANTLRv4Parser::IdListContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterIdList(this); } void ANTLRv4Parser::IdListContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitIdList(this); } ANTLRv4Parser::IdListContext *ANTLRv4Parser::idList() { IdListContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 22, ANTLRv4Parser::RuleIdList); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { size_t alt; enterOuterAlt(_localctx, 1); setState(220); identifier(); setState(225); _errHandler->sync(this); alt = getInterpreter()->adaptivePredict(_input, 11, _ctx); while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { if (alt == 1) { setState(221); match(ANTLRv4Parser::COMMA); setState(222); identifier(); } setState(227); _errHandler->sync(this); alt = getInterpreter()->adaptivePredict( _input, 11, _ctx); } setState(229); _errHandler->sync(this); _la = _input->LA(1); if (_la == ANTLRv4Parser::COMMA) { setState(228); match(ANTLRv4Parser::COMMA); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- Action_Context //------------------------------------------------------------------ ANTLRv4Parser::Action_Context::Action_Context(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} tree::TerminalNode *ANTLRv4Parser::Action_Context::AT() { return getToken(ANTLRv4Parser::AT, 0); } ANTLRv4Parser::IdentifierContext *ANTLRv4Parser::Action_Context::identifier() { return getRuleContext(0); } ANTLRv4Parser::ActionBlockContext * ANTLRv4Parser::Action_Context::actionBlock() { return getRuleContext(0); } ANTLRv4Parser::ActionScopeNameContext * ANTLRv4Parser::Action_Context::actionScopeName() { return getRuleContext(0); } tree::TerminalNode *ANTLRv4Parser::Action_Context::COLONCOLON() { return getToken(ANTLRv4Parser::COLONCOLON, 0); } size_t ANTLRv4Parser::Action_Context::getRuleIndex() const { return ANTLRv4Parser::RuleAction_; } void ANTLRv4Parser::Action_Context::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterAction_(this); } void ANTLRv4Parser::Action_Context::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitAction_(this); } ANTLRv4Parser::Action_Context *ANTLRv4Parser::action_() { Action_Context *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 24, ANTLRv4Parser::RuleAction_); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(231); match(ANTLRv4Parser::AT); setState(235); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict( _input, 13, _ctx)) { case 1: { setState(232); actionScopeName(); setState(233); match(ANTLRv4Parser::COLONCOLON); break; } default: break; } setState(237); identifier(); setState(238); actionBlock(); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- ActionScopeNameContext //------------------------------------------------------------------ ANTLRv4Parser::ActionScopeNameContext::ActionScopeNameContext( ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} ANTLRv4Parser::IdentifierContext * ANTLRv4Parser::ActionScopeNameContext::identifier() { return getRuleContext(0); } tree::TerminalNode *ANTLRv4Parser::ActionScopeNameContext::LEXER() { return getToken(ANTLRv4Parser::LEXER, 0); } tree::TerminalNode *ANTLRv4Parser::ActionScopeNameContext::PARSER() { return getToken(ANTLRv4Parser::PARSER, 0); } size_t ANTLRv4Parser::ActionScopeNameContext::getRuleIndex() const { return ANTLRv4Parser::RuleActionScopeName; } void ANTLRv4Parser::ActionScopeNameContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterActionScopeName(this); } void ANTLRv4Parser::ActionScopeNameContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitActionScopeName(this); } ANTLRv4Parser::ActionScopeNameContext *ANTLRv4Parser::actionScopeName() { ActionScopeNameContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 26, ANTLRv4Parser::RuleActionScopeName); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(243); _errHandler->sync(this); switch (_input->LA(1)) { case ANTLRv4Parser::TOKEN_REF: case ANTLRv4Parser::RULE_REF: { enterOuterAlt(_localctx, 1); setState(240); identifier(); break; } case ANTLRv4Parser::LEXER: { enterOuterAlt(_localctx, 2); setState(241); match(ANTLRv4Parser::LEXER); break; } case ANTLRv4Parser::PARSER: { enterOuterAlt(_localctx, 3); setState(242); match(ANTLRv4Parser::PARSER); break; } default: throw NoViableAltException(this); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- ActionBlockContext //------------------------------------------------------------------ ANTLRv4Parser::ActionBlockContext::ActionBlockContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} tree::TerminalNode *ANTLRv4Parser::ActionBlockContext::BEGIN_ACTION() { return getToken(ANTLRv4Parser::BEGIN_ACTION, 0); } tree::TerminalNode *ANTLRv4Parser::ActionBlockContext::END_ACTION() { return getToken(ANTLRv4Parser::END_ACTION, 0); } std::vector ANTLRv4Parser::ActionBlockContext::ACTION_CONTENT() { return getTokens(ANTLRv4Parser::ACTION_CONTENT); } tree::TerminalNode *ANTLRv4Parser::ActionBlockContext::ACTION_CONTENT( size_t i) { return getToken(ANTLRv4Parser::ACTION_CONTENT, i); } size_t ANTLRv4Parser::ActionBlockContext::getRuleIndex() const { return ANTLRv4Parser::RuleActionBlock; } void ANTLRv4Parser::ActionBlockContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterActionBlock(this); } void ANTLRv4Parser::ActionBlockContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitActionBlock(this); } ANTLRv4Parser::ActionBlockContext *ANTLRv4Parser::actionBlock() { ActionBlockContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 28, ANTLRv4Parser::RuleActionBlock); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(245); match(ANTLRv4Parser::BEGIN_ACTION); setState(249); _errHandler->sync(this); _la = _input->LA(1); while (_la == ANTLRv4Parser::ACTION_CONTENT) { setState(246); match(ANTLRv4Parser::ACTION_CONTENT); setState(251); _errHandler->sync(this); _la = _input->LA(1); } setState(252); match(ANTLRv4Parser::END_ACTION); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- ArgActionBlockContext //------------------------------------------------------------------ ANTLRv4Parser::ArgActionBlockContext::ArgActionBlockContext( ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} tree::TerminalNode *ANTLRv4Parser::ArgActionBlockContext::BEGIN_ARGUMENT() { return getToken(ANTLRv4Parser::BEGIN_ARGUMENT, 0); } tree::TerminalNode *ANTLRv4Parser::ArgActionBlockContext::END_ARGUMENT() { return getToken(ANTLRv4Parser::END_ARGUMENT, 0); } std::vector ANTLRv4Parser::ArgActionBlockContext::ARGUMENT_CONTENT() { return getTokens(ANTLRv4Parser::ARGUMENT_CONTENT); } tree::TerminalNode *ANTLRv4Parser::ArgActionBlockContext::ARGUMENT_CONTENT( size_t i) { return getToken(ANTLRv4Parser::ARGUMENT_CONTENT, i); } size_t ANTLRv4Parser::ArgActionBlockContext::getRuleIndex() const { return ANTLRv4Parser::RuleArgActionBlock; } void ANTLRv4Parser::ArgActionBlockContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterArgActionBlock(this); } void ANTLRv4Parser::ArgActionBlockContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitArgActionBlock(this); } ANTLRv4Parser::ArgActionBlockContext *ANTLRv4Parser::argActionBlock() { ArgActionBlockContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 30, ANTLRv4Parser::RuleArgActionBlock); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(254); match(ANTLRv4Parser::BEGIN_ARGUMENT); setState(258); _errHandler->sync(this); _la = _input->LA(1); while (_la == ANTLRv4Parser::ARGUMENT_CONTENT) { setState(255); match(ANTLRv4Parser::ARGUMENT_CONTENT); setState(260); _errHandler->sync(this); _la = _input->LA(1); } setState(261); match(ANTLRv4Parser::END_ARGUMENT); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- ModeSpecContext //------------------------------------------------------------------ ANTLRv4Parser::ModeSpecContext::ModeSpecContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} tree::TerminalNode *ANTLRv4Parser::ModeSpecContext::MODE() { return getToken(ANTLRv4Parser::MODE, 0); } ANTLRv4Parser::IdentifierContext *ANTLRv4Parser::ModeSpecContext::identifier() { return getRuleContext(0); } tree::TerminalNode *ANTLRv4Parser::ModeSpecContext::SEMI() { return getToken(ANTLRv4Parser::SEMI, 0); } std::vector ANTLRv4Parser::ModeSpecContext::lexerRuleSpec() { return getRuleContexts(); } ANTLRv4Parser::LexerRuleSpecContext * ANTLRv4Parser::ModeSpecContext::lexerRuleSpec(size_t i) { return getRuleContext(i); } size_t ANTLRv4Parser::ModeSpecContext::getRuleIndex() const { return ANTLRv4Parser::RuleModeSpec; } void ANTLRv4Parser::ModeSpecContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterModeSpec(this); } void ANTLRv4Parser::ModeSpecContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitModeSpec(this); } ANTLRv4Parser::ModeSpecContext *ANTLRv4Parser::modeSpec() { ModeSpecContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 32, ANTLRv4Parser::RuleModeSpec); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(263); match(ANTLRv4Parser::MODE); setState(264); identifier(); setState(265); match(ANTLRv4Parser::SEMI); setState(269); _errHandler->sync(this); _la = _input->LA(1); while (_la == ANTLRv4Parser::TOKEN_REF || _la == ANTLRv4Parser::FRAGMENT) { setState(266); lexerRuleSpec(); setState(271); _errHandler->sync(this); _la = _input->LA(1); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- RulesContext //------------------------------------------------------------------ ANTLRv4Parser::RulesContext::RulesContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} std::vector ANTLRv4Parser::RulesContext::ruleSpec() { return getRuleContexts(); } ANTLRv4Parser::RuleSpecContext *ANTLRv4Parser::RulesContext::ruleSpec( size_t i) { return getRuleContext(i); } size_t ANTLRv4Parser::RulesContext::getRuleIndex() const { return ANTLRv4Parser::RuleRules; } void ANTLRv4Parser::RulesContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterRules(this); } void ANTLRv4Parser::RulesContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitRules(this); } ANTLRv4Parser::RulesContext *ANTLRv4Parser::rules() { RulesContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 34, ANTLRv4Parser::RuleRules); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(275); _errHandler->sync(this); _la = _input->LA(1); while ((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 7405574) != 0)) { setState(272); ruleSpec(); setState(277); _errHandler->sync(this); _la = _input->LA(1); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- RuleSpecContext //------------------------------------------------------------------ ANTLRv4Parser::RuleSpecContext::RuleSpecContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} ANTLRv4Parser::ParserRuleSpecContext * ANTLRv4Parser::RuleSpecContext::parserRuleSpec() { return getRuleContext(0); } ANTLRv4Parser::LexerRuleSpecContext * ANTLRv4Parser::RuleSpecContext::lexerRuleSpec() { return getRuleContext(0); } size_t ANTLRv4Parser::RuleSpecContext::getRuleIndex() const { return ANTLRv4Parser::RuleRuleSpec; } void ANTLRv4Parser::RuleSpecContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterRuleSpec(this); } void ANTLRv4Parser::RuleSpecContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitRuleSpec(this); } ANTLRv4Parser::RuleSpecContext *ANTLRv4Parser::ruleSpec() { RuleSpecContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 36, ANTLRv4Parser::RuleRuleSpec); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(280); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict( _input, 19, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); setState(278); parserRuleSpec(); break; } case 2: { enterOuterAlt(_localctx, 2); setState(279); lexerRuleSpec(); break; } default: break; } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- ParserRuleSpecContext //------------------------------------------------------------------ ANTLRv4Parser::ParserRuleSpecContext::ParserRuleSpecContext( ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} tree::TerminalNode *ANTLRv4Parser::ParserRuleSpecContext::RULE_REF() { return getToken(ANTLRv4Parser::RULE_REF, 0); } tree::TerminalNode *ANTLRv4Parser::ParserRuleSpecContext::COLON() { return getToken(ANTLRv4Parser::COLON, 0); } ANTLRv4Parser::RuleBlockContext * ANTLRv4Parser::ParserRuleSpecContext::ruleBlock() { return getRuleContext(0); } tree::TerminalNode *ANTLRv4Parser::ParserRuleSpecContext::SEMI() { return getToken(ANTLRv4Parser::SEMI, 0); } ANTLRv4Parser::ExceptionGroupContext * ANTLRv4Parser::ParserRuleSpecContext::exceptionGroup() { return getRuleContext(0); } ANTLRv4Parser::RuleModifiersContext * ANTLRv4Parser::ParserRuleSpecContext::ruleModifiers() { return getRuleContext(0); } ANTLRv4Parser::ArgActionBlockContext * ANTLRv4Parser::ParserRuleSpecContext::argActionBlock() { return getRuleContext(0); } ANTLRv4Parser::RuleReturnsContext * ANTLRv4Parser::ParserRuleSpecContext::ruleReturns() { return getRuleContext(0); } ANTLRv4Parser::ThrowsSpecContext * ANTLRv4Parser::ParserRuleSpecContext::throwsSpec() { return getRuleContext(0); } ANTLRv4Parser::LocalsSpecContext * ANTLRv4Parser::ParserRuleSpecContext::localsSpec() { return getRuleContext(0); } std::vector ANTLRv4Parser::ParserRuleSpecContext::rulePrequel() { return getRuleContexts(); } ANTLRv4Parser::RulePrequelContext * ANTLRv4Parser::ParserRuleSpecContext::rulePrequel(size_t i) { return getRuleContext(i); } size_t ANTLRv4Parser::ParserRuleSpecContext::getRuleIndex() const { return ANTLRv4Parser::RuleParserRuleSpec; } void ANTLRv4Parser::ParserRuleSpecContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterParserRuleSpec(this); } void ANTLRv4Parser::ParserRuleSpecContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitParserRuleSpec(this); } ANTLRv4Parser::ParserRuleSpecContext *ANTLRv4Parser::parserRuleSpec() { ParserRuleSpecContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 38, ANTLRv4Parser::RuleParserRuleSpec); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(283); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 7405568) != 0)) { setState(282); ruleModifiers(); } setState(285); match(ANTLRv4Parser::RULE_REF); setState(287); _errHandler->sync(this); _la = _input->LA(1); if (_la == ANTLRv4Parser::BEGIN_ARGUMENT) { setState(286); argActionBlock(); } setState(290); _errHandler->sync(this); _la = _input->LA(1); if (_la == ANTLRv4Parser::RETURNS) { setState(289); ruleReturns(); } setState(293); _errHandler->sync(this); _la = _input->LA(1); if (_la == ANTLRv4Parser::THROWS) { setState(292); throwsSpec(); } setState(296); _errHandler->sync(this); _la = _input->LA(1); if (_la == ANTLRv4Parser::LOCALS) { setState(295); localsSpec(); } setState(301); _errHandler->sync(this); _la = _input->LA(1); while (_la == ANTLRv4Parser::OPTIONS || _la == ANTLRv4Parser::AT) { setState(298); rulePrequel(); setState(303); _errHandler->sync(this); _la = _input->LA(1); } setState(304); match(ANTLRv4Parser::COLON); setState(305); ruleBlock(); setState(306); match(ANTLRv4Parser::SEMI); setState(307); exceptionGroup(); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- ExceptionGroupContext //------------------------------------------------------------------ ANTLRv4Parser::ExceptionGroupContext::ExceptionGroupContext( ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} std::vector ANTLRv4Parser::ExceptionGroupContext::exceptionHandler() { return getRuleContexts(); } ANTLRv4Parser::ExceptionHandlerContext * ANTLRv4Parser::ExceptionGroupContext::exceptionHandler(size_t i) { return getRuleContext(i); } ANTLRv4Parser::FinallyClauseContext * ANTLRv4Parser::ExceptionGroupContext::finallyClause() { return getRuleContext(0); } size_t ANTLRv4Parser::ExceptionGroupContext::getRuleIndex() const { return ANTLRv4Parser::RuleExceptionGroup; } void ANTLRv4Parser::ExceptionGroupContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterExceptionGroup(this); } void ANTLRv4Parser::ExceptionGroupContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitExceptionGroup(this); } ANTLRv4Parser::ExceptionGroupContext *ANTLRv4Parser::exceptionGroup() { ExceptionGroupContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 40, ANTLRv4Parser::RuleExceptionGroup); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(312); _errHandler->sync(this); _la = _input->LA(1); while (_la == ANTLRv4Parser::CATCH) { setState(309); exceptionHandler(); setState(314); _errHandler->sync(this); _la = _input->LA(1); } setState(316); _errHandler->sync(this); _la = _input->LA(1); if (_la == ANTLRv4Parser::FINALLY) { setState(315); finallyClause(); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- ExceptionHandlerContext //------------------------------------------------------------------ ANTLRv4Parser::ExceptionHandlerContext::ExceptionHandlerContext( ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} tree::TerminalNode *ANTLRv4Parser::ExceptionHandlerContext::CATCH() { return getToken(ANTLRv4Parser::CATCH, 0); } ANTLRv4Parser::ArgActionBlockContext * ANTLRv4Parser::ExceptionHandlerContext::argActionBlock() { return getRuleContext(0); } ANTLRv4Parser::ActionBlockContext * ANTLRv4Parser::ExceptionHandlerContext::actionBlock() { return getRuleContext(0); } size_t ANTLRv4Parser::ExceptionHandlerContext::getRuleIndex() const { return ANTLRv4Parser::RuleExceptionHandler; } void ANTLRv4Parser::ExceptionHandlerContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterExceptionHandler(this); } void ANTLRv4Parser::ExceptionHandlerContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitExceptionHandler(this); } ANTLRv4Parser::ExceptionHandlerContext *ANTLRv4Parser::exceptionHandler() { ExceptionHandlerContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 42, ANTLRv4Parser::RuleExceptionHandler); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(318); match(ANTLRv4Parser::CATCH); setState(319); argActionBlock(); setState(320); actionBlock(); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- FinallyClauseContext //------------------------------------------------------------------ ANTLRv4Parser::FinallyClauseContext::FinallyClauseContext( ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} tree::TerminalNode *ANTLRv4Parser::FinallyClauseContext::FINALLY() { return getToken(ANTLRv4Parser::FINALLY, 0); } ANTLRv4Parser::ActionBlockContext * ANTLRv4Parser::FinallyClauseContext::actionBlock() { return getRuleContext(0); } size_t ANTLRv4Parser::FinallyClauseContext::getRuleIndex() const { return ANTLRv4Parser::RuleFinallyClause; } void ANTLRv4Parser::FinallyClauseContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterFinallyClause(this); } void ANTLRv4Parser::FinallyClauseContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitFinallyClause(this); } ANTLRv4Parser::FinallyClauseContext *ANTLRv4Parser::finallyClause() { FinallyClauseContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 44, ANTLRv4Parser::RuleFinallyClause); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(322); match(ANTLRv4Parser::FINALLY); setState(323); actionBlock(); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- RulePrequelContext //------------------------------------------------------------------ ANTLRv4Parser::RulePrequelContext::RulePrequelContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} ANTLRv4Parser::OptionsSpecContext * ANTLRv4Parser::RulePrequelContext::optionsSpec() { return getRuleContext(0); } ANTLRv4Parser::RuleActionContext * ANTLRv4Parser::RulePrequelContext::ruleAction() { return getRuleContext(0); } size_t ANTLRv4Parser::RulePrequelContext::getRuleIndex() const { return ANTLRv4Parser::RuleRulePrequel; } void ANTLRv4Parser::RulePrequelContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterRulePrequel(this); } void ANTLRv4Parser::RulePrequelContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitRulePrequel(this); } ANTLRv4Parser::RulePrequelContext *ANTLRv4Parser::rulePrequel() { RulePrequelContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 46, ANTLRv4Parser::RuleRulePrequel); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(327); _errHandler->sync(this); switch (_input->LA(1)) { case ANTLRv4Parser::OPTIONS: { enterOuterAlt(_localctx, 1); setState(325); optionsSpec(); break; } case ANTLRv4Parser::AT: { enterOuterAlt(_localctx, 2); setState(326); ruleAction(); break; } default: throw NoViableAltException(this); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- RuleReturnsContext //------------------------------------------------------------------ ANTLRv4Parser::RuleReturnsContext::RuleReturnsContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} tree::TerminalNode *ANTLRv4Parser::RuleReturnsContext::RETURNS() { return getToken(ANTLRv4Parser::RETURNS, 0); } ANTLRv4Parser::ArgActionBlockContext * ANTLRv4Parser::RuleReturnsContext::argActionBlock() { return getRuleContext(0); } size_t ANTLRv4Parser::RuleReturnsContext::getRuleIndex() const { return ANTLRv4Parser::RuleRuleReturns; } void ANTLRv4Parser::RuleReturnsContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterRuleReturns(this); } void ANTLRv4Parser::RuleReturnsContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitRuleReturns(this); } ANTLRv4Parser::RuleReturnsContext *ANTLRv4Parser::ruleReturns() { RuleReturnsContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 48, ANTLRv4Parser::RuleRuleReturns); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(329); match(ANTLRv4Parser::RETURNS); setState(330); argActionBlock(); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- ThrowsSpecContext //------------------------------------------------------------------ ANTLRv4Parser::ThrowsSpecContext::ThrowsSpecContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} tree::TerminalNode *ANTLRv4Parser::ThrowsSpecContext::THROWS() { return getToken(ANTLRv4Parser::THROWS, 0); } std::vector ANTLRv4Parser::ThrowsSpecContext::identifier() { return getRuleContexts(); } ANTLRv4Parser::IdentifierContext *ANTLRv4Parser::ThrowsSpecContext::identifier( size_t i) { return getRuleContext(i); } std::vector ANTLRv4Parser::ThrowsSpecContext::COMMA() { return getTokens(ANTLRv4Parser::COMMA); } tree::TerminalNode *ANTLRv4Parser::ThrowsSpecContext::COMMA(size_t i) { return getToken(ANTLRv4Parser::COMMA, i); } size_t ANTLRv4Parser::ThrowsSpecContext::getRuleIndex() const { return ANTLRv4Parser::RuleThrowsSpec; } void ANTLRv4Parser::ThrowsSpecContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterThrowsSpec(this); } void ANTLRv4Parser::ThrowsSpecContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitThrowsSpec(this); } ANTLRv4Parser::ThrowsSpecContext *ANTLRv4Parser::throwsSpec() { ThrowsSpecContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 50, ANTLRv4Parser::RuleThrowsSpec); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(332); match(ANTLRv4Parser::THROWS); setState(333); identifier(); setState(338); _errHandler->sync(this); _la = _input->LA(1); while (_la == ANTLRv4Parser::COMMA) { setState(334); match(ANTLRv4Parser::COMMA); setState(335); identifier(); setState(340); _errHandler->sync(this); _la = _input->LA(1); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- LocalsSpecContext //------------------------------------------------------------------ ANTLRv4Parser::LocalsSpecContext::LocalsSpecContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} tree::TerminalNode *ANTLRv4Parser::LocalsSpecContext::LOCALS() { return getToken(ANTLRv4Parser::LOCALS, 0); } ANTLRv4Parser::ArgActionBlockContext * ANTLRv4Parser::LocalsSpecContext::argActionBlock() { return getRuleContext(0); } size_t ANTLRv4Parser::LocalsSpecContext::getRuleIndex() const { return ANTLRv4Parser::RuleLocalsSpec; } void ANTLRv4Parser::LocalsSpecContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterLocalsSpec(this); } void ANTLRv4Parser::LocalsSpecContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitLocalsSpec(this); } ANTLRv4Parser::LocalsSpecContext *ANTLRv4Parser::localsSpec() { LocalsSpecContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 52, ANTLRv4Parser::RuleLocalsSpec); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(341); match(ANTLRv4Parser::LOCALS); setState(342); argActionBlock(); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- RuleActionContext //------------------------------------------------------------------ ANTLRv4Parser::RuleActionContext::RuleActionContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} tree::TerminalNode *ANTLRv4Parser::RuleActionContext::AT() { return getToken(ANTLRv4Parser::AT, 0); } ANTLRv4Parser::IdentifierContext * ANTLRv4Parser::RuleActionContext::identifier() { return getRuleContext(0); } ANTLRv4Parser::ActionBlockContext * ANTLRv4Parser::RuleActionContext::actionBlock() { return getRuleContext(0); } size_t ANTLRv4Parser::RuleActionContext::getRuleIndex() const { return ANTLRv4Parser::RuleRuleAction; } void ANTLRv4Parser::RuleActionContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterRuleAction(this); } void ANTLRv4Parser::RuleActionContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitRuleAction(this); } ANTLRv4Parser::RuleActionContext *ANTLRv4Parser::ruleAction() { RuleActionContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 54, ANTLRv4Parser::RuleRuleAction); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(344); match(ANTLRv4Parser::AT); setState(345); identifier(); setState(346); actionBlock(); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- RuleModifiersContext //------------------------------------------------------------------ ANTLRv4Parser::RuleModifiersContext::RuleModifiersContext( ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} std::vector ANTLRv4Parser::RuleModifiersContext::ruleModifier() { return getRuleContexts(); } ANTLRv4Parser::RuleModifierContext * ANTLRv4Parser::RuleModifiersContext::ruleModifier(size_t i) { return getRuleContext(i); } size_t ANTLRv4Parser::RuleModifiersContext::getRuleIndex() const { return ANTLRv4Parser::RuleRuleModifiers; } void ANTLRv4Parser::RuleModifiersContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterRuleModifiers(this); } void ANTLRv4Parser::RuleModifiersContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitRuleModifiers(this); } ANTLRv4Parser::RuleModifiersContext *ANTLRv4Parser::ruleModifiers() { RuleModifiersContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 56, ANTLRv4Parser::RuleRuleModifiers); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(349); _errHandler->sync(this); _la = _input->LA(1); do { setState(348); ruleModifier(); setState(351); _errHandler->sync(this); _la = _input->LA(1); } while ((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 7405568) != 0)); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- RuleModifierContext //------------------------------------------------------------------ ANTLRv4Parser::RuleModifierContext::RuleModifierContext( ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} tree::TerminalNode *ANTLRv4Parser::RuleModifierContext::PUBLIC() { return getToken(ANTLRv4Parser::PUBLIC, 0); } tree::TerminalNode *ANTLRv4Parser::RuleModifierContext::PRIVATE() { return getToken(ANTLRv4Parser::PRIVATE, 0); } tree::TerminalNode *ANTLRv4Parser::RuleModifierContext::PROTECTED() { return getToken(ANTLRv4Parser::PROTECTED, 0); } tree::TerminalNode *ANTLRv4Parser::RuleModifierContext::FRAGMENT() { return getToken(ANTLRv4Parser::FRAGMENT, 0); } size_t ANTLRv4Parser::RuleModifierContext::getRuleIndex() const { return ANTLRv4Parser::RuleRuleModifier; } void ANTLRv4Parser::RuleModifierContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterRuleModifier(this); } void ANTLRv4Parser::RuleModifierContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitRuleModifier(this); } ANTLRv4Parser::RuleModifierContext *ANTLRv4Parser::ruleModifier() { RuleModifierContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 58, ANTLRv4Parser::RuleRuleModifier); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(353); _la = _input->LA(1); if (!((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 7405568) != 0))) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- RuleBlockContext //------------------------------------------------------------------ ANTLRv4Parser::RuleBlockContext::RuleBlockContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} ANTLRv4Parser::RuleAltListContext * ANTLRv4Parser::RuleBlockContext::ruleAltList() { return getRuleContext(0); } size_t ANTLRv4Parser::RuleBlockContext::getRuleIndex() const { return ANTLRv4Parser::RuleRuleBlock; } void ANTLRv4Parser::RuleBlockContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterRuleBlock(this); } void ANTLRv4Parser::RuleBlockContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitRuleBlock(this); } ANTLRv4Parser::RuleBlockContext *ANTLRv4Parser::ruleBlock() { RuleBlockContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 60, ANTLRv4Parser::RuleRuleBlock); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(355); ruleAltList(); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- RuleAltListContext //------------------------------------------------------------------ ANTLRv4Parser::RuleAltListContext::RuleAltListContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} std::vector ANTLRv4Parser::RuleAltListContext::labeledAlt() { return getRuleContexts(); } ANTLRv4Parser::LabeledAltContext *ANTLRv4Parser::RuleAltListContext::labeledAlt( size_t i) { return getRuleContext(i); } std::vector ANTLRv4Parser::RuleAltListContext::OR() { return getTokens(ANTLRv4Parser::OR); } tree::TerminalNode *ANTLRv4Parser::RuleAltListContext::OR(size_t i) { return getToken(ANTLRv4Parser::OR, i); } size_t ANTLRv4Parser::RuleAltListContext::getRuleIndex() const { return ANTLRv4Parser::RuleRuleAltList; } void ANTLRv4Parser::RuleAltListContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterRuleAltList(this); } void ANTLRv4Parser::RuleAltListContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitRuleAltList(this); } ANTLRv4Parser::RuleAltListContext *ANTLRv4Parser::ruleAltList() { RuleAltListContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 62, ANTLRv4Parser::RuleRuleAltList); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(357); labeledAlt(); setState(362); _errHandler->sync(this); _la = _input->LA(1); while (_la == ANTLRv4Parser::OR) { setState(358); match(ANTLRv4Parser::OR); setState(359); labeledAlt(); setState(364); _errHandler->sync(this); _la = _input->LA(1); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- LabeledAltContext //------------------------------------------------------------------ ANTLRv4Parser::LabeledAltContext::LabeledAltContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} ANTLRv4Parser::AlternativeContext * ANTLRv4Parser::LabeledAltContext::alternative() { return getRuleContext(0); } tree::TerminalNode *ANTLRv4Parser::LabeledAltContext::POUND() { return getToken(ANTLRv4Parser::POUND, 0); } ANTLRv4Parser::IdentifierContext * ANTLRv4Parser::LabeledAltContext::identifier() { return getRuleContext(0); } size_t ANTLRv4Parser::LabeledAltContext::getRuleIndex() const { return ANTLRv4Parser::RuleLabeledAlt; } void ANTLRv4Parser::LabeledAltContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterLabeledAlt(this); } void ANTLRv4Parser::LabeledAltContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitLabeledAlt(this); } ANTLRv4Parser::LabeledAltContext *ANTLRv4Parser::labeledAlt() { LabeledAltContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 64, ANTLRv4Parser::RuleLabeledAlt); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(365); alternative(); setState(368); _errHandler->sync(this); _la = _input->LA(1); if (_la == ANTLRv4Parser::POUND) { setState(366); match(ANTLRv4Parser::POUND); setState(367); identifier(); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- LexerRuleSpecContext //------------------------------------------------------------------ ANTLRv4Parser::LexerRuleSpecContext::LexerRuleSpecContext( ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} tree::TerminalNode *ANTLRv4Parser::LexerRuleSpecContext::TOKEN_REF() { return getToken(ANTLRv4Parser::TOKEN_REF, 0); } tree::TerminalNode *ANTLRv4Parser::LexerRuleSpecContext::COLON() { return getToken(ANTLRv4Parser::COLON, 0); } ANTLRv4Parser::LexerRuleBlockContext * ANTLRv4Parser::LexerRuleSpecContext::lexerRuleBlock() { return getRuleContext(0); } tree::TerminalNode *ANTLRv4Parser::LexerRuleSpecContext::SEMI() { return getToken(ANTLRv4Parser::SEMI, 0); } tree::TerminalNode *ANTLRv4Parser::LexerRuleSpecContext::FRAGMENT() { return getToken(ANTLRv4Parser::FRAGMENT, 0); } size_t ANTLRv4Parser::LexerRuleSpecContext::getRuleIndex() const { return ANTLRv4Parser::RuleLexerRuleSpec; } void ANTLRv4Parser::LexerRuleSpecContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterLexerRuleSpec(this); } void ANTLRv4Parser::LexerRuleSpecContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitLexerRuleSpec(this); } ANTLRv4Parser::LexerRuleSpecContext *ANTLRv4Parser::lexerRuleSpec() { LexerRuleSpecContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 66, ANTLRv4Parser::RuleLexerRuleSpec); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(371); _errHandler->sync(this); _la = _input->LA(1); if (_la == ANTLRv4Parser::FRAGMENT) { setState(370); match(ANTLRv4Parser::FRAGMENT); } setState(373); match(ANTLRv4Parser::TOKEN_REF); setState(374); match(ANTLRv4Parser::COLON); setState(375); lexerRuleBlock(); setState(376); match(ANTLRv4Parser::SEMI); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- LexerRuleBlockContext //------------------------------------------------------------------ ANTLRv4Parser::LexerRuleBlockContext::LexerRuleBlockContext( ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} ANTLRv4Parser::LexerAltListContext * ANTLRv4Parser::LexerRuleBlockContext::lexerAltList() { return getRuleContext(0); } size_t ANTLRv4Parser::LexerRuleBlockContext::getRuleIndex() const { return ANTLRv4Parser::RuleLexerRuleBlock; } void ANTLRv4Parser::LexerRuleBlockContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterLexerRuleBlock(this); } void ANTLRv4Parser::LexerRuleBlockContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitLexerRuleBlock(this); } ANTLRv4Parser::LexerRuleBlockContext *ANTLRv4Parser::lexerRuleBlock() { LexerRuleBlockContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 68, ANTLRv4Parser::RuleLexerRuleBlock); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(378); lexerAltList(); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- LexerAltListContext //------------------------------------------------------------------ ANTLRv4Parser::LexerAltListContext::LexerAltListContext( ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} std::vector ANTLRv4Parser::LexerAltListContext::lexerAlt() { return getRuleContexts(); } ANTLRv4Parser::LexerAltContext *ANTLRv4Parser::LexerAltListContext::lexerAlt( size_t i) { return getRuleContext(i); } std::vector ANTLRv4Parser::LexerAltListContext::OR() { return getTokens(ANTLRv4Parser::OR); } tree::TerminalNode *ANTLRv4Parser::LexerAltListContext::OR(size_t i) { return getToken(ANTLRv4Parser::OR, i); } size_t ANTLRv4Parser::LexerAltListContext::getRuleIndex() const { return ANTLRv4Parser::RuleLexerAltList; } void ANTLRv4Parser::LexerAltListContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterLexerAltList(this); } void ANTLRv4Parser::LexerAltListContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitLexerAltList(this); } ANTLRv4Parser::LexerAltListContext *ANTLRv4Parser::lexerAltList() { LexerAltListContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 70, ANTLRv4Parser::RuleLexerAltList); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(380); lexerAlt(); setState(385); _errHandler->sync(this); _la = _input->LA(1); while (_la == ANTLRv4Parser::OR) { setState(381); match(ANTLRv4Parser::OR); setState(382); lexerAlt(); setState(387); _errHandler->sync(this); _la = _input->LA(1); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- LexerAltContext //------------------------------------------------------------------ ANTLRv4Parser::LexerAltContext::LexerAltContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} ANTLRv4Parser::LexerElementsContext * ANTLRv4Parser::LexerAltContext::lexerElements() { return getRuleContext(0); } ANTLRv4Parser::LexerCommandsContext * ANTLRv4Parser::LexerAltContext::lexerCommands() { return getRuleContext(0); } size_t ANTLRv4Parser::LexerAltContext::getRuleIndex() const { return ANTLRv4Parser::RuleLexerAlt; } void ANTLRv4Parser::LexerAltContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterLexerAlt(this); } void ANTLRv4Parser::LexerAltContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitLexerAlt(this); } ANTLRv4Parser::LexerAltContext *ANTLRv4Parser::lexerAlt() { LexerAltContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 72, ANTLRv4Parser::RuleLexerAlt); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(393); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict( _input, 36, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); setState(388); lexerElements(); setState(390); _errHandler->sync(this); _la = _input->LA(1); if (_la == ANTLRv4Parser::RARROW) { setState(389); lexerCommands(); } break; } case 2: { enterOuterAlt(_localctx, 2); break; } default: break; } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- LexerElementsContext //------------------------------------------------------------------ ANTLRv4Parser::LexerElementsContext::LexerElementsContext( ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} std::vector ANTLRv4Parser::LexerElementsContext::lexerElement() { return getRuleContexts(); } ANTLRv4Parser::LexerElementContext * ANTLRv4Parser::LexerElementsContext::lexerElement(size_t i) { return getRuleContext(i); } size_t ANTLRv4Parser::LexerElementsContext::getRuleIndex() const { return ANTLRv4Parser::RuleLexerElements; } void ANTLRv4Parser::LexerElementsContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterLexerElements(this); } void ANTLRv4Parser::LexerElementsContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitLexerElements(this); } ANTLRv4Parser::LexerElementsContext *ANTLRv4Parser::lexerElements() { LexerElementsContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 74, ANTLRv4Parser::RuleLexerElements); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(401); _errHandler->sync(this); switch (_input->LA(1)) { case ANTLRv4Parser::TOKEN_REF: case ANTLRv4Parser::RULE_REF: case ANTLRv4Parser::LEXER_CHAR_SET: case ANTLRv4Parser::STRING_LITERAL: case ANTLRv4Parser::BEGIN_ACTION: case ANTLRv4Parser::LPAREN: case ANTLRv4Parser::DOT: case ANTLRv4Parser::NOT: { enterOuterAlt(_localctx, 1); setState(396); _errHandler->sync(this); _la = _input->LA(1); do { setState(395); lexerElement(); setState(398); _errHandler->sync(this); _la = _input->LA(1); } while ((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 2533283380332814) != 0)); break; } case ANTLRv4Parser::SEMI: case ANTLRv4Parser::RPAREN: case ANTLRv4Parser::RARROW: case ANTLRv4Parser::OR: { enterOuterAlt(_localctx, 2); break; } default: throw NoViableAltException(this); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- LexerElementContext //------------------------------------------------------------------ ANTLRv4Parser::LexerElementContext::LexerElementContext( ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} ANTLRv4Parser::LabeledLexerElementContext * ANTLRv4Parser::LexerElementContext::labeledLexerElement() { return getRuleContext(0); } ANTLRv4Parser::EbnfSuffixContext * ANTLRv4Parser::LexerElementContext::ebnfSuffix() { return getRuleContext(0); } ANTLRv4Parser::LexerAtomContext * ANTLRv4Parser::LexerElementContext::lexerAtom() { return getRuleContext(0); } ANTLRv4Parser::LexerBlockContext * ANTLRv4Parser::LexerElementContext::lexerBlock() { return getRuleContext(0); } ANTLRv4Parser::ActionBlockContext * ANTLRv4Parser::LexerElementContext::actionBlock() { return getRuleContext(0); } tree::TerminalNode *ANTLRv4Parser::LexerElementContext::QUESTION() { return getToken(ANTLRv4Parser::QUESTION, 0); } size_t ANTLRv4Parser::LexerElementContext::getRuleIndex() const { return ANTLRv4Parser::RuleLexerElement; } void ANTLRv4Parser::LexerElementContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterLexerElement(this); } void ANTLRv4Parser::LexerElementContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitLexerElement(this); } ANTLRv4Parser::LexerElementContext *ANTLRv4Parser::lexerElement() { LexerElementContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 76, ANTLRv4Parser::RuleLexerElement); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(419); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict( _input, 43, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); setState(403); labeledLexerElement(); setState(405); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 24189255811072) != 0)) { setState(404); ebnfSuffix(); } break; } case 2: { enterOuterAlt(_localctx, 2); setState(407); lexerAtom(); setState(409); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 24189255811072) != 0)) { setState(408); ebnfSuffix(); } break; } case 3: { enterOuterAlt(_localctx, 3); setState(411); lexerBlock(); setState(413); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 24189255811072) != 0)) { setState(412); ebnfSuffix(); } break; } case 4: { enterOuterAlt(_localctx, 4); setState(415); actionBlock(); setState(417); _errHandler->sync(this); _la = _input->LA(1); if (_la == ANTLRv4Parser::QUESTION) { setState(416); match(ANTLRv4Parser::QUESTION); } break; } default: break; } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- LabeledLexerElementContext //------------------------------------------------------------------ ANTLRv4Parser::LabeledLexerElementContext::LabeledLexerElementContext( ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} ANTLRv4Parser::IdentifierContext * ANTLRv4Parser::LabeledLexerElementContext::identifier() { return getRuleContext(0); } tree::TerminalNode *ANTLRv4Parser::LabeledLexerElementContext::ASSIGN() { return getToken(ANTLRv4Parser::ASSIGN, 0); } tree::TerminalNode *ANTLRv4Parser::LabeledLexerElementContext::PLUS_ASSIGN() { return getToken(ANTLRv4Parser::PLUS_ASSIGN, 0); } ANTLRv4Parser::LexerAtomContext * ANTLRv4Parser::LabeledLexerElementContext::lexerAtom() { return getRuleContext(0); } ANTLRv4Parser::LexerBlockContext * ANTLRv4Parser::LabeledLexerElementContext::lexerBlock() { return getRuleContext(0); } size_t ANTLRv4Parser::LabeledLexerElementContext::getRuleIndex() const { return ANTLRv4Parser::RuleLabeledLexerElement; } void ANTLRv4Parser::LabeledLexerElementContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterLabeledLexerElement(this); } void ANTLRv4Parser::LabeledLexerElementContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitLabeledLexerElement(this); } ANTLRv4Parser::LabeledLexerElementContext * ANTLRv4Parser::labeledLexerElement() { LabeledLexerElementContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 78, ANTLRv4Parser::RuleLabeledLexerElement); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(421); identifier(); setState(422); _la = _input->LA(1); if (!(_la == ANTLRv4Parser::ASSIGN || _la == ANTLRv4Parser::PLUS_ASSIGN)) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } setState(425); _errHandler->sync(this); switch (_input->LA(1)) { case ANTLRv4Parser::TOKEN_REF: case ANTLRv4Parser::LEXER_CHAR_SET: case ANTLRv4Parser::STRING_LITERAL: case ANTLRv4Parser::DOT: case ANTLRv4Parser::NOT: { setState(423); lexerAtom(); break; } case ANTLRv4Parser::LPAREN: { setState(424); lexerBlock(); break; } default: throw NoViableAltException(this); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- LexerBlockContext //------------------------------------------------------------------ ANTLRv4Parser::LexerBlockContext::LexerBlockContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} tree::TerminalNode *ANTLRv4Parser::LexerBlockContext::LPAREN() { return getToken(ANTLRv4Parser::LPAREN, 0); } ANTLRv4Parser::LexerAltListContext * ANTLRv4Parser::LexerBlockContext::lexerAltList() { return getRuleContext(0); } tree::TerminalNode *ANTLRv4Parser::LexerBlockContext::RPAREN() { return getToken(ANTLRv4Parser::RPAREN, 0); } size_t ANTLRv4Parser::LexerBlockContext::getRuleIndex() const { return ANTLRv4Parser::RuleLexerBlock; } void ANTLRv4Parser::LexerBlockContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterLexerBlock(this); } void ANTLRv4Parser::LexerBlockContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitLexerBlock(this); } ANTLRv4Parser::LexerBlockContext *ANTLRv4Parser::lexerBlock() { LexerBlockContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 80, ANTLRv4Parser::RuleLexerBlock); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(427); match(ANTLRv4Parser::LPAREN); setState(428); lexerAltList(); setState(429); match(ANTLRv4Parser::RPAREN); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- LexerCommandsContext //------------------------------------------------------------------ ANTLRv4Parser::LexerCommandsContext::LexerCommandsContext( ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} tree::TerminalNode *ANTLRv4Parser::LexerCommandsContext::RARROW() { return getToken(ANTLRv4Parser::RARROW, 0); } std::vector ANTLRv4Parser::LexerCommandsContext::lexerCommand() { return getRuleContexts(); } ANTLRv4Parser::LexerCommandContext * ANTLRv4Parser::LexerCommandsContext::lexerCommand(size_t i) { return getRuleContext(i); } std::vector ANTLRv4Parser::LexerCommandsContext::COMMA() { return getTokens(ANTLRv4Parser::COMMA); } tree::TerminalNode *ANTLRv4Parser::LexerCommandsContext::COMMA(size_t i) { return getToken(ANTLRv4Parser::COMMA, i); } size_t ANTLRv4Parser::LexerCommandsContext::getRuleIndex() const { return ANTLRv4Parser::RuleLexerCommands; } void ANTLRv4Parser::LexerCommandsContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterLexerCommands(this); } void ANTLRv4Parser::LexerCommandsContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitLexerCommands(this); } ANTLRv4Parser::LexerCommandsContext *ANTLRv4Parser::lexerCommands() { LexerCommandsContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 82, ANTLRv4Parser::RuleLexerCommands); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(431); match(ANTLRv4Parser::RARROW); setState(432); lexerCommand(); setState(437); _errHandler->sync(this); _la = _input->LA(1); while (_la == ANTLRv4Parser::COMMA) { setState(433); match(ANTLRv4Parser::COMMA); setState(434); lexerCommand(); setState(439); _errHandler->sync(this); _la = _input->LA(1); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- LexerCommandContext //------------------------------------------------------------------ ANTLRv4Parser::LexerCommandContext::LexerCommandContext( ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} ANTLRv4Parser::LexerCommandNameContext * ANTLRv4Parser::LexerCommandContext::lexerCommandName() { return getRuleContext(0); } tree::TerminalNode *ANTLRv4Parser::LexerCommandContext::LPAREN() { return getToken(ANTLRv4Parser::LPAREN, 0); } ANTLRv4Parser::LexerCommandExprContext * ANTLRv4Parser::LexerCommandContext::lexerCommandExpr() { return getRuleContext(0); } tree::TerminalNode *ANTLRv4Parser::LexerCommandContext::RPAREN() { return getToken(ANTLRv4Parser::RPAREN, 0); } size_t ANTLRv4Parser::LexerCommandContext::getRuleIndex() const { return ANTLRv4Parser::RuleLexerCommand; } void ANTLRv4Parser::LexerCommandContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterLexerCommand(this); } void ANTLRv4Parser::LexerCommandContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitLexerCommand(this); } ANTLRv4Parser::LexerCommandContext *ANTLRv4Parser::lexerCommand() { LexerCommandContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 84, ANTLRv4Parser::RuleLexerCommand); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(446); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict( _input, 46, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); setState(440); lexerCommandName(); setState(441); match(ANTLRv4Parser::LPAREN); setState(442); lexerCommandExpr(); setState(443); match(ANTLRv4Parser::RPAREN); break; } case 2: { enterOuterAlt(_localctx, 2); setState(445); lexerCommandName(); break; } default: break; } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- LexerCommandNameContext //------------------------------------------------------------------ ANTLRv4Parser::LexerCommandNameContext::LexerCommandNameContext( ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} ANTLRv4Parser::IdentifierContext * ANTLRv4Parser::LexerCommandNameContext::identifier() { return getRuleContext(0); } tree::TerminalNode *ANTLRv4Parser::LexerCommandNameContext::MODE() { return getToken(ANTLRv4Parser::MODE, 0); } size_t ANTLRv4Parser::LexerCommandNameContext::getRuleIndex() const { return ANTLRv4Parser::RuleLexerCommandName; } void ANTLRv4Parser::LexerCommandNameContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterLexerCommandName(this); } void ANTLRv4Parser::LexerCommandNameContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitLexerCommandName(this); } ANTLRv4Parser::LexerCommandNameContext *ANTLRv4Parser::lexerCommandName() { LexerCommandNameContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 86, ANTLRv4Parser::RuleLexerCommandName); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(450); _errHandler->sync(this); switch (_input->LA(1)) { case ANTLRv4Parser::TOKEN_REF: case ANTLRv4Parser::RULE_REF: { enterOuterAlt(_localctx, 1); setState(448); identifier(); break; } case ANTLRv4Parser::MODE: { enterOuterAlt(_localctx, 2); setState(449); match(ANTLRv4Parser::MODE); break; } default: throw NoViableAltException(this); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- LexerCommandExprContext //------------------------------------------------------------------ ANTLRv4Parser::LexerCommandExprContext::LexerCommandExprContext( ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} ANTLRv4Parser::IdentifierContext * ANTLRv4Parser::LexerCommandExprContext::identifier() { return getRuleContext(0); } tree::TerminalNode *ANTLRv4Parser::LexerCommandExprContext::INT() { return getToken(ANTLRv4Parser::INT, 0); } size_t ANTLRv4Parser::LexerCommandExprContext::getRuleIndex() const { return ANTLRv4Parser::RuleLexerCommandExpr; } void ANTLRv4Parser::LexerCommandExprContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterLexerCommandExpr(this); } void ANTLRv4Parser::LexerCommandExprContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitLexerCommandExpr(this); } ANTLRv4Parser::LexerCommandExprContext *ANTLRv4Parser::lexerCommandExpr() { LexerCommandExprContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 88, ANTLRv4Parser::RuleLexerCommandExpr); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(454); _errHandler->sync(this); switch (_input->LA(1)) { case ANTLRv4Parser::TOKEN_REF: case ANTLRv4Parser::RULE_REF: { enterOuterAlt(_localctx, 1); setState(452); identifier(); break; } case ANTLRv4Parser::INT: { enterOuterAlt(_localctx, 2); setState(453); match(ANTLRv4Parser::INT); break; } default: throw NoViableAltException(this); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- AltListContext //------------------------------------------------------------------ ANTLRv4Parser::AltListContext::AltListContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} std::vector ANTLRv4Parser::AltListContext::alternative() { return getRuleContexts(); } ANTLRv4Parser::AlternativeContext *ANTLRv4Parser::AltListContext::alternative( size_t i) { return getRuleContext(i); } std::vector ANTLRv4Parser::AltListContext::OR() { return getTokens(ANTLRv4Parser::OR); } tree::TerminalNode *ANTLRv4Parser::AltListContext::OR(size_t i) { return getToken(ANTLRv4Parser::OR, i); } size_t ANTLRv4Parser::AltListContext::getRuleIndex() const { return ANTLRv4Parser::RuleAltList; } void ANTLRv4Parser::AltListContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterAltList(this); } void ANTLRv4Parser::AltListContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitAltList(this); } ANTLRv4Parser::AltListContext *ANTLRv4Parser::altList() { AltListContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 90, ANTLRv4Parser::RuleAltList); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(456); alternative(); setState(461); _errHandler->sync(this); _la = _input->LA(1); while (_la == ANTLRv4Parser::OR) { setState(457); match(ANTLRv4Parser::OR); setState(458); alternative(); setState(463); _errHandler->sync(this); _la = _input->LA(1); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- AlternativeContext //------------------------------------------------------------------ ANTLRv4Parser::AlternativeContext::AlternativeContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} ANTLRv4Parser::ElementOptionsContext * ANTLRv4Parser::AlternativeContext::elementOptions() { return getRuleContext(0); } std::vector ANTLRv4Parser::AlternativeContext::element() { return getRuleContexts(); } ANTLRv4Parser::ElementContext *ANTLRv4Parser::AlternativeContext::element( size_t i) { return getRuleContext(i); } size_t ANTLRv4Parser::AlternativeContext::getRuleIndex() const { return ANTLRv4Parser::RuleAlternative; } void ANTLRv4Parser::AlternativeContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterAlternative(this); } void ANTLRv4Parser::AlternativeContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitAlternative(this); } ANTLRv4Parser::AlternativeContext *ANTLRv4Parser::alternative() { AlternativeContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 92, ANTLRv4Parser::RuleAlternative); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(473); _errHandler->sync(this); switch (_input->LA(1)) { case ANTLRv4Parser::TOKEN_REF: case ANTLRv4Parser::RULE_REF: case ANTLRv4Parser::STRING_LITERAL: case ANTLRv4Parser::BEGIN_ACTION: case ANTLRv4Parser::LPAREN: case ANTLRv4Parser::LT: case ANTLRv4Parser::DOT: case ANTLRv4Parser::NOT: { enterOuterAlt(_localctx, 1); setState(465); _errHandler->sync(this); _la = _input->LA(1); if (_la == ANTLRv4Parser::LT) { setState(464); elementOptions(); } setState(468); _errHandler->sync(this); _la = _input->LA(1); do { setState(467); element(); setState(470); _errHandler->sync(this); _la = _input->LA(1); } while ((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 2533283380332806) != 0)); break; } case ANTLRv4Parser::SEMI: case ANTLRv4Parser::RPAREN: case ANTLRv4Parser::OR: case ANTLRv4Parser::POUND: { enterOuterAlt(_localctx, 2); break; } default: throw NoViableAltException(this); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- ElementContext //------------------------------------------------------------------ ANTLRv4Parser::ElementContext::ElementContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} ANTLRv4Parser::LabeledElementContext * ANTLRv4Parser::ElementContext::labeledElement() { return getRuleContext(0); } ANTLRv4Parser::EbnfSuffixContext *ANTLRv4Parser::ElementContext::ebnfSuffix() { return getRuleContext(0); } ANTLRv4Parser::AtomContext *ANTLRv4Parser::ElementContext::atom() { return getRuleContext(0); } ANTLRv4Parser::EbnfContext *ANTLRv4Parser::ElementContext::ebnf() { return getRuleContext(0); } ANTLRv4Parser::ActionBlockContext * ANTLRv4Parser::ElementContext::actionBlock() { return getRuleContext(0); } tree::TerminalNode *ANTLRv4Parser::ElementContext::QUESTION() { return getToken(ANTLRv4Parser::QUESTION, 0); } size_t ANTLRv4Parser::ElementContext::getRuleIndex() const { return ANTLRv4Parser::RuleElement; } void ANTLRv4Parser::ElementContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterElement(this); } void ANTLRv4Parser::ElementContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitElement(this); } ANTLRv4Parser::ElementContext *ANTLRv4Parser::element() { ElementContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 94, ANTLRv4Parser::RuleElement); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(490); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict( _input, 56, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); setState(475); labeledElement(); setState(478); _errHandler->sync(this); switch (_input->LA(1)) { case ANTLRv4Parser::QUESTION: case ANTLRv4Parser::STAR: case ANTLRv4Parser::PLUS: { setState(476); ebnfSuffix(); break; } case ANTLRv4Parser::TOKEN_REF: case ANTLRv4Parser::RULE_REF: case ANTLRv4Parser::STRING_LITERAL: case ANTLRv4Parser::BEGIN_ACTION: case ANTLRv4Parser::SEMI: case ANTLRv4Parser::LPAREN: case ANTLRv4Parser::RPAREN: case ANTLRv4Parser::OR: case ANTLRv4Parser::DOT: case ANTLRv4Parser::POUND: case ANTLRv4Parser::NOT: { break; } default: throw NoViableAltException(this); } break; } case 2: { enterOuterAlt(_localctx, 2); setState(480); atom(); setState(483); _errHandler->sync(this); switch (_input->LA(1)) { case ANTLRv4Parser::QUESTION: case ANTLRv4Parser::STAR: case ANTLRv4Parser::PLUS: { setState(481); ebnfSuffix(); break; } case ANTLRv4Parser::TOKEN_REF: case ANTLRv4Parser::RULE_REF: case ANTLRv4Parser::STRING_LITERAL: case ANTLRv4Parser::BEGIN_ACTION: case ANTLRv4Parser::SEMI: case ANTLRv4Parser::LPAREN: case ANTLRv4Parser::RPAREN: case ANTLRv4Parser::OR: case ANTLRv4Parser::DOT: case ANTLRv4Parser::POUND: case ANTLRv4Parser::NOT: { break; } default: throw NoViableAltException(this); } break; } case 3: { enterOuterAlt(_localctx, 3); setState(485); ebnf(); break; } case 4: { enterOuterAlt(_localctx, 4); setState(486); actionBlock(); setState(488); _errHandler->sync(this); _la = _input->LA(1); if (_la == ANTLRv4Parser::QUESTION) { setState(487); match(ANTLRv4Parser::QUESTION); } break; } default: break; } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- LabeledElementContext //------------------------------------------------------------------ ANTLRv4Parser::LabeledElementContext::LabeledElementContext( ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} ANTLRv4Parser::IdentifierContext * ANTLRv4Parser::LabeledElementContext::identifier() { return getRuleContext(0); } tree::TerminalNode *ANTLRv4Parser::LabeledElementContext::ASSIGN() { return getToken(ANTLRv4Parser::ASSIGN, 0); } tree::TerminalNode *ANTLRv4Parser::LabeledElementContext::PLUS_ASSIGN() { return getToken(ANTLRv4Parser::PLUS_ASSIGN, 0); } ANTLRv4Parser::AtomContext *ANTLRv4Parser::LabeledElementContext::atom() { return getRuleContext(0); } ANTLRv4Parser::BlockContext *ANTLRv4Parser::LabeledElementContext::block() { return getRuleContext(0); } size_t ANTLRv4Parser::LabeledElementContext::getRuleIndex() const { return ANTLRv4Parser::RuleLabeledElement; } void ANTLRv4Parser::LabeledElementContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterLabeledElement(this); } void ANTLRv4Parser::LabeledElementContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitLabeledElement(this); } ANTLRv4Parser::LabeledElementContext *ANTLRv4Parser::labeledElement() { LabeledElementContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 96, ANTLRv4Parser::RuleLabeledElement); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(492); identifier(); setState(493); _la = _input->LA(1); if (!(_la == ANTLRv4Parser::ASSIGN || _la == ANTLRv4Parser::PLUS_ASSIGN)) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } setState(496); _errHandler->sync(this); switch (_input->LA(1)) { case ANTLRv4Parser::TOKEN_REF: case ANTLRv4Parser::RULE_REF: case ANTLRv4Parser::STRING_LITERAL: case ANTLRv4Parser::DOT: case ANTLRv4Parser::NOT: { setState(494); atom(); break; } case ANTLRv4Parser::LPAREN: { setState(495); block(); break; } default: throw NoViableAltException(this); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- EbnfContext //------------------------------------------------------------------ ANTLRv4Parser::EbnfContext::EbnfContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} ANTLRv4Parser::BlockContext *ANTLRv4Parser::EbnfContext::block() { return getRuleContext(0); } ANTLRv4Parser::BlockSuffixContext *ANTLRv4Parser::EbnfContext::blockSuffix() { return getRuleContext(0); } size_t ANTLRv4Parser::EbnfContext::getRuleIndex() const { return ANTLRv4Parser::RuleEbnf; } void ANTLRv4Parser::EbnfContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterEbnf(this); } void ANTLRv4Parser::EbnfContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitEbnf(this); } ANTLRv4Parser::EbnfContext *ANTLRv4Parser::ebnf() { EbnfContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 98, ANTLRv4Parser::RuleEbnf); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(498); block(); setState(500); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 24189255811072) != 0)) { setState(499); blockSuffix(); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- BlockSuffixContext //------------------------------------------------------------------ ANTLRv4Parser::BlockSuffixContext::BlockSuffixContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} ANTLRv4Parser::EbnfSuffixContext * ANTLRv4Parser::BlockSuffixContext::ebnfSuffix() { return getRuleContext(0); } size_t ANTLRv4Parser::BlockSuffixContext::getRuleIndex() const { return ANTLRv4Parser::RuleBlockSuffix; } void ANTLRv4Parser::BlockSuffixContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterBlockSuffix(this); } void ANTLRv4Parser::BlockSuffixContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitBlockSuffix(this); } ANTLRv4Parser::BlockSuffixContext *ANTLRv4Parser::blockSuffix() { BlockSuffixContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 100, ANTLRv4Parser::RuleBlockSuffix); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(502); ebnfSuffix(); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- EbnfSuffixContext //------------------------------------------------------------------ ANTLRv4Parser::EbnfSuffixContext::EbnfSuffixContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} std::vector ANTLRv4Parser::EbnfSuffixContext::QUESTION() { return getTokens(ANTLRv4Parser::QUESTION); } tree::TerminalNode *ANTLRv4Parser::EbnfSuffixContext::QUESTION(size_t i) { return getToken(ANTLRv4Parser::QUESTION, i); } tree::TerminalNode *ANTLRv4Parser::EbnfSuffixContext::STAR() { return getToken(ANTLRv4Parser::STAR, 0); } tree::TerminalNode *ANTLRv4Parser::EbnfSuffixContext::PLUS() { return getToken(ANTLRv4Parser::PLUS, 0); } size_t ANTLRv4Parser::EbnfSuffixContext::getRuleIndex() const { return ANTLRv4Parser::RuleEbnfSuffix; } void ANTLRv4Parser::EbnfSuffixContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterEbnfSuffix(this); } void ANTLRv4Parser::EbnfSuffixContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitEbnfSuffix(this); } ANTLRv4Parser::EbnfSuffixContext *ANTLRv4Parser::ebnfSuffix() { EbnfSuffixContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 102, ANTLRv4Parser::RuleEbnfSuffix); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(516); _errHandler->sync(this); switch (_input->LA(1)) { case ANTLRv4Parser::QUESTION: { enterOuterAlt(_localctx, 1); setState(504); match(ANTLRv4Parser::QUESTION); setState(506); _errHandler->sync(this); _la = _input->LA(1); if (_la == ANTLRv4Parser::QUESTION) { setState(505); match(ANTLRv4Parser::QUESTION); } break; } case ANTLRv4Parser::STAR: { enterOuterAlt(_localctx, 2); setState(508); match(ANTLRv4Parser::STAR); setState(510); _errHandler->sync(this); _la = _input->LA(1); if (_la == ANTLRv4Parser::QUESTION) { setState(509); match(ANTLRv4Parser::QUESTION); } break; } case ANTLRv4Parser::PLUS: { enterOuterAlt(_localctx, 3); setState(512); match(ANTLRv4Parser::PLUS); setState(514); _errHandler->sync(this); _la = _input->LA(1); if (_la == ANTLRv4Parser::QUESTION) { setState(513); match(ANTLRv4Parser::QUESTION); } break; } default: throw NoViableAltException(this); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- LexerAtomContext //------------------------------------------------------------------ ANTLRv4Parser::LexerAtomContext::LexerAtomContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} ANTLRv4Parser::CharacterRangeContext * ANTLRv4Parser::LexerAtomContext::characterRange() { return getRuleContext(0); } ANTLRv4Parser::TerminalContext *ANTLRv4Parser::LexerAtomContext::terminal() { return getRuleContext(0); } ANTLRv4Parser::NotSetContext *ANTLRv4Parser::LexerAtomContext::notSet() { return getRuleContext(0); } tree::TerminalNode *ANTLRv4Parser::LexerAtomContext::LEXER_CHAR_SET() { return getToken(ANTLRv4Parser::LEXER_CHAR_SET, 0); } tree::TerminalNode *ANTLRv4Parser::LexerAtomContext::DOT() { return getToken(ANTLRv4Parser::DOT, 0); } ANTLRv4Parser::ElementOptionsContext * ANTLRv4Parser::LexerAtomContext::elementOptions() { return getRuleContext(0); } size_t ANTLRv4Parser::LexerAtomContext::getRuleIndex() const { return ANTLRv4Parser::RuleLexerAtom; } void ANTLRv4Parser::LexerAtomContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterLexerAtom(this); } void ANTLRv4Parser::LexerAtomContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitLexerAtom(this); } ANTLRv4Parser::LexerAtomContext *ANTLRv4Parser::lexerAtom() { LexerAtomContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 104, ANTLRv4Parser::RuleLexerAtom); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(526); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict( _input, 64, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); setState(518); characterRange(); break; } case 2: { enterOuterAlt(_localctx, 2); setState(519); terminal(); break; } case 3: { enterOuterAlt(_localctx, 3); setState(520); notSet(); break; } case 4: { enterOuterAlt(_localctx, 4); setState(521); match(ANTLRv4Parser::LEXER_CHAR_SET); break; } case 5: { enterOuterAlt(_localctx, 5); setState(522); match(ANTLRv4Parser::DOT); setState(524); _errHandler->sync(this); _la = _input->LA(1); if (_la == ANTLRv4Parser::LT) { setState(523); elementOptions(); } break; } default: break; } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- AtomContext //------------------------------------------------------------------ ANTLRv4Parser::AtomContext::AtomContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} ANTLRv4Parser::TerminalContext *ANTLRv4Parser::AtomContext::terminal() { return getRuleContext(0); } ANTLRv4Parser::RulerefContext *ANTLRv4Parser::AtomContext::ruleref() { return getRuleContext(0); } ANTLRv4Parser::NotSetContext *ANTLRv4Parser::AtomContext::notSet() { return getRuleContext(0); } tree::TerminalNode *ANTLRv4Parser::AtomContext::DOT() { return getToken(ANTLRv4Parser::DOT, 0); } ANTLRv4Parser::ElementOptionsContext * ANTLRv4Parser::AtomContext::elementOptions() { return getRuleContext(0); } size_t ANTLRv4Parser::AtomContext::getRuleIndex() const { return ANTLRv4Parser::RuleAtom; } void ANTLRv4Parser::AtomContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterAtom(this); } void ANTLRv4Parser::AtomContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitAtom(this); } ANTLRv4Parser::AtomContext *ANTLRv4Parser::atom() { AtomContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 106, ANTLRv4Parser::RuleAtom); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(535); _errHandler->sync(this); switch (_input->LA(1)) { case ANTLRv4Parser::TOKEN_REF: case ANTLRv4Parser::STRING_LITERAL: { enterOuterAlt(_localctx, 1); setState(528); terminal(); break; } case ANTLRv4Parser::RULE_REF: { enterOuterAlt(_localctx, 2); setState(529); ruleref(); break; } case ANTLRv4Parser::NOT: { enterOuterAlt(_localctx, 3); setState(530); notSet(); break; } case ANTLRv4Parser::DOT: { enterOuterAlt(_localctx, 4); setState(531); match(ANTLRv4Parser::DOT); setState(533); _errHandler->sync(this); _la = _input->LA(1); if (_la == ANTLRv4Parser::LT) { setState(532); elementOptions(); } break; } default: throw NoViableAltException(this); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- NotSetContext //------------------------------------------------------------------ ANTLRv4Parser::NotSetContext::NotSetContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} tree::TerminalNode *ANTLRv4Parser::NotSetContext::NOT() { return getToken(ANTLRv4Parser::NOT, 0); } ANTLRv4Parser::SetElementContext *ANTLRv4Parser::NotSetContext::setElement() { return getRuleContext(0); } ANTLRv4Parser::BlockSetContext *ANTLRv4Parser::NotSetContext::blockSet() { return getRuleContext(0); } size_t ANTLRv4Parser::NotSetContext::getRuleIndex() const { return ANTLRv4Parser::RuleNotSet; } void ANTLRv4Parser::NotSetContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterNotSet(this); } void ANTLRv4Parser::NotSetContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitNotSet(this); } ANTLRv4Parser::NotSetContext *ANTLRv4Parser::notSet() { NotSetContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 108, ANTLRv4Parser::RuleNotSet); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(541); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict( _input, 67, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); setState(537); match(ANTLRv4Parser::NOT); setState(538); setElement(); break; } case 2: { enterOuterAlt(_localctx, 2); setState(539); match(ANTLRv4Parser::NOT); setState(540); blockSet(); break; } default: break; } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- BlockSetContext //------------------------------------------------------------------ ANTLRv4Parser::BlockSetContext::BlockSetContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} tree::TerminalNode *ANTLRv4Parser::BlockSetContext::LPAREN() { return getToken(ANTLRv4Parser::LPAREN, 0); } std::vector ANTLRv4Parser::BlockSetContext::setElement() { return getRuleContexts(); } ANTLRv4Parser::SetElementContext *ANTLRv4Parser::BlockSetContext::setElement( size_t i) { return getRuleContext(i); } tree::TerminalNode *ANTLRv4Parser::BlockSetContext::RPAREN() { return getToken(ANTLRv4Parser::RPAREN, 0); } std::vector ANTLRv4Parser::BlockSetContext::OR() { return getTokens(ANTLRv4Parser::OR); } tree::TerminalNode *ANTLRv4Parser::BlockSetContext::OR(size_t i) { return getToken(ANTLRv4Parser::OR, i); } size_t ANTLRv4Parser::BlockSetContext::getRuleIndex() const { return ANTLRv4Parser::RuleBlockSet; } void ANTLRv4Parser::BlockSetContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterBlockSet(this); } void ANTLRv4Parser::BlockSetContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitBlockSet(this); } ANTLRv4Parser::BlockSetContext *ANTLRv4Parser::blockSet() { BlockSetContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 110, ANTLRv4Parser::RuleBlockSet); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(543); match(ANTLRv4Parser::LPAREN); setState(544); setElement(); setState(549); _errHandler->sync(this); _la = _input->LA(1); while (_la == ANTLRv4Parser::OR) { setState(545); match(ANTLRv4Parser::OR); setState(546); setElement(); setState(551); _errHandler->sync(this); _la = _input->LA(1); } setState(552); match(ANTLRv4Parser::RPAREN); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- SetElementContext //------------------------------------------------------------------ ANTLRv4Parser::SetElementContext::SetElementContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} tree::TerminalNode *ANTLRv4Parser::SetElementContext::TOKEN_REF() { return getToken(ANTLRv4Parser::TOKEN_REF, 0); } ANTLRv4Parser::ElementOptionsContext * ANTLRv4Parser::SetElementContext::elementOptions() { return getRuleContext(0); } tree::TerminalNode *ANTLRv4Parser::SetElementContext::STRING_LITERAL() { return getToken(ANTLRv4Parser::STRING_LITERAL, 0); } ANTLRv4Parser::CharacterRangeContext * ANTLRv4Parser::SetElementContext::characterRange() { return getRuleContext(0); } tree::TerminalNode *ANTLRv4Parser::SetElementContext::LEXER_CHAR_SET() { return getToken(ANTLRv4Parser::LEXER_CHAR_SET, 0); } size_t ANTLRv4Parser::SetElementContext::getRuleIndex() const { return ANTLRv4Parser::RuleSetElement; } void ANTLRv4Parser::SetElementContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterSetElement(this); } void ANTLRv4Parser::SetElementContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitSetElement(this); } ANTLRv4Parser::SetElementContext *ANTLRv4Parser::setElement() { SetElementContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 112, ANTLRv4Parser::RuleSetElement); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(564); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict( _input, 71, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); setState(554); match(ANTLRv4Parser::TOKEN_REF); setState(556); _errHandler->sync(this); _la = _input->LA(1); if (_la == ANTLRv4Parser::LT) { setState(555); elementOptions(); } break; } case 2: { enterOuterAlt(_localctx, 2); setState(558); match(ANTLRv4Parser::STRING_LITERAL); setState(560); _errHandler->sync(this); _la = _input->LA(1); if (_la == ANTLRv4Parser::LT) { setState(559); elementOptions(); } break; } case 3: { enterOuterAlt(_localctx, 3); setState(562); characterRange(); break; } case 4: { enterOuterAlt(_localctx, 4); setState(563); match(ANTLRv4Parser::LEXER_CHAR_SET); break; } default: break; } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- BlockContext //------------------------------------------------------------------ ANTLRv4Parser::BlockContext::BlockContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} tree::TerminalNode *ANTLRv4Parser::BlockContext::LPAREN() { return getToken(ANTLRv4Parser::LPAREN, 0); } ANTLRv4Parser::AltListContext *ANTLRv4Parser::BlockContext::altList() { return getRuleContext(0); } tree::TerminalNode *ANTLRv4Parser::BlockContext::RPAREN() { return getToken(ANTLRv4Parser::RPAREN, 0); } tree::TerminalNode *ANTLRv4Parser::BlockContext::COLON() { return getToken(ANTLRv4Parser::COLON, 0); } ANTLRv4Parser::OptionsSpecContext *ANTLRv4Parser::BlockContext::optionsSpec() { return getRuleContext(0); } std::vector ANTLRv4Parser::BlockContext::ruleAction() { return getRuleContexts(); } ANTLRv4Parser::RuleActionContext *ANTLRv4Parser::BlockContext::ruleAction( size_t i) { return getRuleContext(i); } size_t ANTLRv4Parser::BlockContext::getRuleIndex() const { return ANTLRv4Parser::RuleBlock; } void ANTLRv4Parser::BlockContext::enterRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterBlock(this); } void ANTLRv4Parser::BlockContext::exitRule(tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitBlock(this); } ANTLRv4Parser::BlockContext *ANTLRv4Parser::block() { BlockContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 114, ANTLRv4Parser::RuleBlock); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(566); match(ANTLRv4Parser::LPAREN); setState(577); _errHandler->sync(this); _la = _input->LA(1); if ((((_la & ~0x3fULL) == 0) && ((1ULL << _la) & 562950490296320) != 0)) { setState(568); _errHandler->sync(this); _la = _input->LA(1); if (_la == ANTLRv4Parser::OPTIONS) { setState(567); optionsSpec(); } setState(573); _errHandler->sync(this); _la = _input->LA(1); while (_la == ANTLRv4Parser::AT) { setState(570); ruleAction(); setState(575); _errHandler->sync(this); _la = _input->LA(1); } setState(576); match(ANTLRv4Parser::COLON); } setState(579); altList(); setState(580); match(ANTLRv4Parser::RPAREN); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- RulerefContext //------------------------------------------------------------------ ANTLRv4Parser::RulerefContext::RulerefContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} tree::TerminalNode *ANTLRv4Parser::RulerefContext::RULE_REF() { return getToken(ANTLRv4Parser::RULE_REF, 0); } ANTLRv4Parser::ArgActionBlockContext * ANTLRv4Parser::RulerefContext::argActionBlock() { return getRuleContext(0); } ANTLRv4Parser::ElementOptionsContext * ANTLRv4Parser::RulerefContext::elementOptions() { return getRuleContext(0); } size_t ANTLRv4Parser::RulerefContext::getRuleIndex() const { return ANTLRv4Parser::RuleRuleref; } void ANTLRv4Parser::RulerefContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterRuleref(this); } void ANTLRv4Parser::RulerefContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitRuleref(this); } ANTLRv4Parser::RulerefContext *ANTLRv4Parser::ruleref() { RulerefContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 116, ANTLRv4Parser::RuleRuleref); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(582); match(ANTLRv4Parser::RULE_REF); setState(584); _errHandler->sync(this); _la = _input->LA(1); if (_la == ANTLRv4Parser::BEGIN_ARGUMENT) { setState(583); argActionBlock(); } setState(587); _errHandler->sync(this); _la = _input->LA(1); if (_la == ANTLRv4Parser::LT) { setState(586); elementOptions(); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- CharacterRangeContext //------------------------------------------------------------------ ANTLRv4Parser::CharacterRangeContext::CharacterRangeContext( ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} std::vector ANTLRv4Parser::CharacterRangeContext::STRING_LITERAL() { return getTokens(ANTLRv4Parser::STRING_LITERAL); } tree::TerminalNode *ANTLRv4Parser::CharacterRangeContext::STRING_LITERAL( size_t i) { return getToken(ANTLRv4Parser::STRING_LITERAL, i); } tree::TerminalNode *ANTLRv4Parser::CharacterRangeContext::RANGE() { return getToken(ANTLRv4Parser::RANGE, 0); } size_t ANTLRv4Parser::CharacterRangeContext::getRuleIndex() const { return ANTLRv4Parser::RuleCharacterRange; } void ANTLRv4Parser::CharacterRangeContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterCharacterRange(this); } void ANTLRv4Parser::CharacterRangeContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitCharacterRange(this); } ANTLRv4Parser::CharacterRangeContext *ANTLRv4Parser::characterRange() { CharacterRangeContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 118, ANTLRv4Parser::RuleCharacterRange); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(589); match(ANTLRv4Parser::STRING_LITERAL); setState(590); match(ANTLRv4Parser::RANGE); setState(591); match(ANTLRv4Parser::STRING_LITERAL); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- TerminalContext //------------------------------------------------------------------ ANTLRv4Parser::TerminalContext::TerminalContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} tree::TerminalNode *ANTLRv4Parser::TerminalContext::TOKEN_REF() { return getToken(ANTLRv4Parser::TOKEN_REF, 0); } ANTLRv4Parser::ElementOptionsContext * ANTLRv4Parser::TerminalContext::elementOptions() { return getRuleContext(0); } tree::TerminalNode *ANTLRv4Parser::TerminalContext::STRING_LITERAL() { return getToken(ANTLRv4Parser::STRING_LITERAL, 0); } size_t ANTLRv4Parser::TerminalContext::getRuleIndex() const { return ANTLRv4Parser::RuleTerminal; } void ANTLRv4Parser::TerminalContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterTerminal(this); } void ANTLRv4Parser::TerminalContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitTerminal(this); } ANTLRv4Parser::TerminalContext *ANTLRv4Parser::terminal() { TerminalContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 120, ANTLRv4Parser::RuleTerminal); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(601); _errHandler->sync(this); switch (_input->LA(1)) { case ANTLRv4Parser::TOKEN_REF: { enterOuterAlt(_localctx, 1); setState(593); match(ANTLRv4Parser::TOKEN_REF); setState(595); _errHandler->sync(this); _la = _input->LA(1); if (_la == ANTLRv4Parser::LT) { setState(594); elementOptions(); } break; } case ANTLRv4Parser::STRING_LITERAL: { enterOuterAlt(_localctx, 2); setState(597); match(ANTLRv4Parser::STRING_LITERAL); setState(599); _errHandler->sync(this); _la = _input->LA(1); if (_la == ANTLRv4Parser::LT) { setState(598); elementOptions(); } break; } default: throw NoViableAltException(this); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- ElementOptionsContext //------------------------------------------------------------------ ANTLRv4Parser::ElementOptionsContext::ElementOptionsContext( ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} tree::TerminalNode *ANTLRv4Parser::ElementOptionsContext::LT() { return getToken(ANTLRv4Parser::LT, 0); } std::vector ANTLRv4Parser::ElementOptionsContext::elementOption() { return getRuleContexts(); } ANTLRv4Parser::ElementOptionContext * ANTLRv4Parser::ElementOptionsContext::elementOption(size_t i) { return getRuleContext(i); } tree::TerminalNode *ANTLRv4Parser::ElementOptionsContext::GT() { return getToken(ANTLRv4Parser::GT, 0); } std::vector ANTLRv4Parser::ElementOptionsContext::COMMA() { return getTokens(ANTLRv4Parser::COMMA); } tree::TerminalNode *ANTLRv4Parser::ElementOptionsContext::COMMA(size_t i) { return getToken(ANTLRv4Parser::COMMA, i); } size_t ANTLRv4Parser::ElementOptionsContext::getRuleIndex() const { return ANTLRv4Parser::RuleElementOptions; } void ANTLRv4Parser::ElementOptionsContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterElementOptions(this); } void ANTLRv4Parser::ElementOptionsContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitElementOptions(this); } ANTLRv4Parser::ElementOptionsContext *ANTLRv4Parser::elementOptions() { ElementOptionsContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 122, ANTLRv4Parser::RuleElementOptions); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(603); match(ANTLRv4Parser::LT); setState(604); elementOption(); setState(609); _errHandler->sync(this); _la = _input->LA(1); while (_la == ANTLRv4Parser::COMMA) { setState(605); match(ANTLRv4Parser::COMMA); setState(606); elementOption(); setState(611); _errHandler->sync(this); _la = _input->LA(1); } setState(612); match(ANTLRv4Parser::GT); } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- ElementOptionContext //------------------------------------------------------------------ ANTLRv4Parser::ElementOptionContext::ElementOptionContext( ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} std::vector ANTLRv4Parser::ElementOptionContext::identifier() { return getRuleContexts(); } ANTLRv4Parser::IdentifierContext * ANTLRv4Parser::ElementOptionContext::identifier(size_t i) { return getRuleContext(i); } tree::TerminalNode *ANTLRv4Parser::ElementOptionContext::ASSIGN() { return getToken(ANTLRv4Parser::ASSIGN, 0); } tree::TerminalNode *ANTLRv4Parser::ElementOptionContext::STRING_LITERAL() { return getToken(ANTLRv4Parser::STRING_LITERAL, 0); } size_t ANTLRv4Parser::ElementOptionContext::getRuleIndex() const { return ANTLRv4Parser::RuleElementOption; } void ANTLRv4Parser::ElementOptionContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterElementOption(this); } void ANTLRv4Parser::ElementOptionContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitElementOption(this); } ANTLRv4Parser::ElementOptionContext *ANTLRv4Parser::elementOption() { ElementOptionContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 124, ANTLRv4Parser::RuleElementOption); #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { setState(621); _errHandler->sync(this); switch (getInterpreter()->adaptivePredict( _input, 82, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); setState(614); identifier(); break; } case 2: { enterOuterAlt(_localctx, 2); setState(615); identifier(); setState(616); match(ANTLRv4Parser::ASSIGN); setState(619); _errHandler->sync(this); switch (_input->LA(1)) { case ANTLRv4Parser::TOKEN_REF: case ANTLRv4Parser::RULE_REF: { setState(617); identifier(); break; } case ANTLRv4Parser::STRING_LITERAL: { setState(618); match(ANTLRv4Parser::STRING_LITERAL); break; } default: throw NoViableAltException(this); } break; } default: break; } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } //----------------- IdentifierContext //------------------------------------------------------------------ ANTLRv4Parser::IdentifierContext::IdentifierContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) {} tree::TerminalNode *ANTLRv4Parser::IdentifierContext::RULE_REF() { return getToken(ANTLRv4Parser::RULE_REF, 0); } tree::TerminalNode *ANTLRv4Parser::IdentifierContext::TOKEN_REF() { return getToken(ANTLRv4Parser::TOKEN_REF, 0); } size_t ANTLRv4Parser::IdentifierContext::getRuleIndex() const { return ANTLRv4Parser::RuleIdentifier; } void ANTLRv4Parser::IdentifierContext::enterRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->enterIdentifier(this); } void ANTLRv4Parser::IdentifierContext::exitRule( tree::ParseTreeListener *listener) { auto parserListener = dynamic_cast(listener); if (parserListener != nullptr) parserListener->exitIdentifier(this); } ANTLRv4Parser::IdentifierContext *ANTLRv4Parser::identifier() { IdentifierContext *_localctx = _tracker.createInstance(_ctx, getState()); enterRule(_localctx, 126, ANTLRv4Parser::RuleIdentifier); size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { #else auto onExit = finally([=] { #endif exitRule(); }); try { enterOuterAlt(_localctx, 1); setState(623); _la = _input->LA(1); if (!(_la == ANTLRv4Parser::TOKEN_REF || _la == ANTLRv4Parser::RULE_REF)) { _errHandler->recoverInline(this); } else { _errHandler->reportMatch(this); consume(); } } catch (RecognitionException &e) { _errHandler->reportError(this, e); _localctx->exception = std::current_exception(); _errHandler->recover(this, _localctx->exception); } return _localctx; } void ANTLRv4Parser::initialize() { ::antlr4::internal::call_once(antlrv4parserParserOnceFlag, antlrv4parserParserInitialize); }