You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6202 lines
200 KiB
6202 lines
200 KiB
// [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);
|
|
}
|
|
|