| // [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<std::string> ruleNames, |
| std::vector<std::string> literalNames, |
| std::vector<std::string> 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<antlr4::dfa::DFA> decisionToDFA; |
| antlr4::atn::PredictionContextCache sharedContextCache; |
| const std::vector<std::string> ruleNames; |
| const std::vector<std::string> literalNames; |
| const std::vector<std::string> symbolicNames; |
| const antlr4::dfa::Vocabulary vocabulary; |
| antlr4::atn::SerializedATNView serializedATN; |
| std::unique_ptr<antlr4::atn::ATN> atn; |
| }; |
| |
| ::antlr4::internal::OnceFlag antlrv4parserParserOnceFlag; |
| ANTLRv4ParserStaticData *antlrv4parserParserStaticData = nullptr; |
| |
| void antlrv4parserParserInitialize() { |
| assert(antlrv4parserParserStaticData == nullptr); |
| auto staticData = std::make_unique<ANTLRv4ParserStaticData>( |
| std::vector<std::string>{"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<std::string>{"", "", "", |
| "", "", "", |
| "", "", "", |
| "", "", "", |
| "", "", "", |
| "'import'", "'fragment'", "'lexer'", |
| "'parser'", "'grammar'", "'protected'", |
| "'public'", "'private'", "'returns'", |
| "'locals'", "'throws'", "'catch'", |
| "'finally'", "'mode'"}, |
| std::vector<std::string>{"", |
| "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<std::string> &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<ANTLRv4Parser::GrammarDeclContext>(0); |
| } |
| |
| ANTLRv4Parser::RulesContext *ANTLRv4Parser::GrammarSpecContext::rules() { |
| return getRuleContext<ANTLRv4Parser::RulesContext>(0); |
| } |
| |
| tree::TerminalNode *ANTLRv4Parser::GrammarSpecContext::EOF() { |
| return getToken(ANTLRv4Parser::EOF, 0); |
| } |
| |
| std::vector<ANTLRv4Parser::PrequelConstructContext *> |
| ANTLRv4Parser::GrammarSpecContext::prequelConstruct() { |
| return getRuleContexts<ANTLRv4Parser::PrequelConstructContext>(); |
| } |
| |
| ANTLRv4Parser::PrequelConstructContext * |
| ANTLRv4Parser::GrammarSpecContext::prequelConstruct(size_t i) { |
| return getRuleContext<ANTLRv4Parser::PrequelConstructContext>(i); |
| } |
| |
| std::vector<ANTLRv4Parser::ModeSpecContext *> |
| ANTLRv4Parser::GrammarSpecContext::modeSpec() { |
| return getRuleContexts<ANTLRv4Parser::ModeSpecContext>(); |
| } |
| |
| ANTLRv4Parser::ModeSpecContext *ANTLRv4Parser::GrammarSpecContext::modeSpec( |
| size_t i) { |
| return getRuleContext<ANTLRv4Parser::ModeSpecContext>(i); |
| } |
| |
| size_t ANTLRv4Parser::GrammarSpecContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleGrammarSpec; |
| } |
| |
| void ANTLRv4Parser::GrammarSpecContext::enterRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterGrammarSpec(this); |
| } |
| |
| void ANTLRv4Parser::GrammarSpecContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitGrammarSpec(this); |
| } |
| |
| ANTLRv4Parser::GrammarSpecContext *ANTLRv4Parser::grammarSpec() { |
| GrammarSpecContext *_localctx = |
| _tracker.createInstance<GrammarSpecContext>(_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<ANTLRv4Parser::GrammarTypeContext>(0); |
| } |
| |
| ANTLRv4Parser::IdentifierContext * |
| ANTLRv4Parser::GrammarDeclContext::identifier() { |
| return getRuleContext<ANTLRv4Parser::IdentifierContext>(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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterGrammarDecl(this); |
| } |
| |
| void ANTLRv4Parser::GrammarDeclContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitGrammarDecl(this); |
| } |
| |
| ANTLRv4Parser::GrammarDeclContext *ANTLRv4Parser::grammarDecl() { |
| GrammarDeclContext *_localctx = |
| _tracker.createInstance<GrammarDeclContext>(_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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterGrammarType(this); |
| } |
| |
| void ANTLRv4Parser::GrammarTypeContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitGrammarType(this); |
| } |
| |
| ANTLRv4Parser::GrammarTypeContext *ANTLRv4Parser::grammarType() { |
| GrammarTypeContext *_localctx = |
| _tracker.createInstance<GrammarTypeContext>(_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<ANTLRv4Parser::OptionsSpecContext>(0); |
| } |
| |
| ANTLRv4Parser::DelegateGrammarsContext * |
| ANTLRv4Parser::PrequelConstructContext::delegateGrammars() { |
| return getRuleContext<ANTLRv4Parser::DelegateGrammarsContext>(0); |
| } |
| |
| ANTLRv4Parser::TokensSpecContext * |
| ANTLRv4Parser::PrequelConstructContext::tokensSpec() { |
| return getRuleContext<ANTLRv4Parser::TokensSpecContext>(0); |
| } |
| |
| ANTLRv4Parser::ChannelsSpecContext * |
| ANTLRv4Parser::PrequelConstructContext::channelsSpec() { |
| return getRuleContext<ANTLRv4Parser::ChannelsSpecContext>(0); |
| } |
| |
| ANTLRv4Parser::Action_Context * |
| ANTLRv4Parser::PrequelConstructContext::action_() { |
| return getRuleContext<ANTLRv4Parser::Action_Context>(0); |
| } |
| |
| size_t ANTLRv4Parser::PrequelConstructContext::getRuleIndex() const { |
| return ANTLRv4Parser::RulePrequelConstruct; |
| } |
| |
| void ANTLRv4Parser::PrequelConstructContext::enterRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterPrequelConstruct(this); |
| } |
| |
| void ANTLRv4Parser::PrequelConstructContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitPrequelConstruct(this); |
| } |
| |
| ANTLRv4Parser::PrequelConstructContext *ANTLRv4Parser::prequelConstruct() { |
| PrequelConstructContext *_localctx = |
| _tracker.createInstance<PrequelConstructContext>(_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::OptionContext *> |
| ANTLRv4Parser::OptionsSpecContext::option() { |
| return getRuleContexts<ANTLRv4Parser::OptionContext>(); |
| } |
| |
| ANTLRv4Parser::OptionContext *ANTLRv4Parser::OptionsSpecContext::option( |
| size_t i) { |
| return getRuleContext<ANTLRv4Parser::OptionContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> 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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterOptionsSpec(this); |
| } |
| |
| void ANTLRv4Parser::OptionsSpecContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitOptionsSpec(this); |
| } |
| |
| ANTLRv4Parser::OptionsSpecContext *ANTLRv4Parser::optionsSpec() { |
| OptionsSpecContext *_localctx = |
| _tracker.createInstance<OptionsSpecContext>(_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<ANTLRv4Parser::IdentifierContext>(0); |
| } |
| |
| tree::TerminalNode *ANTLRv4Parser::OptionContext::ASSIGN() { |
| return getToken(ANTLRv4Parser::ASSIGN, 0); |
| } |
| |
| ANTLRv4Parser::OptionValueContext *ANTLRv4Parser::OptionContext::optionValue() { |
| return getRuleContext<ANTLRv4Parser::OptionValueContext>(0); |
| } |
| |
| size_t ANTLRv4Parser::OptionContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleOption; |
| } |
| |
| void ANTLRv4Parser::OptionContext::enterRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterOption(this); |
| } |
| |
| void ANTLRv4Parser::OptionContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitOption(this); |
| } |
| |
| ANTLRv4Parser::OptionContext *ANTLRv4Parser::option() { |
| OptionContext *_localctx = |
| _tracker.createInstance<OptionContext>(_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::IdentifierContext *> |
| ANTLRv4Parser::OptionValueContext::identifier() { |
| return getRuleContexts<ANTLRv4Parser::IdentifierContext>(); |
| } |
| |
| ANTLRv4Parser::IdentifierContext *ANTLRv4Parser::OptionValueContext::identifier( |
| size_t i) { |
| return getRuleContext<ANTLRv4Parser::IdentifierContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> 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<ANTLRv4Parser::ActionBlockContext>(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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterOptionValue(this); |
| } |
| |
| void ANTLRv4Parser::OptionValueContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitOptionValue(this); |
| } |
| |
| ANTLRv4Parser::OptionValueContext *ANTLRv4Parser::optionValue() { |
| OptionValueContext *_localctx = |
| _tracker.createInstance<OptionValueContext>(_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::DelegateGrammarContext *> |
| ANTLRv4Parser::DelegateGrammarsContext::delegateGrammar() { |
| return getRuleContexts<ANTLRv4Parser::DelegateGrammarContext>(); |
| } |
| |
| ANTLRv4Parser::DelegateGrammarContext * |
| ANTLRv4Parser::DelegateGrammarsContext::delegateGrammar(size_t i) { |
| return getRuleContext<ANTLRv4Parser::DelegateGrammarContext>(i); |
| } |
| |
| tree::TerminalNode *ANTLRv4Parser::DelegateGrammarsContext::SEMI() { |
| return getToken(ANTLRv4Parser::SEMI, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> |
| 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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterDelegateGrammars(this); |
| } |
| |
| void ANTLRv4Parser::DelegateGrammarsContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitDelegateGrammars(this); |
| } |
| |
| ANTLRv4Parser::DelegateGrammarsContext *ANTLRv4Parser::delegateGrammars() { |
| DelegateGrammarsContext *_localctx = |
| _tracker.createInstance<DelegateGrammarsContext>(_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::IdentifierContext *> |
| ANTLRv4Parser::DelegateGrammarContext::identifier() { |
| return getRuleContexts<ANTLRv4Parser::IdentifierContext>(); |
| } |
| |
| ANTLRv4Parser::IdentifierContext * |
| ANTLRv4Parser::DelegateGrammarContext::identifier(size_t i) { |
| return getRuleContext<ANTLRv4Parser::IdentifierContext>(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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterDelegateGrammar(this); |
| } |
| |
| void ANTLRv4Parser::DelegateGrammarContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitDelegateGrammar(this); |
| } |
| |
| ANTLRv4Parser::DelegateGrammarContext *ANTLRv4Parser::delegateGrammar() { |
| DelegateGrammarContext *_localctx = |
| _tracker.createInstance<DelegateGrammarContext>(_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<atn::ParserATNSimulator>()->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<ANTLRv4Parser::IdListContext>(0); |
| } |
| |
| size_t ANTLRv4Parser::TokensSpecContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleTokensSpec; |
| } |
| |
| void ANTLRv4Parser::TokensSpecContext::enterRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterTokensSpec(this); |
| } |
| |
| void ANTLRv4Parser::TokensSpecContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitTokensSpec(this); |
| } |
| |
| ANTLRv4Parser::TokensSpecContext *ANTLRv4Parser::tokensSpec() { |
| TokensSpecContext *_localctx = |
| _tracker.createInstance<TokensSpecContext>(_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<ANTLRv4Parser::IdListContext>(0); |
| } |
| |
| size_t ANTLRv4Parser::ChannelsSpecContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleChannelsSpec; |
| } |
| |
| void ANTLRv4Parser::ChannelsSpecContext::enterRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterChannelsSpec(this); |
| } |
| |
| void ANTLRv4Parser::ChannelsSpecContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitChannelsSpec(this); |
| } |
| |
| ANTLRv4Parser::ChannelsSpecContext *ANTLRv4Parser::channelsSpec() { |
| ChannelsSpecContext *_localctx = |
| _tracker.createInstance<ChannelsSpecContext>(_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::IdentifierContext *> |
| ANTLRv4Parser::IdListContext::identifier() { |
| return getRuleContexts<ANTLRv4Parser::IdentifierContext>(); |
| } |
| |
| ANTLRv4Parser::IdentifierContext *ANTLRv4Parser::IdListContext::identifier( |
| size_t i) { |
| return getRuleContext<ANTLRv4Parser::IdentifierContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> 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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterIdList(this); |
| } |
| |
| void ANTLRv4Parser::IdListContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitIdList(this); |
| } |
| |
| ANTLRv4Parser::IdListContext *ANTLRv4Parser::idList() { |
| IdListContext *_localctx = |
| _tracker.createInstance<IdListContext>(_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<atn::ParserATNSimulator>()->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<atn::ParserATNSimulator>()->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<ANTLRv4Parser::IdentifierContext>(0); |
| } |
| |
| ANTLRv4Parser::ActionBlockContext * |
| ANTLRv4Parser::Action_Context::actionBlock() { |
| return getRuleContext<ANTLRv4Parser::ActionBlockContext>(0); |
| } |
| |
| ANTLRv4Parser::ActionScopeNameContext * |
| ANTLRv4Parser::Action_Context::actionScopeName() { |
| return getRuleContext<ANTLRv4Parser::ActionScopeNameContext>(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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterAction_(this); |
| } |
| |
| void ANTLRv4Parser::Action_Context::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitAction_(this); |
| } |
| |
| ANTLRv4Parser::Action_Context *ANTLRv4Parser::action_() { |
| Action_Context *_localctx = |
| _tracker.createInstance<Action_Context>(_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<atn::ParserATNSimulator>()->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<ANTLRv4Parser::IdentifierContext>(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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterActionScopeName(this); |
| } |
| |
| void ANTLRv4Parser::ActionScopeNameContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitActionScopeName(this); |
| } |
| |
| ANTLRv4Parser::ActionScopeNameContext *ANTLRv4Parser::actionScopeName() { |
| ActionScopeNameContext *_localctx = |
| _tracker.createInstance<ActionScopeNameContext>(_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<tree::TerminalNode *> |
| 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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterActionBlock(this); |
| } |
| |
| void ANTLRv4Parser::ActionBlockContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitActionBlock(this); |
| } |
| |
| ANTLRv4Parser::ActionBlockContext *ANTLRv4Parser::actionBlock() { |
| ActionBlockContext *_localctx = |
| _tracker.createInstance<ActionBlockContext>(_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<tree::TerminalNode *> |
| 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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterArgActionBlock(this); |
| } |
| |
| void ANTLRv4Parser::ArgActionBlockContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitArgActionBlock(this); |
| } |
| |
| ANTLRv4Parser::ArgActionBlockContext *ANTLRv4Parser::argActionBlock() { |
| ArgActionBlockContext *_localctx = |
| _tracker.createInstance<ArgActionBlockContext>(_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<ANTLRv4Parser::IdentifierContext>(0); |
| } |
| |
| tree::TerminalNode *ANTLRv4Parser::ModeSpecContext::SEMI() { |
| return getToken(ANTLRv4Parser::SEMI, 0); |
| } |
| |
| std::vector<ANTLRv4Parser::LexerRuleSpecContext *> |
| ANTLRv4Parser::ModeSpecContext::lexerRuleSpec() { |
| return getRuleContexts<ANTLRv4Parser::LexerRuleSpecContext>(); |
| } |
| |
| ANTLRv4Parser::LexerRuleSpecContext * |
| ANTLRv4Parser::ModeSpecContext::lexerRuleSpec(size_t i) { |
| return getRuleContext<ANTLRv4Parser::LexerRuleSpecContext>(i); |
| } |
| |
| size_t ANTLRv4Parser::ModeSpecContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleModeSpec; |
| } |
| |
| void ANTLRv4Parser::ModeSpecContext::enterRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterModeSpec(this); |
| } |
| |
| void ANTLRv4Parser::ModeSpecContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitModeSpec(this); |
| } |
| |
| ANTLRv4Parser::ModeSpecContext *ANTLRv4Parser::modeSpec() { |
| ModeSpecContext *_localctx = |
| _tracker.createInstance<ModeSpecContext>(_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::RuleSpecContext *> |
| ANTLRv4Parser::RulesContext::ruleSpec() { |
| return getRuleContexts<ANTLRv4Parser::RuleSpecContext>(); |
| } |
| |
| ANTLRv4Parser::RuleSpecContext *ANTLRv4Parser::RulesContext::ruleSpec( |
| size_t i) { |
| return getRuleContext<ANTLRv4Parser::RuleSpecContext>(i); |
| } |
| |
| size_t ANTLRv4Parser::RulesContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleRules; |
| } |
| |
| void ANTLRv4Parser::RulesContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterRules(this); |
| } |
| |
| void ANTLRv4Parser::RulesContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitRules(this); |
| } |
| |
| ANTLRv4Parser::RulesContext *ANTLRv4Parser::rules() { |
| RulesContext *_localctx = |
| _tracker.createInstance<RulesContext>(_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<ANTLRv4Parser::ParserRuleSpecContext>(0); |
| } |
| |
| ANTLRv4Parser::LexerRuleSpecContext * |
| ANTLRv4Parser::RuleSpecContext::lexerRuleSpec() { |
| return getRuleContext<ANTLRv4Parser::LexerRuleSpecContext>(0); |
| } |
| |
| size_t ANTLRv4Parser::RuleSpecContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleRuleSpec; |
| } |
| |
| void ANTLRv4Parser::RuleSpecContext::enterRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterRuleSpec(this); |
| } |
| |
| void ANTLRv4Parser::RuleSpecContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitRuleSpec(this); |
| } |
| |
| ANTLRv4Parser::RuleSpecContext *ANTLRv4Parser::ruleSpec() { |
| RuleSpecContext *_localctx = |
| _tracker.createInstance<RuleSpecContext>(_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<atn::ParserATNSimulator>()->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<ANTLRv4Parser::RuleBlockContext>(0); |
| } |
| |
| tree::TerminalNode *ANTLRv4Parser::ParserRuleSpecContext::SEMI() { |
| return getToken(ANTLRv4Parser::SEMI, 0); |
| } |
| |
| ANTLRv4Parser::ExceptionGroupContext * |
| ANTLRv4Parser::ParserRuleSpecContext::exceptionGroup() { |
| return getRuleContext<ANTLRv4Parser::ExceptionGroupContext>(0); |
| } |
| |
| ANTLRv4Parser::RuleModifiersContext * |
| ANTLRv4Parser::ParserRuleSpecContext::ruleModifiers() { |
| return getRuleContext<ANTLRv4Parser::RuleModifiersContext>(0); |
| } |
| |
| ANTLRv4Parser::ArgActionBlockContext * |
| ANTLRv4Parser::ParserRuleSpecContext::argActionBlock() { |
| return getRuleContext<ANTLRv4Parser::ArgActionBlockContext>(0); |
| } |
| |
| ANTLRv4Parser::RuleReturnsContext * |
| ANTLRv4Parser::ParserRuleSpecContext::ruleReturns() { |
| return getRuleContext<ANTLRv4Parser::RuleReturnsContext>(0); |
| } |
| |
| ANTLRv4Parser::ThrowsSpecContext * |
| ANTLRv4Parser::ParserRuleSpecContext::throwsSpec() { |
| return getRuleContext<ANTLRv4Parser::ThrowsSpecContext>(0); |
| } |
| |
| ANTLRv4Parser::LocalsSpecContext * |
| ANTLRv4Parser::ParserRuleSpecContext::localsSpec() { |
| return getRuleContext<ANTLRv4Parser::LocalsSpecContext>(0); |
| } |
| |
| std::vector<ANTLRv4Parser::RulePrequelContext *> |
| ANTLRv4Parser::ParserRuleSpecContext::rulePrequel() { |
| return getRuleContexts<ANTLRv4Parser::RulePrequelContext>(); |
| } |
| |
| ANTLRv4Parser::RulePrequelContext * |
| ANTLRv4Parser::ParserRuleSpecContext::rulePrequel(size_t i) { |
| return getRuleContext<ANTLRv4Parser::RulePrequelContext>(i); |
| } |
| |
| size_t ANTLRv4Parser::ParserRuleSpecContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleParserRuleSpec; |
| } |
| |
| void ANTLRv4Parser::ParserRuleSpecContext::enterRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterParserRuleSpec(this); |
| } |
| |
| void ANTLRv4Parser::ParserRuleSpecContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitParserRuleSpec(this); |
| } |
| |
| ANTLRv4Parser::ParserRuleSpecContext *ANTLRv4Parser::parserRuleSpec() { |
| ParserRuleSpecContext *_localctx = |
| _tracker.createInstance<ParserRuleSpecContext>(_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::ExceptionHandlerContext *> |
| ANTLRv4Parser::ExceptionGroupContext::exceptionHandler() { |
| return getRuleContexts<ANTLRv4Parser::ExceptionHandlerContext>(); |
| } |
| |
| ANTLRv4Parser::ExceptionHandlerContext * |
| ANTLRv4Parser::ExceptionGroupContext::exceptionHandler(size_t i) { |
| return getRuleContext<ANTLRv4Parser::ExceptionHandlerContext>(i); |
| } |
| |
| ANTLRv4Parser::FinallyClauseContext * |
| ANTLRv4Parser::ExceptionGroupContext::finallyClause() { |
| return getRuleContext<ANTLRv4Parser::FinallyClauseContext>(0); |
| } |
| |
| size_t ANTLRv4Parser::ExceptionGroupContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleExceptionGroup; |
| } |
| |
| void ANTLRv4Parser::ExceptionGroupContext::enterRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterExceptionGroup(this); |
| } |
| |
| void ANTLRv4Parser::ExceptionGroupContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitExceptionGroup(this); |
| } |
| |
| ANTLRv4Parser::ExceptionGroupContext *ANTLRv4Parser::exceptionGroup() { |
| ExceptionGroupContext *_localctx = |
| _tracker.createInstance<ExceptionGroupContext>(_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<ANTLRv4Parser::ArgActionBlockContext>(0); |
| } |
| |
| ANTLRv4Parser::ActionBlockContext * |
| ANTLRv4Parser::ExceptionHandlerContext::actionBlock() { |
| return getRuleContext<ANTLRv4Parser::ActionBlockContext>(0); |
| } |
| |
| size_t ANTLRv4Parser::ExceptionHandlerContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleExceptionHandler; |
| } |
| |
| void ANTLRv4Parser::ExceptionHandlerContext::enterRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterExceptionHandler(this); |
| } |
| |
| void ANTLRv4Parser::ExceptionHandlerContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitExceptionHandler(this); |
| } |
| |
| ANTLRv4Parser::ExceptionHandlerContext *ANTLRv4Parser::exceptionHandler() { |
| ExceptionHandlerContext *_localctx = |
| _tracker.createInstance<ExceptionHandlerContext>(_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<ANTLRv4Parser::ActionBlockContext>(0); |
| } |
| |
| size_t ANTLRv4Parser::FinallyClauseContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleFinallyClause; |
| } |
| |
| void ANTLRv4Parser::FinallyClauseContext::enterRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterFinallyClause(this); |
| } |
| |
| void ANTLRv4Parser::FinallyClauseContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitFinallyClause(this); |
| } |
| |
| ANTLRv4Parser::FinallyClauseContext *ANTLRv4Parser::finallyClause() { |
| FinallyClauseContext *_localctx = |
| _tracker.createInstance<FinallyClauseContext>(_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<ANTLRv4Parser::OptionsSpecContext>(0); |
| } |
| |
| ANTLRv4Parser::RuleActionContext * |
| ANTLRv4Parser::RulePrequelContext::ruleAction() { |
| return getRuleContext<ANTLRv4Parser::RuleActionContext>(0); |
| } |
| |
| size_t ANTLRv4Parser::RulePrequelContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleRulePrequel; |
| } |
| |
| void ANTLRv4Parser::RulePrequelContext::enterRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterRulePrequel(this); |
| } |
| |
| void ANTLRv4Parser::RulePrequelContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitRulePrequel(this); |
| } |
| |
| ANTLRv4Parser::RulePrequelContext *ANTLRv4Parser::rulePrequel() { |
| RulePrequelContext *_localctx = |
| _tracker.createInstance<RulePrequelContext>(_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<ANTLRv4Parser::ArgActionBlockContext>(0); |
| } |
| |
| size_t ANTLRv4Parser::RuleReturnsContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleRuleReturns; |
| } |
| |
| void ANTLRv4Parser::RuleReturnsContext::enterRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterRuleReturns(this); |
| } |
| |
| void ANTLRv4Parser::RuleReturnsContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitRuleReturns(this); |
| } |
| |
| ANTLRv4Parser::RuleReturnsContext *ANTLRv4Parser::ruleReturns() { |
| RuleReturnsContext *_localctx = |
| _tracker.createInstance<RuleReturnsContext>(_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::IdentifierContext *> |
| ANTLRv4Parser::ThrowsSpecContext::identifier() { |
| return getRuleContexts<ANTLRv4Parser::IdentifierContext>(); |
| } |
| |
| ANTLRv4Parser::IdentifierContext *ANTLRv4Parser::ThrowsSpecContext::identifier( |
| size_t i) { |
| return getRuleContext<ANTLRv4Parser::IdentifierContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> 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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterThrowsSpec(this); |
| } |
| |
| void ANTLRv4Parser::ThrowsSpecContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitThrowsSpec(this); |
| } |
| |
| ANTLRv4Parser::ThrowsSpecContext *ANTLRv4Parser::throwsSpec() { |
| ThrowsSpecContext *_localctx = |
| _tracker.createInstance<ThrowsSpecContext>(_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<ANTLRv4Parser::ArgActionBlockContext>(0); |
| } |
| |
| size_t ANTLRv4Parser::LocalsSpecContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleLocalsSpec; |
| } |
| |
| void ANTLRv4Parser::LocalsSpecContext::enterRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterLocalsSpec(this); |
| } |
| |
| void ANTLRv4Parser::LocalsSpecContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitLocalsSpec(this); |
| } |
| |
| ANTLRv4Parser::LocalsSpecContext *ANTLRv4Parser::localsSpec() { |
| LocalsSpecContext *_localctx = |
| _tracker.createInstance<LocalsSpecContext>(_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<ANTLRv4Parser::IdentifierContext>(0); |
| } |
| |
| ANTLRv4Parser::ActionBlockContext * |
| ANTLRv4Parser::RuleActionContext::actionBlock() { |
| return getRuleContext<ANTLRv4Parser::ActionBlockContext>(0); |
| } |
| |
| size_t ANTLRv4Parser::RuleActionContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleRuleAction; |
| } |
| |
| void ANTLRv4Parser::RuleActionContext::enterRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterRuleAction(this); |
| } |
| |
| void ANTLRv4Parser::RuleActionContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitRuleAction(this); |
| } |
| |
| ANTLRv4Parser::RuleActionContext *ANTLRv4Parser::ruleAction() { |
| RuleActionContext *_localctx = |
| _tracker.createInstance<RuleActionContext>(_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::RuleModifierContext *> |
| ANTLRv4Parser::RuleModifiersContext::ruleModifier() { |
| return getRuleContexts<ANTLRv4Parser::RuleModifierContext>(); |
| } |
| |
| ANTLRv4Parser::RuleModifierContext * |
| ANTLRv4Parser::RuleModifiersContext::ruleModifier(size_t i) { |
| return getRuleContext<ANTLRv4Parser::RuleModifierContext>(i); |
| } |
| |
| size_t ANTLRv4Parser::RuleModifiersContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleRuleModifiers; |
| } |
| |
| void ANTLRv4Parser::RuleModifiersContext::enterRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterRuleModifiers(this); |
| } |
| |
| void ANTLRv4Parser::RuleModifiersContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitRuleModifiers(this); |
| } |
| |
| ANTLRv4Parser::RuleModifiersContext *ANTLRv4Parser::ruleModifiers() { |
| RuleModifiersContext *_localctx = |
| _tracker.createInstance<RuleModifiersContext>(_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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterRuleModifier(this); |
| } |
| |
| void ANTLRv4Parser::RuleModifierContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitRuleModifier(this); |
| } |
| |
| ANTLRv4Parser::RuleModifierContext *ANTLRv4Parser::ruleModifier() { |
| RuleModifierContext *_localctx = |
| _tracker.createInstance<RuleModifierContext>(_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<ANTLRv4Parser::RuleAltListContext>(0); |
| } |
| |
| size_t ANTLRv4Parser::RuleBlockContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleRuleBlock; |
| } |
| |
| void ANTLRv4Parser::RuleBlockContext::enterRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterRuleBlock(this); |
| } |
| |
| void ANTLRv4Parser::RuleBlockContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitRuleBlock(this); |
| } |
| |
| ANTLRv4Parser::RuleBlockContext *ANTLRv4Parser::ruleBlock() { |
| RuleBlockContext *_localctx = |
| _tracker.createInstance<RuleBlockContext>(_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::LabeledAltContext *> |
| ANTLRv4Parser::RuleAltListContext::labeledAlt() { |
| return getRuleContexts<ANTLRv4Parser::LabeledAltContext>(); |
| } |
| |
| ANTLRv4Parser::LabeledAltContext *ANTLRv4Parser::RuleAltListContext::labeledAlt( |
| size_t i) { |
| return getRuleContext<ANTLRv4Parser::LabeledAltContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> 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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterRuleAltList(this); |
| } |
| |
| void ANTLRv4Parser::RuleAltListContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitRuleAltList(this); |
| } |
| |
| ANTLRv4Parser::RuleAltListContext *ANTLRv4Parser::ruleAltList() { |
| RuleAltListContext *_localctx = |
| _tracker.createInstance<RuleAltListContext>(_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<ANTLRv4Parser::AlternativeContext>(0); |
| } |
| |
| tree::TerminalNode *ANTLRv4Parser::LabeledAltContext::POUND() { |
| return getToken(ANTLRv4Parser::POUND, 0); |
| } |
| |
| ANTLRv4Parser::IdentifierContext * |
| ANTLRv4Parser::LabeledAltContext::identifier() { |
| return getRuleContext<ANTLRv4Parser::IdentifierContext>(0); |
| } |
| |
| size_t ANTLRv4Parser::LabeledAltContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleLabeledAlt; |
| } |
| |
| void ANTLRv4Parser::LabeledAltContext::enterRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterLabeledAlt(this); |
| } |
| |
| void ANTLRv4Parser::LabeledAltContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitLabeledAlt(this); |
| } |
| |
| ANTLRv4Parser::LabeledAltContext *ANTLRv4Parser::labeledAlt() { |
| LabeledAltContext *_localctx = |
| _tracker.createInstance<LabeledAltContext>(_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<ANTLRv4Parser::LexerRuleBlockContext>(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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterLexerRuleSpec(this); |
| } |
| |
| void ANTLRv4Parser::LexerRuleSpecContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitLexerRuleSpec(this); |
| } |
| |
| ANTLRv4Parser::LexerRuleSpecContext *ANTLRv4Parser::lexerRuleSpec() { |
| LexerRuleSpecContext *_localctx = |
| _tracker.createInstance<LexerRuleSpecContext>(_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<ANTLRv4Parser::LexerAltListContext>(0); |
| } |
| |
| size_t ANTLRv4Parser::LexerRuleBlockContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleLexerRuleBlock; |
| } |
| |
| void ANTLRv4Parser::LexerRuleBlockContext::enterRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterLexerRuleBlock(this); |
| } |
| |
| void ANTLRv4Parser::LexerRuleBlockContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitLexerRuleBlock(this); |
| } |
| |
| ANTLRv4Parser::LexerRuleBlockContext *ANTLRv4Parser::lexerRuleBlock() { |
| LexerRuleBlockContext *_localctx = |
| _tracker.createInstance<LexerRuleBlockContext>(_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::LexerAltContext *> |
| ANTLRv4Parser::LexerAltListContext::lexerAlt() { |
| return getRuleContexts<ANTLRv4Parser::LexerAltContext>(); |
| } |
| |
| ANTLRv4Parser::LexerAltContext *ANTLRv4Parser::LexerAltListContext::lexerAlt( |
| size_t i) { |
| return getRuleContext<ANTLRv4Parser::LexerAltContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> 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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterLexerAltList(this); |
| } |
| |
| void ANTLRv4Parser::LexerAltListContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitLexerAltList(this); |
| } |
| |
| ANTLRv4Parser::LexerAltListContext *ANTLRv4Parser::lexerAltList() { |
| LexerAltListContext *_localctx = |
| _tracker.createInstance<LexerAltListContext>(_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<ANTLRv4Parser::LexerElementsContext>(0); |
| } |
| |
| ANTLRv4Parser::LexerCommandsContext * |
| ANTLRv4Parser::LexerAltContext::lexerCommands() { |
| return getRuleContext<ANTLRv4Parser::LexerCommandsContext>(0); |
| } |
| |
| size_t ANTLRv4Parser::LexerAltContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleLexerAlt; |
| } |
| |
| void ANTLRv4Parser::LexerAltContext::enterRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterLexerAlt(this); |
| } |
| |
| void ANTLRv4Parser::LexerAltContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitLexerAlt(this); |
| } |
| |
| ANTLRv4Parser::LexerAltContext *ANTLRv4Parser::lexerAlt() { |
| LexerAltContext *_localctx = |
| _tracker.createInstance<LexerAltContext>(_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<atn::ParserATNSimulator>()->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::LexerElementContext *> |
| ANTLRv4Parser::LexerElementsContext::lexerElement() { |
| return getRuleContexts<ANTLRv4Parser::LexerElementContext>(); |
| } |
| |
| ANTLRv4Parser::LexerElementContext * |
| ANTLRv4Parser::LexerElementsContext::lexerElement(size_t i) { |
| return getRuleContext<ANTLRv4Parser::LexerElementContext>(i); |
| } |
| |
| size_t ANTLRv4Parser::LexerElementsContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleLexerElements; |
| } |
| |
| void ANTLRv4Parser::LexerElementsContext::enterRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterLexerElements(this); |
| } |
| |
| void ANTLRv4Parser::LexerElementsContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitLexerElements(this); |
| } |
| |
| ANTLRv4Parser::LexerElementsContext *ANTLRv4Parser::lexerElements() { |
| LexerElementsContext *_localctx = |
| _tracker.createInstance<LexerElementsContext>(_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<ANTLRv4Parser::LabeledLexerElementContext>(0); |
| } |
| |
| ANTLRv4Parser::EbnfSuffixContext * |
| ANTLRv4Parser::LexerElementContext::ebnfSuffix() { |
| return getRuleContext<ANTLRv4Parser::EbnfSuffixContext>(0); |
| } |
| |
| ANTLRv4Parser::LexerAtomContext * |
| ANTLRv4Parser::LexerElementContext::lexerAtom() { |
| return getRuleContext<ANTLRv4Parser::LexerAtomContext>(0); |
| } |
| |
| ANTLRv4Parser::LexerBlockContext * |
| ANTLRv4Parser::LexerElementContext::lexerBlock() { |
| return getRuleContext<ANTLRv4Parser::LexerBlockContext>(0); |
| } |
| |
| ANTLRv4Parser::ActionBlockContext * |
| ANTLRv4Parser::LexerElementContext::actionBlock() { |
| return getRuleContext<ANTLRv4Parser::ActionBlockContext>(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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterLexerElement(this); |
| } |
| |
| void ANTLRv4Parser::LexerElementContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitLexerElement(this); |
| } |
| |
| ANTLRv4Parser::LexerElementContext *ANTLRv4Parser::lexerElement() { |
| LexerElementContext *_localctx = |
| _tracker.createInstance<LexerElementContext>(_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<atn::ParserATNSimulator>()->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<ANTLRv4Parser::IdentifierContext>(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<ANTLRv4Parser::LexerAtomContext>(0); |
| } |
| |
| ANTLRv4Parser::LexerBlockContext * |
| ANTLRv4Parser::LabeledLexerElementContext::lexerBlock() { |
| return getRuleContext<ANTLRv4Parser::LexerBlockContext>(0); |
| } |
| |
| size_t ANTLRv4Parser::LabeledLexerElementContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleLabeledLexerElement; |
| } |
| |
| void ANTLRv4Parser::LabeledLexerElementContext::enterRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterLabeledLexerElement(this); |
| } |
| |
| void ANTLRv4Parser::LabeledLexerElementContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitLabeledLexerElement(this); |
| } |
| |
| ANTLRv4Parser::LabeledLexerElementContext * |
| ANTLRv4Parser::labeledLexerElement() { |
| LabeledLexerElementContext *_localctx = |
| _tracker.createInstance<LabeledLexerElementContext>(_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<ANTLRv4Parser::LexerAltListContext>(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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterLexerBlock(this); |
| } |
| |
| void ANTLRv4Parser::LexerBlockContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitLexerBlock(this); |
| } |
| |
| ANTLRv4Parser::LexerBlockContext *ANTLRv4Parser::lexerBlock() { |
| LexerBlockContext *_localctx = |
| _tracker.createInstance<LexerBlockContext>(_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::LexerCommandContext *> |
| ANTLRv4Parser::LexerCommandsContext::lexerCommand() { |
| return getRuleContexts<ANTLRv4Parser::LexerCommandContext>(); |
| } |
| |
| ANTLRv4Parser::LexerCommandContext * |
| ANTLRv4Parser::LexerCommandsContext::lexerCommand(size_t i) { |
| return getRuleContext<ANTLRv4Parser::LexerCommandContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> 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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterLexerCommands(this); |
| } |
| |
| void ANTLRv4Parser::LexerCommandsContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitLexerCommands(this); |
| } |
| |
| ANTLRv4Parser::LexerCommandsContext *ANTLRv4Parser::lexerCommands() { |
| LexerCommandsContext *_localctx = |
| _tracker.createInstance<LexerCommandsContext>(_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<ANTLRv4Parser::LexerCommandNameContext>(0); |
| } |
| |
| tree::TerminalNode *ANTLRv4Parser::LexerCommandContext::LPAREN() { |
| return getToken(ANTLRv4Parser::LPAREN, 0); |
| } |
| |
| ANTLRv4Parser::LexerCommandExprContext * |
| ANTLRv4Parser::LexerCommandContext::lexerCommandExpr() { |
| return getRuleContext<ANTLRv4Parser::LexerCommandExprContext>(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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterLexerCommand(this); |
| } |
| |
| void ANTLRv4Parser::LexerCommandContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitLexerCommand(this); |
| } |
| |
| ANTLRv4Parser::LexerCommandContext *ANTLRv4Parser::lexerCommand() { |
| LexerCommandContext *_localctx = |
| _tracker.createInstance<LexerCommandContext>(_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<atn::ParserATNSimulator>()->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<ANTLRv4Parser::IdentifierContext>(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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterLexerCommandName(this); |
| } |
| |
| void ANTLRv4Parser::LexerCommandNameContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitLexerCommandName(this); |
| } |
| |
| ANTLRv4Parser::LexerCommandNameContext *ANTLRv4Parser::lexerCommandName() { |
| LexerCommandNameContext *_localctx = |
| _tracker.createInstance<LexerCommandNameContext>(_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<ANTLRv4Parser::IdentifierContext>(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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterLexerCommandExpr(this); |
| } |
| |
| void ANTLRv4Parser::LexerCommandExprContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitLexerCommandExpr(this); |
| } |
| |
| ANTLRv4Parser::LexerCommandExprContext *ANTLRv4Parser::lexerCommandExpr() { |
| LexerCommandExprContext *_localctx = |
| _tracker.createInstance<LexerCommandExprContext>(_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::AlternativeContext *> |
| ANTLRv4Parser::AltListContext::alternative() { |
| return getRuleContexts<ANTLRv4Parser::AlternativeContext>(); |
| } |
| |
| ANTLRv4Parser::AlternativeContext *ANTLRv4Parser::AltListContext::alternative( |
| size_t i) { |
| return getRuleContext<ANTLRv4Parser::AlternativeContext>(i); |
| } |
| |
| std::vector<tree::TerminalNode *> 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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterAltList(this); |
| } |
| |
| void ANTLRv4Parser::AltListContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitAltList(this); |
| } |
| |
| ANTLRv4Parser::AltListContext *ANTLRv4Parser::altList() { |
| AltListContext *_localctx = |
| _tracker.createInstance<AltListContext>(_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<ANTLRv4Parser::ElementOptionsContext>(0); |
| } |
| |
| std::vector<ANTLRv4Parser::ElementContext *> |
| ANTLRv4Parser::AlternativeContext::element() { |
| return getRuleContexts<ANTLRv4Parser::ElementContext>(); |
| } |
| |
| ANTLRv4Parser::ElementContext *ANTLRv4Parser::AlternativeContext::element( |
| size_t i) { |
| return getRuleContext<ANTLRv4Parser::ElementContext>(i); |
| } |
| |
| size_t ANTLRv4Parser::AlternativeContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleAlternative; |
| } |
| |
| void ANTLRv4Parser::AlternativeContext::enterRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterAlternative(this); |
| } |
| |
| void ANTLRv4Parser::AlternativeContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitAlternative(this); |
| } |
| |
| ANTLRv4Parser::AlternativeContext *ANTLRv4Parser::alternative() { |
| AlternativeContext *_localctx = |
| _tracker.createInstance<AlternativeContext>(_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<ANTLRv4Parser::LabeledElementContext>(0); |
| } |
| |
| ANTLRv4Parser::EbnfSuffixContext *ANTLRv4Parser::ElementContext::ebnfSuffix() { |
| return getRuleContext<ANTLRv4Parser::EbnfSuffixContext>(0); |
| } |
| |
| ANTLRv4Parser::AtomContext *ANTLRv4Parser::ElementContext::atom() { |
| return getRuleContext<ANTLRv4Parser::AtomContext>(0); |
| } |
| |
| ANTLRv4Parser::EbnfContext *ANTLRv4Parser::ElementContext::ebnf() { |
| return getRuleContext<ANTLRv4Parser::EbnfContext>(0); |
| } |
| |
| ANTLRv4Parser::ActionBlockContext * |
| ANTLRv4Parser::ElementContext::actionBlock() { |
| return getRuleContext<ANTLRv4Parser::ActionBlockContext>(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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterElement(this); |
| } |
| |
| void ANTLRv4Parser::ElementContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitElement(this); |
| } |
| |
| ANTLRv4Parser::ElementContext *ANTLRv4Parser::element() { |
| ElementContext *_localctx = |
| _tracker.createInstance<ElementContext>(_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<atn::ParserATNSimulator>()->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<ANTLRv4Parser::IdentifierContext>(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<ANTLRv4Parser::AtomContext>(0); |
| } |
| |
| ANTLRv4Parser::BlockContext *ANTLRv4Parser::LabeledElementContext::block() { |
| return getRuleContext<ANTLRv4Parser::BlockContext>(0); |
| } |
| |
| size_t ANTLRv4Parser::LabeledElementContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleLabeledElement; |
| } |
| |
| void ANTLRv4Parser::LabeledElementContext::enterRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterLabeledElement(this); |
| } |
| |
| void ANTLRv4Parser::LabeledElementContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitLabeledElement(this); |
| } |
| |
| ANTLRv4Parser::LabeledElementContext *ANTLRv4Parser::labeledElement() { |
| LabeledElementContext *_localctx = |
| _tracker.createInstance<LabeledElementContext>(_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<ANTLRv4Parser::BlockContext>(0); |
| } |
| |
| ANTLRv4Parser::BlockSuffixContext *ANTLRv4Parser::EbnfContext::blockSuffix() { |
| return getRuleContext<ANTLRv4Parser::BlockSuffixContext>(0); |
| } |
| |
| size_t ANTLRv4Parser::EbnfContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleEbnf; |
| } |
| |
| void ANTLRv4Parser::EbnfContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterEbnf(this); |
| } |
| |
| void ANTLRv4Parser::EbnfContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitEbnf(this); |
| } |
| |
| ANTLRv4Parser::EbnfContext *ANTLRv4Parser::ebnf() { |
| EbnfContext *_localctx = |
| _tracker.createInstance<EbnfContext>(_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<ANTLRv4Parser::EbnfSuffixContext>(0); |
| } |
| |
| size_t ANTLRv4Parser::BlockSuffixContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleBlockSuffix; |
| } |
| |
| void ANTLRv4Parser::BlockSuffixContext::enterRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterBlockSuffix(this); |
| } |
| |
| void ANTLRv4Parser::BlockSuffixContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitBlockSuffix(this); |
| } |
| |
| ANTLRv4Parser::BlockSuffixContext *ANTLRv4Parser::blockSuffix() { |
| BlockSuffixContext *_localctx = |
| _tracker.createInstance<BlockSuffixContext>(_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<tree::TerminalNode *> 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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterEbnfSuffix(this); |
| } |
| |
| void ANTLRv4Parser::EbnfSuffixContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitEbnfSuffix(this); |
| } |
| |
| ANTLRv4Parser::EbnfSuffixContext *ANTLRv4Parser::ebnfSuffix() { |
| EbnfSuffixContext *_localctx = |
| _tracker.createInstance<EbnfSuffixContext>(_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<ANTLRv4Parser::CharacterRangeContext>(0); |
| } |
| |
| ANTLRv4Parser::TerminalContext *ANTLRv4Parser::LexerAtomContext::terminal() { |
| return getRuleContext<ANTLRv4Parser::TerminalContext>(0); |
| } |
| |
| ANTLRv4Parser::NotSetContext *ANTLRv4Parser::LexerAtomContext::notSet() { |
| return getRuleContext<ANTLRv4Parser::NotSetContext>(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<ANTLRv4Parser::ElementOptionsContext>(0); |
| } |
| |
| size_t ANTLRv4Parser::LexerAtomContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleLexerAtom; |
| } |
| |
| void ANTLRv4Parser::LexerAtomContext::enterRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterLexerAtom(this); |
| } |
| |
| void ANTLRv4Parser::LexerAtomContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitLexerAtom(this); |
| } |
| |
| ANTLRv4Parser::LexerAtomContext *ANTLRv4Parser::lexerAtom() { |
| LexerAtomContext *_localctx = |
| _tracker.createInstance<LexerAtomContext>(_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<atn::ParserATNSimulator>()->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<ANTLRv4Parser::TerminalContext>(0); |
| } |
| |
| ANTLRv4Parser::RulerefContext *ANTLRv4Parser::AtomContext::ruleref() { |
| return getRuleContext<ANTLRv4Parser::RulerefContext>(0); |
| } |
| |
| ANTLRv4Parser::NotSetContext *ANTLRv4Parser::AtomContext::notSet() { |
| return getRuleContext<ANTLRv4Parser::NotSetContext>(0); |
| } |
| |
| tree::TerminalNode *ANTLRv4Parser::AtomContext::DOT() { |
| return getToken(ANTLRv4Parser::DOT, 0); |
| } |
| |
| ANTLRv4Parser::ElementOptionsContext * |
| ANTLRv4Parser::AtomContext::elementOptions() { |
| return getRuleContext<ANTLRv4Parser::ElementOptionsContext>(0); |
| } |
| |
| size_t ANTLRv4Parser::AtomContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleAtom; |
| } |
| |
| void ANTLRv4Parser::AtomContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterAtom(this); |
| } |
| |
| void ANTLRv4Parser::AtomContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitAtom(this); |
| } |
| |
| ANTLRv4Parser::AtomContext *ANTLRv4Parser::atom() { |
| AtomContext *_localctx = |
| _tracker.createInstance<AtomContext>(_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<ANTLRv4Parser::SetElementContext>(0); |
| } |
| |
| ANTLRv4Parser::BlockSetContext *ANTLRv4Parser::NotSetContext::blockSet() { |
| return getRuleContext<ANTLRv4Parser::BlockSetContext>(0); |
| } |
| |
| size_t ANTLRv4Parser::NotSetContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleNotSet; |
| } |
| |
| void ANTLRv4Parser::NotSetContext::enterRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterNotSet(this); |
| } |
| |
| void ANTLRv4Parser::NotSetContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitNotSet(this); |
| } |
| |
| ANTLRv4Parser::NotSetContext *ANTLRv4Parser::notSet() { |
| NotSetContext *_localctx = |
| _tracker.createInstance<NotSetContext>(_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<atn::ParserATNSimulator>()->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::SetElementContext *> |
| ANTLRv4Parser::BlockSetContext::setElement() { |
| return getRuleContexts<ANTLRv4Parser::SetElementContext>(); |
| } |
| |
| ANTLRv4Parser::SetElementContext *ANTLRv4Parser::BlockSetContext::setElement( |
| size_t i) { |
| return getRuleContext<ANTLRv4Parser::SetElementContext>(i); |
| } |
| |
| tree::TerminalNode *ANTLRv4Parser::BlockSetContext::RPAREN() { |
| return getToken(ANTLRv4Parser::RPAREN, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> 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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterBlockSet(this); |
| } |
| |
| void ANTLRv4Parser::BlockSetContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitBlockSet(this); |
| } |
| |
| ANTLRv4Parser::BlockSetContext *ANTLRv4Parser::blockSet() { |
| BlockSetContext *_localctx = |
| _tracker.createInstance<BlockSetContext>(_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<ANTLRv4Parser::ElementOptionsContext>(0); |
| } |
| |
| tree::TerminalNode *ANTLRv4Parser::SetElementContext::STRING_LITERAL() { |
| return getToken(ANTLRv4Parser::STRING_LITERAL, 0); |
| } |
| |
| ANTLRv4Parser::CharacterRangeContext * |
| ANTLRv4Parser::SetElementContext::characterRange() { |
| return getRuleContext<ANTLRv4Parser::CharacterRangeContext>(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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterSetElement(this); |
| } |
| |
| void ANTLRv4Parser::SetElementContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitSetElement(this); |
| } |
| |
| ANTLRv4Parser::SetElementContext *ANTLRv4Parser::setElement() { |
| SetElementContext *_localctx = |
| _tracker.createInstance<SetElementContext>(_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<atn::ParserATNSimulator>()->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<ANTLRv4Parser::AltListContext>(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<ANTLRv4Parser::OptionsSpecContext>(0); |
| } |
| |
| std::vector<ANTLRv4Parser::RuleActionContext *> |
| ANTLRv4Parser::BlockContext::ruleAction() { |
| return getRuleContexts<ANTLRv4Parser::RuleActionContext>(); |
| } |
| |
| ANTLRv4Parser::RuleActionContext *ANTLRv4Parser::BlockContext::ruleAction( |
| size_t i) { |
| return getRuleContext<ANTLRv4Parser::RuleActionContext>(i); |
| } |
| |
| size_t ANTLRv4Parser::BlockContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleBlock; |
| } |
| |
| void ANTLRv4Parser::BlockContext::enterRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterBlock(this); |
| } |
| |
| void ANTLRv4Parser::BlockContext::exitRule(tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitBlock(this); |
| } |
| |
| ANTLRv4Parser::BlockContext *ANTLRv4Parser::block() { |
| BlockContext *_localctx = |
| _tracker.createInstance<BlockContext>(_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<ANTLRv4Parser::ArgActionBlockContext>(0); |
| } |
| |
| ANTLRv4Parser::ElementOptionsContext * |
| ANTLRv4Parser::RulerefContext::elementOptions() { |
| return getRuleContext<ANTLRv4Parser::ElementOptionsContext>(0); |
| } |
| |
| size_t ANTLRv4Parser::RulerefContext::getRuleIndex() const { |
| return ANTLRv4Parser::RuleRuleref; |
| } |
| |
| void ANTLRv4Parser::RulerefContext::enterRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterRuleref(this); |
| } |
| |
| void ANTLRv4Parser::RulerefContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitRuleref(this); |
| } |
| |
| ANTLRv4Parser::RulerefContext *ANTLRv4Parser::ruleref() { |
| RulerefContext *_localctx = |
| _tracker.createInstance<RulerefContext>(_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<tree::TerminalNode *> |
| 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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterCharacterRange(this); |
| } |
| |
| void ANTLRv4Parser::CharacterRangeContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitCharacterRange(this); |
| } |
| |
| ANTLRv4Parser::CharacterRangeContext *ANTLRv4Parser::characterRange() { |
| CharacterRangeContext *_localctx = |
| _tracker.createInstance<CharacterRangeContext>(_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<ANTLRv4Parser::ElementOptionsContext>(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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterTerminal(this); |
| } |
| |
| void ANTLRv4Parser::TerminalContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitTerminal(this); |
| } |
| |
| ANTLRv4Parser::TerminalContext *ANTLRv4Parser::terminal() { |
| TerminalContext *_localctx = |
| _tracker.createInstance<TerminalContext>(_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::ElementOptionContext *> |
| ANTLRv4Parser::ElementOptionsContext::elementOption() { |
| return getRuleContexts<ANTLRv4Parser::ElementOptionContext>(); |
| } |
| |
| ANTLRv4Parser::ElementOptionContext * |
| ANTLRv4Parser::ElementOptionsContext::elementOption(size_t i) { |
| return getRuleContext<ANTLRv4Parser::ElementOptionContext>(i); |
| } |
| |
| tree::TerminalNode *ANTLRv4Parser::ElementOptionsContext::GT() { |
| return getToken(ANTLRv4Parser::GT, 0); |
| } |
| |
| std::vector<tree::TerminalNode *> |
| 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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterElementOptions(this); |
| } |
| |
| void ANTLRv4Parser::ElementOptionsContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitElementOptions(this); |
| } |
| |
| ANTLRv4Parser::ElementOptionsContext *ANTLRv4Parser::elementOptions() { |
| ElementOptionsContext *_localctx = |
| _tracker.createInstance<ElementOptionsContext>(_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::IdentifierContext *> |
| ANTLRv4Parser::ElementOptionContext::identifier() { |
| return getRuleContexts<ANTLRv4Parser::IdentifierContext>(); |
| } |
| |
| ANTLRv4Parser::IdentifierContext * |
| ANTLRv4Parser::ElementOptionContext::identifier(size_t i) { |
| return getRuleContext<ANTLRv4Parser::IdentifierContext>(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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterElementOption(this); |
| } |
| |
| void ANTLRv4Parser::ElementOptionContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitElementOption(this); |
| } |
| |
| ANTLRv4Parser::ElementOptionContext *ANTLRv4Parser::elementOption() { |
| ElementOptionContext *_localctx = |
| _tracker.createInstance<ElementOptionContext>(_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<atn::ParserATNSimulator>()->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<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->enterIdentifier(this); |
| } |
| |
| void ANTLRv4Parser::IdentifierContext::exitRule( |
| tree::ParseTreeListener *listener) { |
| auto parserListener = dynamic_cast<ANTLRv4ParserListener *>(listener); |
| if (parserListener != nullptr) parserListener->exitIdentifier(this); |
| } |
| |
| ANTLRv4Parser::IdentifierContext *ANTLRv4Parser::identifier() { |
| IdentifierContext *_localctx = |
| _tracker.createInstance<IdentifierContext>(_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); |
| } |
