mirror of
https://github.com/ethereum/solidity
synced 2023-10-03 13:03:40 +00:00
10075 lines
357 KiB
C++
10075 lines
357 KiB
C++
|
|
// Generated from Solidity.g4 by ANTLR 4.8
|
|
|
|
|
|
#include <test/tools/ossfuzz/antlr4-runtime/SolidityVisitor.h>
|
|
#include <test/tools/ossfuzz/antlr4-runtime/SolidityParser.h>
|
|
|
|
|
|
using namespace antlrcpp;
|
|
using namespace antlr4;
|
|
|
|
SolidityParser::SolidityParser(TokenStream *input) : Parser(input) {
|
|
_interpreter = new atn::ParserATNSimulator(this, _atn, _decisionToDFA, _sharedContextCache);
|
|
}
|
|
|
|
SolidityParser::~SolidityParser() {
|
|
delete _interpreter;
|
|
}
|
|
|
|
std::string SolidityParser::getGrammarFileName() const {
|
|
return "Solidity.g4";
|
|
}
|
|
|
|
const std::vector<std::string>& SolidityParser::getRuleNames() const {
|
|
return _ruleNames;
|
|
}
|
|
|
|
dfa::Vocabulary& SolidityParser::getVocabulary() const {
|
|
return _vocabulary;
|
|
}
|
|
|
|
|
|
//----------------- SourceUnitContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::SourceUnitContext::SourceUnitContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::SourceUnitContext::EOF() {
|
|
return getToken(SolidityParser::EOF, 0);
|
|
}
|
|
|
|
std::vector<SolidityParser::PragmaDirectiveContext *> SolidityParser::SourceUnitContext::pragmaDirective() {
|
|
return getRuleContexts<SolidityParser::PragmaDirectiveContext>();
|
|
}
|
|
|
|
SolidityParser::PragmaDirectiveContext* SolidityParser::SourceUnitContext::pragmaDirective(size_t i) {
|
|
return getRuleContext<SolidityParser::PragmaDirectiveContext>(i);
|
|
}
|
|
|
|
std::vector<SolidityParser::ImportDirectiveContext *> SolidityParser::SourceUnitContext::importDirective() {
|
|
return getRuleContexts<SolidityParser::ImportDirectiveContext>();
|
|
}
|
|
|
|
SolidityParser::ImportDirectiveContext* SolidityParser::SourceUnitContext::importDirective(size_t i) {
|
|
return getRuleContext<SolidityParser::ImportDirectiveContext>(i);
|
|
}
|
|
|
|
std::vector<SolidityParser::ContractDefinitionContext *> SolidityParser::SourceUnitContext::contractDefinition() {
|
|
return getRuleContexts<SolidityParser::ContractDefinitionContext>();
|
|
}
|
|
|
|
SolidityParser::ContractDefinitionContext* SolidityParser::SourceUnitContext::contractDefinition(size_t i) {
|
|
return getRuleContext<SolidityParser::ContractDefinitionContext>(i);
|
|
}
|
|
|
|
std::vector<SolidityParser::InterfaceDefinitionContext *> SolidityParser::SourceUnitContext::interfaceDefinition() {
|
|
return getRuleContexts<SolidityParser::InterfaceDefinitionContext>();
|
|
}
|
|
|
|
SolidityParser::InterfaceDefinitionContext* SolidityParser::SourceUnitContext::interfaceDefinition(size_t i) {
|
|
return getRuleContext<SolidityParser::InterfaceDefinitionContext>(i);
|
|
}
|
|
|
|
std::vector<SolidityParser::LibraryDefinitionContext *> SolidityParser::SourceUnitContext::libraryDefinition() {
|
|
return getRuleContexts<SolidityParser::LibraryDefinitionContext>();
|
|
}
|
|
|
|
SolidityParser::LibraryDefinitionContext* SolidityParser::SourceUnitContext::libraryDefinition(size_t i) {
|
|
return getRuleContext<SolidityParser::LibraryDefinitionContext>(i);
|
|
}
|
|
|
|
std::vector<SolidityParser::FunctionDefinitionContext *> SolidityParser::SourceUnitContext::functionDefinition() {
|
|
return getRuleContexts<SolidityParser::FunctionDefinitionContext>();
|
|
}
|
|
|
|
SolidityParser::FunctionDefinitionContext* SolidityParser::SourceUnitContext::functionDefinition(size_t i) {
|
|
return getRuleContext<SolidityParser::FunctionDefinitionContext>(i);
|
|
}
|
|
|
|
std::vector<SolidityParser::StructDefinitionContext *> SolidityParser::SourceUnitContext::structDefinition() {
|
|
return getRuleContexts<SolidityParser::StructDefinitionContext>();
|
|
}
|
|
|
|
SolidityParser::StructDefinitionContext* SolidityParser::SourceUnitContext::structDefinition(size_t i) {
|
|
return getRuleContext<SolidityParser::StructDefinitionContext>(i);
|
|
}
|
|
|
|
std::vector<SolidityParser::EnumDefinitionContext *> SolidityParser::SourceUnitContext::enumDefinition() {
|
|
return getRuleContexts<SolidityParser::EnumDefinitionContext>();
|
|
}
|
|
|
|
SolidityParser::EnumDefinitionContext* SolidityParser::SourceUnitContext::enumDefinition(size_t i) {
|
|
return getRuleContext<SolidityParser::EnumDefinitionContext>(i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::SourceUnitContext::getRuleIndex() const {
|
|
return SolidityParser::RuleSourceUnit;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::SourceUnitContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitSourceUnit(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::SourceUnitContext* SolidityParser::sourceUnit() {
|
|
SourceUnitContext *_localctx = _tracker.createInstance<SourceUnitContext>(_ctx, getState());
|
|
enterRule(_localctx, 0, SolidityParser::RuleSourceUnit);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(174);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & ((1ULL << SolidityParser::Pragma)
|
|
| (1ULL << SolidityParser::Abstract)
|
|
| (1ULL << SolidityParser::Contract)
|
|
| (1ULL << SolidityParser::Enum)
|
|
| (1ULL << SolidityParser::Function)
|
|
| (1ULL << SolidityParser::Import)
|
|
| (1ULL << SolidityParser::Interface)
|
|
| (1ULL << SolidityParser::Library)
|
|
| (1ULL << SolidityParser::Struct))) != 0)) {
|
|
setState(172);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case SolidityParser::Pragma: {
|
|
setState(164);
|
|
pragmaDirective();
|
|
break;
|
|
}
|
|
|
|
case SolidityParser::Import: {
|
|
setState(165);
|
|
importDirective();
|
|
break;
|
|
}
|
|
|
|
case SolidityParser::Abstract:
|
|
case SolidityParser::Contract: {
|
|
setState(166);
|
|
contractDefinition();
|
|
break;
|
|
}
|
|
|
|
case SolidityParser::Interface: {
|
|
setState(167);
|
|
interfaceDefinition();
|
|
break;
|
|
}
|
|
|
|
case SolidityParser::Library: {
|
|
setState(168);
|
|
libraryDefinition();
|
|
break;
|
|
}
|
|
|
|
case SolidityParser::Function: {
|
|
setState(169);
|
|
functionDefinition();
|
|
break;
|
|
}
|
|
|
|
case SolidityParser::Struct: {
|
|
setState(170);
|
|
structDefinition();
|
|
break;
|
|
}
|
|
|
|
case SolidityParser::Enum: {
|
|
setState(171);
|
|
enumDefinition();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
setState(176);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
setState(177);
|
|
match(SolidityParser::EOF);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- PragmaDirectiveContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::PragmaDirectiveContext::PragmaDirectiveContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::PragmaDirectiveContext::Pragma() {
|
|
return getToken(SolidityParser::Pragma, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::PragmaDirectiveContext::PragmaSemicolon() {
|
|
return getToken(SolidityParser::PragmaSemicolon, 0);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::PragmaDirectiveContext::PragmaToken() {
|
|
return getTokens(SolidityParser::PragmaToken);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::PragmaDirectiveContext::PragmaToken(size_t i) {
|
|
return getToken(SolidityParser::PragmaToken, i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::PragmaDirectiveContext::getRuleIndex() const {
|
|
return SolidityParser::RulePragmaDirective;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::PragmaDirectiveContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitPragmaDirective(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::PragmaDirectiveContext* SolidityParser::pragmaDirective() {
|
|
PragmaDirectiveContext *_localctx = _tracker.createInstance<PragmaDirectiveContext>(_ctx, getState());
|
|
enterRule(_localctx, 2, SolidityParser::RulePragmaDirective);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(179);
|
|
match(SolidityParser::Pragma);
|
|
setState(181);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
do {
|
|
setState(180);
|
|
match(SolidityParser::PragmaToken);
|
|
setState(183);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
} while (_la == SolidityParser::PragmaToken);
|
|
setState(185);
|
|
match(SolidityParser::PragmaSemicolon);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ImportDirectiveContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::ImportDirectiveContext::ImportDirectiveContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ImportDirectiveContext::Import() {
|
|
return getToken(SolidityParser::Import, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ImportDirectiveContext::Semicolon() {
|
|
return getToken(SolidityParser::Semicolon, 0);
|
|
}
|
|
|
|
SolidityParser::PathContext* SolidityParser::ImportDirectiveContext::path() {
|
|
return getRuleContext<SolidityParser::PathContext>(0);
|
|
}
|
|
|
|
SolidityParser::SymbolAliasesContext* SolidityParser::ImportDirectiveContext::symbolAliases() {
|
|
return getRuleContext<SolidityParser::SymbolAliasesContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ImportDirectiveContext::From() {
|
|
return getToken(SolidityParser::From, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ImportDirectiveContext::Mul() {
|
|
return getToken(SolidityParser::Mul, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ImportDirectiveContext::As() {
|
|
return getToken(SolidityParser::As, 0);
|
|
}
|
|
|
|
SolidityParser::IdentifierContext* SolidityParser::ImportDirectiveContext::identifier() {
|
|
return getRuleContext<SolidityParser::IdentifierContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::ImportDirectiveContext::getRuleIndex() const {
|
|
return SolidityParser::RuleImportDirective;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::ImportDirectiveContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitImportDirective(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::ImportDirectiveContext* SolidityParser::importDirective() {
|
|
ImportDirectiveContext *_localctx = _tracker.createInstance<ImportDirectiveContext>(_ctx, getState());
|
|
enterRule(_localctx, 4, SolidityParser::RuleImportDirective);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(187);
|
|
match(SolidityParser::Import);
|
|
setState(203);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case SolidityParser::NonEmptyStringLiteral: {
|
|
setState(188);
|
|
path();
|
|
setState(191);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == SolidityParser::As) {
|
|
setState(189);
|
|
match(SolidityParser::As);
|
|
setState(190);
|
|
dynamic_cast<ImportDirectiveContext *>(_localctx)->unitAlias = identifier();
|
|
}
|
|
break;
|
|
}
|
|
|
|
case SolidityParser::LBrace: {
|
|
setState(193);
|
|
symbolAliases();
|
|
setState(194);
|
|
match(SolidityParser::From);
|
|
setState(195);
|
|
path();
|
|
break;
|
|
}
|
|
|
|
case SolidityParser::Mul: {
|
|
setState(197);
|
|
match(SolidityParser::Mul);
|
|
setState(198);
|
|
match(SolidityParser::As);
|
|
setState(199);
|
|
dynamic_cast<ImportDirectiveContext *>(_localctx)->unitAlias = identifier();
|
|
setState(200);
|
|
match(SolidityParser::From);
|
|
setState(201);
|
|
path();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
setState(205);
|
|
match(SolidityParser::Semicolon);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ImportAliasesContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::ImportAliasesContext::ImportAliasesContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<SolidityParser::IdentifierContext *> SolidityParser::ImportAliasesContext::identifier() {
|
|
return getRuleContexts<SolidityParser::IdentifierContext>();
|
|
}
|
|
|
|
SolidityParser::IdentifierContext* SolidityParser::ImportAliasesContext::identifier(size_t i) {
|
|
return getRuleContext<SolidityParser::IdentifierContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ImportAliasesContext::As() {
|
|
return getToken(SolidityParser::As, 0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::ImportAliasesContext::getRuleIndex() const {
|
|
return SolidityParser::RuleImportAliases;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::ImportAliasesContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitImportAliases(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::ImportAliasesContext* SolidityParser::importAliases() {
|
|
ImportAliasesContext *_localctx = _tracker.createInstance<ImportAliasesContext>(_ctx, getState());
|
|
enterRule(_localctx, 6, SolidityParser::RuleImportAliases);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(207);
|
|
dynamic_cast<ImportAliasesContext *>(_localctx)->symbol = identifier();
|
|
setState(210);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == SolidityParser::As) {
|
|
setState(208);
|
|
match(SolidityParser::As);
|
|
setState(209);
|
|
dynamic_cast<ImportAliasesContext *>(_localctx)->alias = identifier();
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- PathContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::PathContext::PathContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::PathContext::NonEmptyStringLiteral() {
|
|
return getToken(SolidityParser::NonEmptyStringLiteral, 0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::PathContext::getRuleIndex() const {
|
|
return SolidityParser::RulePath;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::PathContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitPath(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::PathContext* SolidityParser::path() {
|
|
PathContext *_localctx = _tracker.createInstance<PathContext>(_ctx, getState());
|
|
enterRule(_localctx, 8, SolidityParser::RulePath);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(212);
|
|
match(SolidityParser::NonEmptyStringLiteral);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- SymbolAliasesContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::SymbolAliasesContext::SymbolAliasesContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::SymbolAliasesContext::LBrace() {
|
|
return getToken(SolidityParser::LBrace, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::SymbolAliasesContext::RBrace() {
|
|
return getToken(SolidityParser::RBrace, 0);
|
|
}
|
|
|
|
std::vector<SolidityParser::ImportAliasesContext *> SolidityParser::SymbolAliasesContext::importAliases() {
|
|
return getRuleContexts<SolidityParser::ImportAliasesContext>();
|
|
}
|
|
|
|
SolidityParser::ImportAliasesContext* SolidityParser::SymbolAliasesContext::importAliases(size_t i) {
|
|
return getRuleContext<SolidityParser::ImportAliasesContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::SymbolAliasesContext::Comma() {
|
|
return getTokens(SolidityParser::Comma);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::SymbolAliasesContext::Comma(size_t i) {
|
|
return getToken(SolidityParser::Comma, i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::SymbolAliasesContext::getRuleIndex() const {
|
|
return SolidityParser::RuleSymbolAliases;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::SymbolAliasesContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitSymbolAliases(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::SymbolAliasesContext* SolidityParser::symbolAliases() {
|
|
SymbolAliasesContext *_localctx = _tracker.createInstance<SymbolAliasesContext>(_ctx, getState());
|
|
enterRule(_localctx, 10, SolidityParser::RuleSymbolAliases);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(214);
|
|
match(SolidityParser::LBrace);
|
|
setState(215);
|
|
dynamic_cast<SymbolAliasesContext *>(_localctx)->importAliasesContext = importAliases();
|
|
dynamic_cast<SymbolAliasesContext *>(_localctx)->aliases.push_back(dynamic_cast<SymbolAliasesContext *>(_localctx)->importAliasesContext);
|
|
setState(220);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == SolidityParser::Comma) {
|
|
setState(216);
|
|
match(SolidityParser::Comma);
|
|
setState(217);
|
|
dynamic_cast<SymbolAliasesContext *>(_localctx)->importAliasesContext = importAliases();
|
|
dynamic_cast<SymbolAliasesContext *>(_localctx)->aliases.push_back(dynamic_cast<SymbolAliasesContext *>(_localctx)->importAliasesContext);
|
|
setState(222);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
setState(223);
|
|
match(SolidityParser::RBrace);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ContractDefinitionContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::ContractDefinitionContext::ContractDefinitionContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ContractDefinitionContext::Contract() {
|
|
return getToken(SolidityParser::Contract, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ContractDefinitionContext::LBrace() {
|
|
return getToken(SolidityParser::LBrace, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ContractDefinitionContext::RBrace() {
|
|
return getToken(SolidityParser::RBrace, 0);
|
|
}
|
|
|
|
SolidityParser::IdentifierContext* SolidityParser::ContractDefinitionContext::identifier() {
|
|
return getRuleContext<SolidityParser::IdentifierContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ContractDefinitionContext::Abstract() {
|
|
return getToken(SolidityParser::Abstract, 0);
|
|
}
|
|
|
|
SolidityParser::InheritanceSpecifierListContext* SolidityParser::ContractDefinitionContext::inheritanceSpecifierList() {
|
|
return getRuleContext<SolidityParser::InheritanceSpecifierListContext>(0);
|
|
}
|
|
|
|
std::vector<SolidityParser::ContractBodyElementContext *> SolidityParser::ContractDefinitionContext::contractBodyElement() {
|
|
return getRuleContexts<SolidityParser::ContractBodyElementContext>();
|
|
}
|
|
|
|
SolidityParser::ContractBodyElementContext* SolidityParser::ContractDefinitionContext::contractBodyElement(size_t i) {
|
|
return getRuleContext<SolidityParser::ContractBodyElementContext>(i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::ContractDefinitionContext::getRuleIndex() const {
|
|
return SolidityParser::RuleContractDefinition;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::ContractDefinitionContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitContractDefinition(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::ContractDefinitionContext* SolidityParser::contractDefinition() {
|
|
ContractDefinitionContext *_localctx = _tracker.createInstance<ContractDefinitionContext>(_ctx, getState());
|
|
enterRule(_localctx, 12, SolidityParser::RuleContractDefinition);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(226);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == SolidityParser::Abstract) {
|
|
setState(225);
|
|
match(SolidityParser::Abstract);
|
|
}
|
|
setState(228);
|
|
match(SolidityParser::Contract);
|
|
setState(229);
|
|
dynamic_cast<ContractDefinitionContext *>(_localctx)->name = identifier();
|
|
setState(231);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == SolidityParser::Is) {
|
|
setState(230);
|
|
inheritanceSpecifierList();
|
|
}
|
|
setState(233);
|
|
match(SolidityParser::LBrace);
|
|
setState(237);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 9, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
setState(234);
|
|
contractBodyElement();
|
|
}
|
|
setState(239);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 9, _ctx);
|
|
}
|
|
setState(240);
|
|
match(SolidityParser::RBrace);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- InterfaceDefinitionContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::InterfaceDefinitionContext::InterfaceDefinitionContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::InterfaceDefinitionContext::Interface() {
|
|
return getToken(SolidityParser::Interface, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::InterfaceDefinitionContext::LBrace() {
|
|
return getToken(SolidityParser::LBrace, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::InterfaceDefinitionContext::RBrace() {
|
|
return getToken(SolidityParser::RBrace, 0);
|
|
}
|
|
|
|
SolidityParser::IdentifierContext* SolidityParser::InterfaceDefinitionContext::identifier() {
|
|
return getRuleContext<SolidityParser::IdentifierContext>(0);
|
|
}
|
|
|
|
SolidityParser::InheritanceSpecifierListContext* SolidityParser::InterfaceDefinitionContext::inheritanceSpecifierList() {
|
|
return getRuleContext<SolidityParser::InheritanceSpecifierListContext>(0);
|
|
}
|
|
|
|
std::vector<SolidityParser::ContractBodyElementContext *> SolidityParser::InterfaceDefinitionContext::contractBodyElement() {
|
|
return getRuleContexts<SolidityParser::ContractBodyElementContext>();
|
|
}
|
|
|
|
SolidityParser::ContractBodyElementContext* SolidityParser::InterfaceDefinitionContext::contractBodyElement(size_t i) {
|
|
return getRuleContext<SolidityParser::ContractBodyElementContext>(i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::InterfaceDefinitionContext::getRuleIndex() const {
|
|
return SolidityParser::RuleInterfaceDefinition;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::InterfaceDefinitionContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitInterfaceDefinition(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::InterfaceDefinitionContext* SolidityParser::interfaceDefinition() {
|
|
InterfaceDefinitionContext *_localctx = _tracker.createInstance<InterfaceDefinitionContext>(_ctx, getState());
|
|
enterRule(_localctx, 14, SolidityParser::RuleInterfaceDefinition);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(242);
|
|
match(SolidityParser::Interface);
|
|
setState(243);
|
|
dynamic_cast<InterfaceDefinitionContext *>(_localctx)->name = identifier();
|
|
setState(245);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == SolidityParser::Is) {
|
|
setState(244);
|
|
inheritanceSpecifierList();
|
|
}
|
|
setState(247);
|
|
match(SolidityParser::LBrace);
|
|
setState(251);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 11, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
setState(248);
|
|
contractBodyElement();
|
|
}
|
|
setState(253);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 11, _ctx);
|
|
}
|
|
setState(254);
|
|
match(SolidityParser::RBrace);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- LibraryDefinitionContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::LibraryDefinitionContext::LibraryDefinitionContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::LibraryDefinitionContext::Library() {
|
|
return getToken(SolidityParser::Library, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::LibraryDefinitionContext::LBrace() {
|
|
return getToken(SolidityParser::LBrace, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::LibraryDefinitionContext::RBrace() {
|
|
return getToken(SolidityParser::RBrace, 0);
|
|
}
|
|
|
|
SolidityParser::IdentifierContext* SolidityParser::LibraryDefinitionContext::identifier() {
|
|
return getRuleContext<SolidityParser::IdentifierContext>(0);
|
|
}
|
|
|
|
std::vector<SolidityParser::ContractBodyElementContext *> SolidityParser::LibraryDefinitionContext::contractBodyElement() {
|
|
return getRuleContexts<SolidityParser::ContractBodyElementContext>();
|
|
}
|
|
|
|
SolidityParser::ContractBodyElementContext* SolidityParser::LibraryDefinitionContext::contractBodyElement(size_t i) {
|
|
return getRuleContext<SolidityParser::ContractBodyElementContext>(i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::LibraryDefinitionContext::getRuleIndex() const {
|
|
return SolidityParser::RuleLibraryDefinition;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::LibraryDefinitionContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitLibraryDefinition(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::LibraryDefinitionContext* SolidityParser::libraryDefinition() {
|
|
LibraryDefinitionContext *_localctx = _tracker.createInstance<LibraryDefinitionContext>(_ctx, getState());
|
|
enterRule(_localctx, 16, SolidityParser::RuleLibraryDefinition);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(256);
|
|
match(SolidityParser::Library);
|
|
setState(257);
|
|
dynamic_cast<LibraryDefinitionContext *>(_localctx)->name = identifier();
|
|
setState(258);
|
|
match(SolidityParser::LBrace);
|
|
setState(262);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 12, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
setState(259);
|
|
contractBodyElement();
|
|
}
|
|
setState(264);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 12, _ctx);
|
|
}
|
|
setState(265);
|
|
match(SolidityParser::RBrace);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- InheritanceSpecifierListContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::InheritanceSpecifierListContext::InheritanceSpecifierListContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::InheritanceSpecifierListContext::Is() {
|
|
return getToken(SolidityParser::Is, 0);
|
|
}
|
|
|
|
std::vector<SolidityParser::InheritanceSpecifierContext *> SolidityParser::InheritanceSpecifierListContext::inheritanceSpecifier() {
|
|
return getRuleContexts<SolidityParser::InheritanceSpecifierContext>();
|
|
}
|
|
|
|
SolidityParser::InheritanceSpecifierContext* SolidityParser::InheritanceSpecifierListContext::inheritanceSpecifier(size_t i) {
|
|
return getRuleContext<SolidityParser::InheritanceSpecifierContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::InheritanceSpecifierListContext::Comma() {
|
|
return getTokens(SolidityParser::Comma);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::InheritanceSpecifierListContext::Comma(size_t i) {
|
|
return getToken(SolidityParser::Comma, i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::InheritanceSpecifierListContext::getRuleIndex() const {
|
|
return SolidityParser::RuleInheritanceSpecifierList;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::InheritanceSpecifierListContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitInheritanceSpecifierList(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::InheritanceSpecifierListContext* SolidityParser::inheritanceSpecifierList() {
|
|
InheritanceSpecifierListContext *_localctx = _tracker.createInstance<InheritanceSpecifierListContext>(_ctx, getState());
|
|
enterRule(_localctx, 18, SolidityParser::RuleInheritanceSpecifierList);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(267);
|
|
match(SolidityParser::Is);
|
|
setState(268);
|
|
dynamic_cast<InheritanceSpecifierListContext *>(_localctx)->inheritanceSpecifierContext = inheritanceSpecifier();
|
|
dynamic_cast<InheritanceSpecifierListContext *>(_localctx)->inheritanceSpecifiers.push_back(dynamic_cast<InheritanceSpecifierListContext *>(_localctx)->inheritanceSpecifierContext);
|
|
setState(273);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 13, _ctx);
|
|
while (alt != 1 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1 + 1) {
|
|
setState(269);
|
|
match(SolidityParser::Comma);
|
|
setState(270);
|
|
dynamic_cast<InheritanceSpecifierListContext *>(_localctx)->inheritanceSpecifierContext = inheritanceSpecifier();
|
|
dynamic_cast<InheritanceSpecifierListContext *>(_localctx)->inheritanceSpecifiers.push_back(dynamic_cast<InheritanceSpecifierListContext *>(_localctx)->inheritanceSpecifierContext);
|
|
}
|
|
setState(275);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 13, _ctx);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- InheritanceSpecifierContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::InheritanceSpecifierContext::InheritanceSpecifierContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
SolidityParser::UserDefinedTypeNameContext* SolidityParser::InheritanceSpecifierContext::userDefinedTypeName() {
|
|
return getRuleContext<SolidityParser::UserDefinedTypeNameContext>(0);
|
|
}
|
|
|
|
SolidityParser::CallArgumentListContext* SolidityParser::InheritanceSpecifierContext::callArgumentList() {
|
|
return getRuleContext<SolidityParser::CallArgumentListContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::InheritanceSpecifierContext::getRuleIndex() const {
|
|
return SolidityParser::RuleInheritanceSpecifier;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::InheritanceSpecifierContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitInheritanceSpecifier(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::InheritanceSpecifierContext* SolidityParser::inheritanceSpecifier() {
|
|
InheritanceSpecifierContext *_localctx = _tracker.createInstance<InheritanceSpecifierContext>(_ctx, getState());
|
|
enterRule(_localctx, 20, SolidityParser::RuleInheritanceSpecifier);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(276);
|
|
dynamic_cast<InheritanceSpecifierContext *>(_localctx)->name = userDefinedTypeName();
|
|
setState(278);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == SolidityParser::LParen) {
|
|
setState(277);
|
|
dynamic_cast<InheritanceSpecifierContext *>(_localctx)->arguments = callArgumentList();
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ContractBodyElementContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::ContractBodyElementContext::ContractBodyElementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
SolidityParser::ConstructorDefinitionContext* SolidityParser::ContractBodyElementContext::constructorDefinition() {
|
|
return getRuleContext<SolidityParser::ConstructorDefinitionContext>(0);
|
|
}
|
|
|
|
SolidityParser::FunctionDefinitionContext* SolidityParser::ContractBodyElementContext::functionDefinition() {
|
|
return getRuleContext<SolidityParser::FunctionDefinitionContext>(0);
|
|
}
|
|
|
|
SolidityParser::ModifierDefinitionContext* SolidityParser::ContractBodyElementContext::modifierDefinition() {
|
|
return getRuleContext<SolidityParser::ModifierDefinitionContext>(0);
|
|
}
|
|
|
|
SolidityParser::FallbackReceiveFunctionDefinitionContext* SolidityParser::ContractBodyElementContext::fallbackReceiveFunctionDefinition() {
|
|
return getRuleContext<SolidityParser::FallbackReceiveFunctionDefinitionContext>(0);
|
|
}
|
|
|
|
SolidityParser::StructDefinitionContext* SolidityParser::ContractBodyElementContext::structDefinition() {
|
|
return getRuleContext<SolidityParser::StructDefinitionContext>(0);
|
|
}
|
|
|
|
SolidityParser::EnumDefinitionContext* SolidityParser::ContractBodyElementContext::enumDefinition() {
|
|
return getRuleContext<SolidityParser::EnumDefinitionContext>(0);
|
|
}
|
|
|
|
SolidityParser::StateVariableDeclarationContext* SolidityParser::ContractBodyElementContext::stateVariableDeclaration() {
|
|
return getRuleContext<SolidityParser::StateVariableDeclarationContext>(0);
|
|
}
|
|
|
|
SolidityParser::EventDefinitionContext* SolidityParser::ContractBodyElementContext::eventDefinition() {
|
|
return getRuleContext<SolidityParser::EventDefinitionContext>(0);
|
|
}
|
|
|
|
SolidityParser::UsingDirectiveContext* SolidityParser::ContractBodyElementContext::usingDirective() {
|
|
return getRuleContext<SolidityParser::UsingDirectiveContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::ContractBodyElementContext::getRuleIndex() const {
|
|
return SolidityParser::RuleContractBodyElement;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::ContractBodyElementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitContractBodyElement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::ContractBodyElementContext* SolidityParser::contractBodyElement() {
|
|
ContractBodyElementContext *_localctx = _tracker.createInstance<ContractBodyElementContext>(_ctx, getState());
|
|
enterRule(_localctx, 22, SolidityParser::RuleContractBodyElement);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(289);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 15, _ctx)) {
|
|
case 1: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(280);
|
|
constructorDefinition();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(281);
|
|
functionDefinition();
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(282);
|
|
modifierDefinition();
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
enterOuterAlt(_localctx, 4);
|
|
setState(283);
|
|
fallbackReceiveFunctionDefinition();
|
|
break;
|
|
}
|
|
|
|
case 5: {
|
|
enterOuterAlt(_localctx, 5);
|
|
setState(284);
|
|
structDefinition();
|
|
break;
|
|
}
|
|
|
|
case 6: {
|
|
enterOuterAlt(_localctx, 6);
|
|
setState(285);
|
|
enumDefinition();
|
|
break;
|
|
}
|
|
|
|
case 7: {
|
|
enterOuterAlt(_localctx, 7);
|
|
setState(286);
|
|
stateVariableDeclaration();
|
|
break;
|
|
}
|
|
|
|
case 8: {
|
|
enterOuterAlt(_localctx, 8);
|
|
setState(287);
|
|
eventDefinition();
|
|
break;
|
|
}
|
|
|
|
case 9: {
|
|
enterOuterAlt(_localctx, 9);
|
|
setState(288);
|
|
usingDirective();
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- NamedArgumentContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::NamedArgumentContext::NamedArgumentContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::NamedArgumentContext::Colon() {
|
|
return getToken(SolidityParser::Colon, 0);
|
|
}
|
|
|
|
SolidityParser::IdentifierContext* SolidityParser::NamedArgumentContext::identifier() {
|
|
return getRuleContext<SolidityParser::IdentifierContext>(0);
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::NamedArgumentContext::expression() {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::NamedArgumentContext::getRuleIndex() const {
|
|
return SolidityParser::RuleNamedArgument;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::NamedArgumentContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitNamedArgument(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::NamedArgumentContext* SolidityParser::namedArgument() {
|
|
NamedArgumentContext *_localctx = _tracker.createInstance<NamedArgumentContext>(_ctx, getState());
|
|
enterRule(_localctx, 24, SolidityParser::RuleNamedArgument);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(291);
|
|
dynamic_cast<NamedArgumentContext *>(_localctx)->name = identifier();
|
|
setState(292);
|
|
match(SolidityParser::Colon);
|
|
setState(293);
|
|
dynamic_cast<NamedArgumentContext *>(_localctx)->value = expression(0);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- CallArgumentListContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::CallArgumentListContext::CallArgumentListContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::CallArgumentListContext::LParen() {
|
|
return getToken(SolidityParser::LParen, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::CallArgumentListContext::RParen() {
|
|
return getToken(SolidityParser::RParen, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::CallArgumentListContext::LBrace() {
|
|
return getToken(SolidityParser::LBrace, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::CallArgumentListContext::RBrace() {
|
|
return getToken(SolidityParser::RBrace, 0);
|
|
}
|
|
|
|
std::vector<SolidityParser::ExpressionContext *> SolidityParser::CallArgumentListContext::expression() {
|
|
return getRuleContexts<SolidityParser::ExpressionContext>();
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::CallArgumentListContext::expression(size_t i) {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(i);
|
|
}
|
|
|
|
std::vector<SolidityParser::NamedArgumentContext *> SolidityParser::CallArgumentListContext::namedArgument() {
|
|
return getRuleContexts<SolidityParser::NamedArgumentContext>();
|
|
}
|
|
|
|
SolidityParser::NamedArgumentContext* SolidityParser::CallArgumentListContext::namedArgument(size_t i) {
|
|
return getRuleContext<SolidityParser::NamedArgumentContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::CallArgumentListContext::Comma() {
|
|
return getTokens(SolidityParser::Comma);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::CallArgumentListContext::Comma(size_t i) {
|
|
return getToken(SolidityParser::Comma, i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::CallArgumentListContext::getRuleIndex() const {
|
|
return SolidityParser::RuleCallArgumentList;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::CallArgumentListContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitCallArgumentList(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::CallArgumentListContext* SolidityParser::callArgumentList() {
|
|
CallArgumentListContext *_localctx = _tracker.createInstance<CallArgumentListContext>(_ctx, getState());
|
|
enterRule(_localctx, 26, SolidityParser::RuleCallArgumentList);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(295);
|
|
match(SolidityParser::LParen);
|
|
setState(318);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 20, _ctx)) {
|
|
case 1: {
|
|
setState(304);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 17, _ctx)) {
|
|
case 1: {
|
|
setState(296);
|
|
expression(0);
|
|
setState(301);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == SolidityParser::Comma) {
|
|
setState(297);
|
|
match(SolidityParser::Comma);
|
|
setState(298);
|
|
expression(0);
|
|
setState(303);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
break;
|
|
}
|
|
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(306);
|
|
match(SolidityParser::LBrace);
|
|
setState(315);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == SolidityParser::From || _la == SolidityParser::Identifier) {
|
|
setState(307);
|
|
namedArgument();
|
|
setState(312);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == SolidityParser::Comma) {
|
|
setState(308);
|
|
match(SolidityParser::Comma);
|
|
setState(309);
|
|
namedArgument();
|
|
setState(314);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
}
|
|
setState(317);
|
|
match(SolidityParser::RBrace);
|
|
break;
|
|
}
|
|
|
|
}
|
|
setState(320);
|
|
match(SolidityParser::RParen);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- UserDefinedTypeNameContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::UserDefinedTypeNameContext::UserDefinedTypeNameContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<SolidityParser::IdentifierContext *> SolidityParser::UserDefinedTypeNameContext::identifier() {
|
|
return getRuleContexts<SolidityParser::IdentifierContext>();
|
|
}
|
|
|
|
SolidityParser::IdentifierContext* SolidityParser::UserDefinedTypeNameContext::identifier(size_t i) {
|
|
return getRuleContext<SolidityParser::IdentifierContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::UserDefinedTypeNameContext::Period() {
|
|
return getTokens(SolidityParser::Period);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::UserDefinedTypeNameContext::Period(size_t i) {
|
|
return getToken(SolidityParser::Period, i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::UserDefinedTypeNameContext::getRuleIndex() const {
|
|
return SolidityParser::RuleUserDefinedTypeName;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::UserDefinedTypeNameContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitUserDefinedTypeName(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::UserDefinedTypeNameContext* SolidityParser::userDefinedTypeName() {
|
|
UserDefinedTypeNameContext *_localctx = _tracker.createInstance<UserDefinedTypeNameContext>(_ctx, getState());
|
|
enterRule(_localctx, 28, SolidityParser::RuleUserDefinedTypeName);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(322);
|
|
identifier();
|
|
setState(327);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 21, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
setState(323);
|
|
match(SolidityParser::Period);
|
|
setState(324);
|
|
identifier();
|
|
}
|
|
setState(329);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 21, _ctx);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ModifierInvocationContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::ModifierInvocationContext::ModifierInvocationContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
SolidityParser::IdentifierContext* SolidityParser::ModifierInvocationContext::identifier() {
|
|
return getRuleContext<SolidityParser::IdentifierContext>(0);
|
|
}
|
|
|
|
SolidityParser::CallArgumentListContext* SolidityParser::ModifierInvocationContext::callArgumentList() {
|
|
return getRuleContext<SolidityParser::CallArgumentListContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::ModifierInvocationContext::getRuleIndex() const {
|
|
return SolidityParser::RuleModifierInvocation;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::ModifierInvocationContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitModifierInvocation(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::ModifierInvocationContext* SolidityParser::modifierInvocation() {
|
|
ModifierInvocationContext *_localctx = _tracker.createInstance<ModifierInvocationContext>(_ctx, getState());
|
|
enterRule(_localctx, 30, SolidityParser::RuleModifierInvocation);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(330);
|
|
identifier();
|
|
setState(332);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 22, _ctx)) {
|
|
case 1: {
|
|
setState(331);
|
|
callArgumentList();
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- VisibilityContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::VisibilityContext::VisibilityContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::VisibilityContext::Internal() {
|
|
return getToken(SolidityParser::Internal, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::VisibilityContext::External() {
|
|
return getToken(SolidityParser::External, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::VisibilityContext::Private() {
|
|
return getToken(SolidityParser::Private, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::VisibilityContext::Public() {
|
|
return getToken(SolidityParser::Public, 0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::VisibilityContext::getRuleIndex() const {
|
|
return SolidityParser::RuleVisibility;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::VisibilityContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitVisibility(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::VisibilityContext* SolidityParser::visibility() {
|
|
VisibilityContext *_localctx = _tracker.createInstance<VisibilityContext>(_ctx, getState());
|
|
enterRule(_localctx, 32, SolidityParser::RuleVisibility);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(334);
|
|
_la = _input->LA(1);
|
|
if (!((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & ((1ULL << SolidityParser::External)
|
|
| (1ULL << SolidityParser::Internal)
|
|
| (1ULL << SolidityParser::Private)
|
|
| (1ULL << SolidityParser::Public))) != 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;
|
|
}
|
|
|
|
//----------------- ParameterListContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::ParameterListContext::ParameterListContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<SolidityParser::ParameterDeclarationContext *> SolidityParser::ParameterListContext::parameterDeclaration() {
|
|
return getRuleContexts<SolidityParser::ParameterDeclarationContext>();
|
|
}
|
|
|
|
SolidityParser::ParameterDeclarationContext* SolidityParser::ParameterListContext::parameterDeclaration(size_t i) {
|
|
return getRuleContext<SolidityParser::ParameterDeclarationContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::ParameterListContext::Comma() {
|
|
return getTokens(SolidityParser::Comma);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ParameterListContext::Comma(size_t i) {
|
|
return getToken(SolidityParser::Comma, i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::ParameterListContext::getRuleIndex() const {
|
|
return SolidityParser::RuleParameterList;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::ParameterListContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitParameterList(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::ParameterListContext* SolidityParser::parameterList() {
|
|
ParameterListContext *_localctx = _tracker.createInstance<ParameterListContext>(_ctx, getState());
|
|
enterRule(_localctx, 34, SolidityParser::RuleParameterList);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(336);
|
|
dynamic_cast<ParameterListContext *>(_localctx)->parameterDeclarationContext = parameterDeclaration();
|
|
dynamic_cast<ParameterListContext *>(_localctx)->parameters.push_back(dynamic_cast<ParameterListContext *>(_localctx)->parameterDeclarationContext);
|
|
setState(341);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == SolidityParser::Comma) {
|
|
setState(337);
|
|
match(SolidityParser::Comma);
|
|
setState(338);
|
|
dynamic_cast<ParameterListContext *>(_localctx)->parameterDeclarationContext = parameterDeclaration();
|
|
dynamic_cast<ParameterListContext *>(_localctx)->parameters.push_back(dynamic_cast<ParameterListContext *>(_localctx)->parameterDeclarationContext);
|
|
setState(343);
|
|
_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;
|
|
}
|
|
|
|
//----------------- ParameterDeclarationContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::ParameterDeclarationContext::ParameterDeclarationContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
SolidityParser::TypeNameContext* SolidityParser::ParameterDeclarationContext::typeName() {
|
|
return getRuleContext<SolidityParser::TypeNameContext>(0);
|
|
}
|
|
|
|
SolidityParser::DataLocationContext* SolidityParser::ParameterDeclarationContext::dataLocation() {
|
|
return getRuleContext<SolidityParser::DataLocationContext>(0);
|
|
}
|
|
|
|
SolidityParser::IdentifierContext* SolidityParser::ParameterDeclarationContext::identifier() {
|
|
return getRuleContext<SolidityParser::IdentifierContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::ParameterDeclarationContext::getRuleIndex() const {
|
|
return SolidityParser::RuleParameterDeclaration;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::ParameterDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitParameterDeclaration(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::ParameterDeclarationContext* SolidityParser::parameterDeclaration() {
|
|
ParameterDeclarationContext *_localctx = _tracker.createInstance<ParameterDeclarationContext>(_ctx, getState());
|
|
enterRule(_localctx, 36, SolidityParser::RuleParameterDeclaration);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(344);
|
|
dynamic_cast<ParameterDeclarationContext *>(_localctx)->type = typeName(0);
|
|
setState(346);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & ((1ULL << SolidityParser::Calldata)
|
|
| (1ULL << SolidityParser::Memory)
|
|
| (1ULL << SolidityParser::Storage))) != 0)) {
|
|
setState(345);
|
|
dynamic_cast<ParameterDeclarationContext *>(_localctx)->location = dataLocation();
|
|
}
|
|
setState(349);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == SolidityParser::From || _la == SolidityParser::Identifier) {
|
|
setState(348);
|
|
dynamic_cast<ParameterDeclarationContext *>(_localctx)->name = identifier();
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ConstructorDefinitionContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::ConstructorDefinitionContext::ConstructorDefinitionContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ConstructorDefinitionContext::Constructor() {
|
|
return getToken(SolidityParser::Constructor, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ConstructorDefinitionContext::LParen() {
|
|
return getToken(SolidityParser::LParen, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ConstructorDefinitionContext::RParen() {
|
|
return getToken(SolidityParser::RParen, 0);
|
|
}
|
|
|
|
SolidityParser::BlockContext* SolidityParser::ConstructorDefinitionContext::block() {
|
|
return getRuleContext<SolidityParser::BlockContext>(0);
|
|
}
|
|
|
|
std::vector<SolidityParser::ModifierInvocationContext *> SolidityParser::ConstructorDefinitionContext::modifierInvocation() {
|
|
return getRuleContexts<SolidityParser::ModifierInvocationContext>();
|
|
}
|
|
|
|
SolidityParser::ModifierInvocationContext* SolidityParser::ConstructorDefinitionContext::modifierInvocation(size_t i) {
|
|
return getRuleContext<SolidityParser::ModifierInvocationContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::ConstructorDefinitionContext::Payable() {
|
|
return getTokens(SolidityParser::Payable);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ConstructorDefinitionContext::Payable(size_t i) {
|
|
return getToken(SolidityParser::Payable, i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::ConstructorDefinitionContext::Internal() {
|
|
return getTokens(SolidityParser::Internal);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ConstructorDefinitionContext::Internal(size_t i) {
|
|
return getToken(SolidityParser::Internal, i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::ConstructorDefinitionContext::Public() {
|
|
return getTokens(SolidityParser::Public);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ConstructorDefinitionContext::Public(size_t i) {
|
|
return getToken(SolidityParser::Public, i);
|
|
}
|
|
|
|
SolidityParser::ParameterListContext* SolidityParser::ConstructorDefinitionContext::parameterList() {
|
|
return getRuleContext<SolidityParser::ParameterListContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::ConstructorDefinitionContext::getRuleIndex() const {
|
|
return SolidityParser::RuleConstructorDefinition;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::ConstructorDefinitionContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitConstructorDefinition(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::ConstructorDefinitionContext* SolidityParser::constructorDefinition() {
|
|
ConstructorDefinitionContext *_localctx = _tracker.createInstance<ConstructorDefinitionContext>(_ctx, getState());
|
|
enterRule(_localctx, 38, SolidityParser::RuleConstructorDefinition);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(351);
|
|
match(SolidityParser::Constructor);
|
|
setState(352);
|
|
match(SolidityParser::LParen);
|
|
setState(354);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 26, _ctx)) {
|
|
case 1: {
|
|
setState(353);
|
|
dynamic_cast<ConstructorDefinitionContext *>(_localctx)->arguments = parameterList();
|
|
break;
|
|
}
|
|
|
|
}
|
|
setState(356);
|
|
match(SolidityParser::RParen);
|
|
setState(369);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 28, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
setState(367);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 27, _ctx)) {
|
|
case 1: {
|
|
setState(357);
|
|
modifierInvocation();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(358);
|
|
|
|
if (!(!_localctx->payableSet)) throw FailedPredicateException(this, "!$payableSet");
|
|
setState(359);
|
|
match(SolidityParser::Payable);
|
|
dynamic_cast<ConstructorDefinitionContext *>(_localctx)->payableSet = true;
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
setState(361);
|
|
|
|
if (!(!_localctx->visibilitySet)) throw FailedPredicateException(this, "!$visibilitySet");
|
|
setState(362);
|
|
match(SolidityParser::Internal);
|
|
dynamic_cast<ConstructorDefinitionContext *>(_localctx)->visibilitySet = true;
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
setState(364);
|
|
|
|
if (!(!_localctx->visibilitySet)) throw FailedPredicateException(this, "!$visibilitySet");
|
|
setState(365);
|
|
match(SolidityParser::Public);
|
|
dynamic_cast<ConstructorDefinitionContext *>(_localctx)->visibilitySet = true;
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
setState(371);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 28, _ctx);
|
|
}
|
|
setState(372);
|
|
dynamic_cast<ConstructorDefinitionContext *>(_localctx)->body = block();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- StateMutabilityContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::StateMutabilityContext::StateMutabilityContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::StateMutabilityContext::Pure() {
|
|
return getToken(SolidityParser::Pure, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::StateMutabilityContext::View() {
|
|
return getToken(SolidityParser::View, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::StateMutabilityContext::Payable() {
|
|
return getToken(SolidityParser::Payable, 0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::StateMutabilityContext::getRuleIndex() const {
|
|
return SolidityParser::RuleStateMutability;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::StateMutabilityContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitStateMutability(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::StateMutabilityContext* SolidityParser::stateMutability() {
|
|
StateMutabilityContext *_localctx = _tracker.createInstance<StateMutabilityContext>(_ctx, getState());
|
|
enterRule(_localctx, 40, SolidityParser::RuleStateMutability);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(374);
|
|
_la = _input->LA(1);
|
|
if (!((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & ((1ULL << SolidityParser::Payable)
|
|
| (1ULL << SolidityParser::Pure)
|
|
| (1ULL << SolidityParser::View))) != 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;
|
|
}
|
|
|
|
//----------------- OverrideSpecifierContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::OverrideSpecifierContext::OverrideSpecifierContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::OverrideSpecifierContext::Override() {
|
|
return getToken(SolidityParser::Override, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::OverrideSpecifierContext::LParen() {
|
|
return getToken(SolidityParser::LParen, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::OverrideSpecifierContext::RParen() {
|
|
return getToken(SolidityParser::RParen, 0);
|
|
}
|
|
|
|
std::vector<SolidityParser::UserDefinedTypeNameContext *> SolidityParser::OverrideSpecifierContext::userDefinedTypeName() {
|
|
return getRuleContexts<SolidityParser::UserDefinedTypeNameContext>();
|
|
}
|
|
|
|
SolidityParser::UserDefinedTypeNameContext* SolidityParser::OverrideSpecifierContext::userDefinedTypeName(size_t i) {
|
|
return getRuleContext<SolidityParser::UserDefinedTypeNameContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::OverrideSpecifierContext::Comma() {
|
|
return getTokens(SolidityParser::Comma);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::OverrideSpecifierContext::Comma(size_t i) {
|
|
return getToken(SolidityParser::Comma, i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::OverrideSpecifierContext::getRuleIndex() const {
|
|
return SolidityParser::RuleOverrideSpecifier;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::OverrideSpecifierContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitOverrideSpecifier(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::OverrideSpecifierContext* SolidityParser::overrideSpecifier() {
|
|
OverrideSpecifierContext *_localctx = _tracker.createInstance<OverrideSpecifierContext>(_ctx, getState());
|
|
enterRule(_localctx, 42, SolidityParser::RuleOverrideSpecifier);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(376);
|
|
match(SolidityParser::Override);
|
|
setState(388);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 30, _ctx)) {
|
|
case 1: {
|
|
setState(377);
|
|
match(SolidityParser::LParen);
|
|
setState(378);
|
|
dynamic_cast<OverrideSpecifierContext *>(_localctx)->userDefinedTypeNameContext = userDefinedTypeName();
|
|
dynamic_cast<OverrideSpecifierContext *>(_localctx)->overrides.push_back(dynamic_cast<OverrideSpecifierContext *>(_localctx)->userDefinedTypeNameContext);
|
|
setState(383);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == SolidityParser::Comma) {
|
|
setState(379);
|
|
match(SolidityParser::Comma);
|
|
setState(380);
|
|
dynamic_cast<OverrideSpecifierContext *>(_localctx)->userDefinedTypeNameContext = userDefinedTypeName();
|
|
dynamic_cast<OverrideSpecifierContext *>(_localctx)->overrides.push_back(dynamic_cast<OverrideSpecifierContext *>(_localctx)->userDefinedTypeNameContext);
|
|
setState(385);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
setState(386);
|
|
match(SolidityParser::RParen);
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- FunctionDefinitionContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::FunctionDefinitionContext::FunctionDefinitionContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::FunctionDefinitionContext::Function() {
|
|
return getToken(SolidityParser::Function, 0);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::FunctionDefinitionContext::LParen() {
|
|
return getTokens(SolidityParser::LParen);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::FunctionDefinitionContext::LParen(size_t i) {
|
|
return getToken(SolidityParser::LParen, i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::FunctionDefinitionContext::RParen() {
|
|
return getTokens(SolidityParser::RParen);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::FunctionDefinitionContext::RParen(size_t i) {
|
|
return getToken(SolidityParser::RParen, i);
|
|
}
|
|
|
|
SolidityParser::IdentifierContext* SolidityParser::FunctionDefinitionContext::identifier() {
|
|
return getRuleContext<SolidityParser::IdentifierContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::FunctionDefinitionContext::Fallback() {
|
|
return getToken(SolidityParser::Fallback, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::FunctionDefinitionContext::Receive() {
|
|
return getToken(SolidityParser::Receive, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::FunctionDefinitionContext::Semicolon() {
|
|
return getToken(SolidityParser::Semicolon, 0);
|
|
}
|
|
|
|
std::vector<SolidityParser::VisibilityContext *> SolidityParser::FunctionDefinitionContext::visibility() {
|
|
return getRuleContexts<SolidityParser::VisibilityContext>();
|
|
}
|
|
|
|
SolidityParser::VisibilityContext* SolidityParser::FunctionDefinitionContext::visibility(size_t i) {
|
|
return getRuleContext<SolidityParser::VisibilityContext>(i);
|
|
}
|
|
|
|
std::vector<SolidityParser::StateMutabilityContext *> SolidityParser::FunctionDefinitionContext::stateMutability() {
|
|
return getRuleContexts<SolidityParser::StateMutabilityContext>();
|
|
}
|
|
|
|
SolidityParser::StateMutabilityContext* SolidityParser::FunctionDefinitionContext::stateMutability(size_t i) {
|
|
return getRuleContext<SolidityParser::StateMutabilityContext>(i);
|
|
}
|
|
|
|
std::vector<SolidityParser::ModifierInvocationContext *> SolidityParser::FunctionDefinitionContext::modifierInvocation() {
|
|
return getRuleContexts<SolidityParser::ModifierInvocationContext>();
|
|
}
|
|
|
|
SolidityParser::ModifierInvocationContext* SolidityParser::FunctionDefinitionContext::modifierInvocation(size_t i) {
|
|
return getRuleContext<SolidityParser::ModifierInvocationContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::FunctionDefinitionContext::Virtual() {
|
|
return getTokens(SolidityParser::Virtual);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::FunctionDefinitionContext::Virtual(size_t i) {
|
|
return getToken(SolidityParser::Virtual, i);
|
|
}
|
|
|
|
std::vector<SolidityParser::OverrideSpecifierContext *> SolidityParser::FunctionDefinitionContext::overrideSpecifier() {
|
|
return getRuleContexts<SolidityParser::OverrideSpecifierContext>();
|
|
}
|
|
|
|
SolidityParser::OverrideSpecifierContext* SolidityParser::FunctionDefinitionContext::overrideSpecifier(size_t i) {
|
|
return getRuleContext<SolidityParser::OverrideSpecifierContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::FunctionDefinitionContext::Returns() {
|
|
return getToken(SolidityParser::Returns, 0);
|
|
}
|
|
|
|
SolidityParser::BlockContext* SolidityParser::FunctionDefinitionContext::block() {
|
|
return getRuleContext<SolidityParser::BlockContext>(0);
|
|
}
|
|
|
|
std::vector<SolidityParser::ParameterListContext *> SolidityParser::FunctionDefinitionContext::parameterList() {
|
|
return getRuleContexts<SolidityParser::ParameterListContext>();
|
|
}
|
|
|
|
SolidityParser::ParameterListContext* SolidityParser::FunctionDefinitionContext::parameterList(size_t i) {
|
|
return getRuleContext<SolidityParser::ParameterListContext>(i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::FunctionDefinitionContext::getRuleIndex() const {
|
|
return SolidityParser::RuleFunctionDefinition;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::FunctionDefinitionContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitFunctionDefinition(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::FunctionDefinitionContext* SolidityParser::functionDefinition() {
|
|
FunctionDefinitionContext *_localctx = _tracker.createInstance<FunctionDefinitionContext>(_ctx, getState());
|
|
enterRule(_localctx, 44, SolidityParser::RuleFunctionDefinition);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(390);
|
|
match(SolidityParser::Function);
|
|
setState(394);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case SolidityParser::From:
|
|
case SolidityParser::Identifier: {
|
|
setState(391);
|
|
identifier();
|
|
break;
|
|
}
|
|
|
|
case SolidityParser::Fallback: {
|
|
setState(392);
|
|
match(SolidityParser::Fallback);
|
|
break;
|
|
}
|
|
|
|
case SolidityParser::Receive: {
|
|
setState(393);
|
|
match(SolidityParser::Receive);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
setState(396);
|
|
match(SolidityParser::LParen);
|
|
setState(398);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 32, _ctx)) {
|
|
case 1: {
|
|
setState(397);
|
|
dynamic_cast<FunctionDefinitionContext *>(_localctx)->arguments = parameterList();
|
|
break;
|
|
}
|
|
|
|
}
|
|
setState(400);
|
|
match(SolidityParser::RParen);
|
|
setState(419);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 34, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
setState(417);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 33, _ctx)) {
|
|
case 1: {
|
|
setState(401);
|
|
|
|
if (!(!_localctx->visibilitySet)) throw FailedPredicateException(this, "!$visibilitySet");
|
|
setState(402);
|
|
visibility();
|
|
dynamic_cast<FunctionDefinitionContext *>(_localctx)->visibilitySet = true;
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(405);
|
|
|
|
if (!(!_localctx->mutabilitySet)) throw FailedPredicateException(this, "!$mutabilitySet");
|
|
setState(406);
|
|
stateMutability();
|
|
dynamic_cast<FunctionDefinitionContext *>(_localctx)->mutabilitySet = true;
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
setState(409);
|
|
modifierInvocation();
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
setState(410);
|
|
|
|
if (!(!_localctx->virtualSet)) throw FailedPredicateException(this, "!$virtualSet");
|
|
setState(411);
|
|
match(SolidityParser::Virtual);
|
|
dynamic_cast<FunctionDefinitionContext *>(_localctx)->virtualSet = true;
|
|
break;
|
|
}
|
|
|
|
case 5: {
|
|
setState(413);
|
|
|
|
if (!(!_localctx->overrideSpecifierSet)) throw FailedPredicateException(this, "!$overrideSpecifierSet");
|
|
setState(414);
|
|
overrideSpecifier();
|
|
dynamic_cast<FunctionDefinitionContext *>(_localctx)->overrideSpecifierSet = true;
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
setState(421);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 34, _ctx);
|
|
}
|
|
setState(427);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == SolidityParser::Returns) {
|
|
setState(422);
|
|
match(SolidityParser::Returns);
|
|
setState(423);
|
|
match(SolidityParser::LParen);
|
|
setState(424);
|
|
dynamic_cast<FunctionDefinitionContext *>(_localctx)->returnParameters = parameterList();
|
|
setState(425);
|
|
match(SolidityParser::RParen);
|
|
}
|
|
setState(431);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case SolidityParser::Semicolon: {
|
|
setState(429);
|
|
match(SolidityParser::Semicolon);
|
|
break;
|
|
}
|
|
|
|
case SolidityParser::LBrace: {
|
|
setState(430);
|
|
dynamic_cast<FunctionDefinitionContext *>(_localctx)->body = 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;
|
|
}
|
|
|
|
//----------------- ModifierDefinitionContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::ModifierDefinitionContext::ModifierDefinitionContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ModifierDefinitionContext::Modifier() {
|
|
return getToken(SolidityParser::Modifier, 0);
|
|
}
|
|
|
|
SolidityParser::IdentifierContext* SolidityParser::ModifierDefinitionContext::identifier() {
|
|
return getRuleContext<SolidityParser::IdentifierContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ModifierDefinitionContext::Semicolon() {
|
|
return getToken(SolidityParser::Semicolon, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ModifierDefinitionContext::LParen() {
|
|
return getToken(SolidityParser::LParen, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ModifierDefinitionContext::RParen() {
|
|
return getToken(SolidityParser::RParen, 0);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::ModifierDefinitionContext::Virtual() {
|
|
return getTokens(SolidityParser::Virtual);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ModifierDefinitionContext::Virtual(size_t i) {
|
|
return getToken(SolidityParser::Virtual, i);
|
|
}
|
|
|
|
std::vector<SolidityParser::OverrideSpecifierContext *> SolidityParser::ModifierDefinitionContext::overrideSpecifier() {
|
|
return getRuleContexts<SolidityParser::OverrideSpecifierContext>();
|
|
}
|
|
|
|
SolidityParser::OverrideSpecifierContext* SolidityParser::ModifierDefinitionContext::overrideSpecifier(size_t i) {
|
|
return getRuleContext<SolidityParser::OverrideSpecifierContext>(i);
|
|
}
|
|
|
|
SolidityParser::BlockContext* SolidityParser::ModifierDefinitionContext::block() {
|
|
return getRuleContext<SolidityParser::BlockContext>(0);
|
|
}
|
|
|
|
SolidityParser::ParameterListContext* SolidityParser::ModifierDefinitionContext::parameterList() {
|
|
return getRuleContext<SolidityParser::ParameterListContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::ModifierDefinitionContext::getRuleIndex() const {
|
|
return SolidityParser::RuleModifierDefinition;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::ModifierDefinitionContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitModifierDefinition(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::ModifierDefinitionContext* SolidityParser::modifierDefinition() {
|
|
ModifierDefinitionContext *_localctx = _tracker.createInstance<ModifierDefinitionContext>(_ctx, getState());
|
|
enterRule(_localctx, 46, SolidityParser::RuleModifierDefinition);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(433);
|
|
match(SolidityParser::Modifier);
|
|
setState(434);
|
|
dynamic_cast<ModifierDefinitionContext *>(_localctx)->name = identifier();
|
|
setState(440);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 38, _ctx)) {
|
|
case 1: {
|
|
setState(435);
|
|
match(SolidityParser::LParen);
|
|
setState(437);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 37, _ctx)) {
|
|
case 1: {
|
|
setState(436);
|
|
dynamic_cast<ModifierDefinitionContext *>(_localctx)->arguments = parameterList();
|
|
break;
|
|
}
|
|
|
|
}
|
|
setState(439);
|
|
match(SolidityParser::RParen);
|
|
break;
|
|
}
|
|
|
|
}
|
|
setState(451);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 40, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
setState(449);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 39, _ctx)) {
|
|
case 1: {
|
|
setState(442);
|
|
|
|
if (!(!_localctx->virtualSet)) throw FailedPredicateException(this, "!$virtualSet");
|
|
setState(443);
|
|
match(SolidityParser::Virtual);
|
|
dynamic_cast<ModifierDefinitionContext *>(_localctx)->virtualSet = true;
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(445);
|
|
|
|
if (!(!_localctx->overrideSpecifierSet)) throw FailedPredicateException(this, "!$overrideSpecifierSet");
|
|
setState(446);
|
|
overrideSpecifier();
|
|
dynamic_cast<ModifierDefinitionContext *>(_localctx)->overrideSpecifierSet = true;
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
setState(453);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 40, _ctx);
|
|
}
|
|
setState(456);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case SolidityParser::Semicolon: {
|
|
setState(454);
|
|
match(SolidityParser::Semicolon);
|
|
break;
|
|
}
|
|
|
|
case SolidityParser::LBrace: {
|
|
setState(455);
|
|
dynamic_cast<ModifierDefinitionContext *>(_localctx)->body = 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;
|
|
}
|
|
|
|
//----------------- FallbackReceiveFunctionDefinitionContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::FallbackReceiveFunctionDefinitionContext::FallbackReceiveFunctionDefinitionContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::FallbackReceiveFunctionDefinitionContext::LParen() {
|
|
return getToken(SolidityParser::LParen, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::FallbackReceiveFunctionDefinitionContext::RParen() {
|
|
return getToken(SolidityParser::RParen, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::FallbackReceiveFunctionDefinitionContext::Fallback() {
|
|
return getToken(SolidityParser::Fallback, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::FallbackReceiveFunctionDefinitionContext::Receive() {
|
|
return getToken(SolidityParser::Receive, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::FallbackReceiveFunctionDefinitionContext::Semicolon() {
|
|
return getToken(SolidityParser::Semicolon, 0);
|
|
}
|
|
|
|
std::vector<SolidityParser::VisibilityContext *> SolidityParser::FallbackReceiveFunctionDefinitionContext::visibility() {
|
|
return getRuleContexts<SolidityParser::VisibilityContext>();
|
|
}
|
|
|
|
SolidityParser::VisibilityContext* SolidityParser::FallbackReceiveFunctionDefinitionContext::visibility(size_t i) {
|
|
return getRuleContext<SolidityParser::VisibilityContext>(i);
|
|
}
|
|
|
|
std::vector<SolidityParser::StateMutabilityContext *> SolidityParser::FallbackReceiveFunctionDefinitionContext::stateMutability() {
|
|
return getRuleContexts<SolidityParser::StateMutabilityContext>();
|
|
}
|
|
|
|
SolidityParser::StateMutabilityContext* SolidityParser::FallbackReceiveFunctionDefinitionContext::stateMutability(size_t i) {
|
|
return getRuleContext<SolidityParser::StateMutabilityContext>(i);
|
|
}
|
|
|
|
std::vector<SolidityParser::ModifierInvocationContext *> SolidityParser::FallbackReceiveFunctionDefinitionContext::modifierInvocation() {
|
|
return getRuleContexts<SolidityParser::ModifierInvocationContext>();
|
|
}
|
|
|
|
SolidityParser::ModifierInvocationContext* SolidityParser::FallbackReceiveFunctionDefinitionContext::modifierInvocation(size_t i) {
|
|
return getRuleContext<SolidityParser::ModifierInvocationContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::FallbackReceiveFunctionDefinitionContext::Virtual() {
|
|
return getTokens(SolidityParser::Virtual);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::FallbackReceiveFunctionDefinitionContext::Virtual(size_t i) {
|
|
return getToken(SolidityParser::Virtual, i);
|
|
}
|
|
|
|
std::vector<SolidityParser::OverrideSpecifierContext *> SolidityParser::FallbackReceiveFunctionDefinitionContext::overrideSpecifier() {
|
|
return getRuleContexts<SolidityParser::OverrideSpecifierContext>();
|
|
}
|
|
|
|
SolidityParser::OverrideSpecifierContext* SolidityParser::FallbackReceiveFunctionDefinitionContext::overrideSpecifier(size_t i) {
|
|
return getRuleContext<SolidityParser::OverrideSpecifierContext>(i);
|
|
}
|
|
|
|
SolidityParser::BlockContext* SolidityParser::FallbackReceiveFunctionDefinitionContext::block() {
|
|
return getRuleContext<SolidityParser::BlockContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::FallbackReceiveFunctionDefinitionContext::getRuleIndex() const {
|
|
return SolidityParser::RuleFallbackReceiveFunctionDefinition;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::FallbackReceiveFunctionDefinitionContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitFallbackReceiveFunctionDefinition(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::FallbackReceiveFunctionDefinitionContext* SolidityParser::fallbackReceiveFunctionDefinition() {
|
|
FallbackReceiveFunctionDefinitionContext *_localctx = _tracker.createInstance<FallbackReceiveFunctionDefinitionContext>(_ctx, getState());
|
|
enterRule(_localctx, 48, SolidityParser::RuleFallbackReceiveFunctionDefinition);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(458);
|
|
dynamic_cast<FallbackReceiveFunctionDefinitionContext *>(_localctx)->kind = _input->LT(1);
|
|
_la = _input->LA(1);
|
|
if (!(_la == SolidityParser::Fallback
|
|
|
|
|| _la == SolidityParser::Receive)) {
|
|
dynamic_cast<FallbackReceiveFunctionDefinitionContext *>(_localctx)->kind = _errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(459);
|
|
match(SolidityParser::LParen);
|
|
setState(460);
|
|
match(SolidityParser::RParen);
|
|
setState(479);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 43, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
setState(477);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 42, _ctx)) {
|
|
case 1: {
|
|
setState(461);
|
|
|
|
if (!(!_localctx->visibilitySet)) throw FailedPredicateException(this, "!$visibilitySet");
|
|
setState(462);
|
|
visibility();
|
|
dynamic_cast<FallbackReceiveFunctionDefinitionContext *>(_localctx)->visibilitySet = true;
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(465);
|
|
|
|
if (!(!_localctx->mutabilitySet)) throw FailedPredicateException(this, "!$mutabilitySet");
|
|
setState(466);
|
|
stateMutability();
|
|
dynamic_cast<FallbackReceiveFunctionDefinitionContext *>(_localctx)->mutabilitySet = true;
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
setState(469);
|
|
modifierInvocation();
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
setState(470);
|
|
|
|
if (!(!_localctx->virtualSet)) throw FailedPredicateException(this, "!$virtualSet");
|
|
setState(471);
|
|
match(SolidityParser::Virtual);
|
|
dynamic_cast<FallbackReceiveFunctionDefinitionContext *>(_localctx)->virtualSet = true;
|
|
break;
|
|
}
|
|
|
|
case 5: {
|
|
setState(473);
|
|
|
|
if (!(!_localctx->overrideSpecifierSet)) throw FailedPredicateException(this, "!$overrideSpecifierSet");
|
|
setState(474);
|
|
overrideSpecifier();
|
|
dynamic_cast<FallbackReceiveFunctionDefinitionContext *>(_localctx)->overrideSpecifierSet = true;
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
setState(481);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 43, _ctx);
|
|
}
|
|
setState(484);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case SolidityParser::Semicolon: {
|
|
setState(482);
|
|
match(SolidityParser::Semicolon);
|
|
break;
|
|
}
|
|
|
|
case SolidityParser::LBrace: {
|
|
setState(483);
|
|
dynamic_cast<FallbackReceiveFunctionDefinitionContext *>(_localctx)->body = 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;
|
|
}
|
|
|
|
//----------------- StructDefinitionContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::StructDefinitionContext::StructDefinitionContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::StructDefinitionContext::Struct() {
|
|
return getToken(SolidityParser::Struct, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::StructDefinitionContext::LBrace() {
|
|
return getToken(SolidityParser::LBrace, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::StructDefinitionContext::RBrace() {
|
|
return getToken(SolidityParser::RBrace, 0);
|
|
}
|
|
|
|
SolidityParser::IdentifierContext* SolidityParser::StructDefinitionContext::identifier() {
|
|
return getRuleContext<SolidityParser::IdentifierContext>(0);
|
|
}
|
|
|
|
std::vector<SolidityParser::StructMemberContext *> SolidityParser::StructDefinitionContext::structMember() {
|
|
return getRuleContexts<SolidityParser::StructMemberContext>();
|
|
}
|
|
|
|
SolidityParser::StructMemberContext* SolidityParser::StructDefinitionContext::structMember(size_t i) {
|
|
return getRuleContext<SolidityParser::StructMemberContext>(i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::StructDefinitionContext::getRuleIndex() const {
|
|
return SolidityParser::RuleStructDefinition;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::StructDefinitionContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitStructDefinition(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::StructDefinitionContext* SolidityParser::structDefinition() {
|
|
StructDefinitionContext *_localctx = _tracker.createInstance<StructDefinitionContext>(_ctx, getState());
|
|
enterRule(_localctx, 50, SolidityParser::RuleStructDefinition);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(486);
|
|
match(SolidityParser::Struct);
|
|
setState(487);
|
|
dynamic_cast<StructDefinitionContext *>(_localctx)->name = identifier();
|
|
setState(488);
|
|
match(SolidityParser::LBrace);
|
|
setState(490);
|
|
_errHandler->sync(this);
|
|
alt = 1;
|
|
do {
|
|
switch (alt) {
|
|
case 1: {
|
|
setState(489);
|
|
dynamic_cast<StructDefinitionContext *>(_localctx)->members = structMember();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
setState(492);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 45, _ctx);
|
|
} while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
|
|
setState(494);
|
|
match(SolidityParser::RBrace);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- StructMemberContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::StructMemberContext::StructMemberContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::StructMemberContext::Semicolon() {
|
|
return getToken(SolidityParser::Semicolon, 0);
|
|
}
|
|
|
|
SolidityParser::TypeNameContext* SolidityParser::StructMemberContext::typeName() {
|
|
return getRuleContext<SolidityParser::TypeNameContext>(0);
|
|
}
|
|
|
|
SolidityParser::IdentifierContext* SolidityParser::StructMemberContext::identifier() {
|
|
return getRuleContext<SolidityParser::IdentifierContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::StructMemberContext::getRuleIndex() const {
|
|
return SolidityParser::RuleStructMember;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::StructMemberContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitStructMember(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::StructMemberContext* SolidityParser::structMember() {
|
|
StructMemberContext *_localctx = _tracker.createInstance<StructMemberContext>(_ctx, getState());
|
|
enterRule(_localctx, 52, SolidityParser::RuleStructMember);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(496);
|
|
dynamic_cast<StructMemberContext *>(_localctx)->type = typeName(0);
|
|
setState(497);
|
|
dynamic_cast<StructMemberContext *>(_localctx)->name = identifier();
|
|
setState(498);
|
|
match(SolidityParser::Semicolon);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- EnumDefinitionContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::EnumDefinitionContext::EnumDefinitionContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::EnumDefinitionContext::Enum() {
|
|
return getToken(SolidityParser::Enum, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::EnumDefinitionContext::LBrace() {
|
|
return getToken(SolidityParser::LBrace, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::EnumDefinitionContext::RBrace() {
|
|
return getToken(SolidityParser::RBrace, 0);
|
|
}
|
|
|
|
std::vector<SolidityParser::IdentifierContext *> SolidityParser::EnumDefinitionContext::identifier() {
|
|
return getRuleContexts<SolidityParser::IdentifierContext>();
|
|
}
|
|
|
|
SolidityParser::IdentifierContext* SolidityParser::EnumDefinitionContext::identifier(size_t i) {
|
|
return getRuleContext<SolidityParser::IdentifierContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::EnumDefinitionContext::Comma() {
|
|
return getTokens(SolidityParser::Comma);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::EnumDefinitionContext::Comma(size_t i) {
|
|
return getToken(SolidityParser::Comma, i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::EnumDefinitionContext::getRuleIndex() const {
|
|
return SolidityParser::RuleEnumDefinition;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::EnumDefinitionContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitEnumDefinition(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::EnumDefinitionContext* SolidityParser::enumDefinition() {
|
|
EnumDefinitionContext *_localctx = _tracker.createInstance<EnumDefinitionContext>(_ctx, getState());
|
|
enterRule(_localctx, 54, SolidityParser::RuleEnumDefinition);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(500);
|
|
match(SolidityParser::Enum);
|
|
setState(501);
|
|
dynamic_cast<EnumDefinitionContext *>(_localctx)->name = identifier();
|
|
setState(502);
|
|
match(SolidityParser::LBrace);
|
|
setState(503);
|
|
dynamic_cast<EnumDefinitionContext *>(_localctx)->identifierContext = identifier();
|
|
dynamic_cast<EnumDefinitionContext *>(_localctx)->enumValues.push_back(dynamic_cast<EnumDefinitionContext *>(_localctx)->identifierContext);
|
|
setState(508);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == SolidityParser::Comma) {
|
|
setState(504);
|
|
match(SolidityParser::Comma);
|
|
setState(505);
|
|
dynamic_cast<EnumDefinitionContext *>(_localctx)->identifierContext = identifier();
|
|
dynamic_cast<EnumDefinitionContext *>(_localctx)->enumValues.push_back(dynamic_cast<EnumDefinitionContext *>(_localctx)->identifierContext);
|
|
setState(510);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
setState(511);
|
|
match(SolidityParser::RBrace);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- StateVariableDeclarationContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::StateVariableDeclarationContext::StateVariableDeclarationContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::StateVariableDeclarationContext::Semicolon() {
|
|
return getToken(SolidityParser::Semicolon, 0);
|
|
}
|
|
|
|
SolidityParser::TypeNameContext* SolidityParser::StateVariableDeclarationContext::typeName() {
|
|
return getRuleContext<SolidityParser::TypeNameContext>(0);
|
|
}
|
|
|
|
SolidityParser::IdentifierContext* SolidityParser::StateVariableDeclarationContext::identifier() {
|
|
return getRuleContext<SolidityParser::IdentifierContext>(0);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::StateVariableDeclarationContext::Public() {
|
|
return getTokens(SolidityParser::Public);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::StateVariableDeclarationContext::Public(size_t i) {
|
|
return getToken(SolidityParser::Public, i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::StateVariableDeclarationContext::Private() {
|
|
return getTokens(SolidityParser::Private);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::StateVariableDeclarationContext::Private(size_t i) {
|
|
return getToken(SolidityParser::Private, i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::StateVariableDeclarationContext::Internal() {
|
|
return getTokens(SolidityParser::Internal);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::StateVariableDeclarationContext::Internal(size_t i) {
|
|
return getToken(SolidityParser::Internal, i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::StateVariableDeclarationContext::Constant() {
|
|
return getTokens(SolidityParser::Constant);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::StateVariableDeclarationContext::Constant(size_t i) {
|
|
return getToken(SolidityParser::Constant, i);
|
|
}
|
|
|
|
std::vector<SolidityParser::OverrideSpecifierContext *> SolidityParser::StateVariableDeclarationContext::overrideSpecifier() {
|
|
return getRuleContexts<SolidityParser::OverrideSpecifierContext>();
|
|
}
|
|
|
|
SolidityParser::OverrideSpecifierContext* SolidityParser::StateVariableDeclarationContext::overrideSpecifier(size_t i) {
|
|
return getRuleContext<SolidityParser::OverrideSpecifierContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::StateVariableDeclarationContext::Immutable() {
|
|
return getTokens(SolidityParser::Immutable);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::StateVariableDeclarationContext::Immutable(size_t i) {
|
|
return getToken(SolidityParser::Immutable, i);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::StateVariableDeclarationContext::Assign() {
|
|
return getToken(SolidityParser::Assign, 0);
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::StateVariableDeclarationContext::expression() {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::StateVariableDeclarationContext::getRuleIndex() const {
|
|
return SolidityParser::RuleStateVariableDeclaration;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::StateVariableDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitStateVariableDeclaration(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::StateVariableDeclarationContext* SolidityParser::stateVariableDeclaration() {
|
|
StateVariableDeclarationContext *_localctx = _tracker.createInstance<StateVariableDeclarationContext>(_ctx, getState());
|
|
enterRule(_localctx, 56, SolidityParser::RuleStateVariableDeclaration);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(513);
|
|
dynamic_cast<StateVariableDeclarationContext *>(_localctx)->type = typeName(0);
|
|
setState(535);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 48, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
setState(533);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 47, _ctx)) {
|
|
case 1: {
|
|
setState(514);
|
|
|
|
if (!(!_localctx->visibilitySet)) throw FailedPredicateException(this, "!$visibilitySet");
|
|
setState(515);
|
|
match(SolidityParser::Public);
|
|
dynamic_cast<StateVariableDeclarationContext *>(_localctx)->visibilitySet = true;
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(517);
|
|
|
|
if (!(!_localctx->visibilitySet)) throw FailedPredicateException(this, "!$visibilitySet");
|
|
setState(518);
|
|
match(SolidityParser::Private);
|
|
dynamic_cast<StateVariableDeclarationContext *>(_localctx)->visibilitySet = true;
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
setState(520);
|
|
|
|
if (!(!_localctx->visibilitySet)) throw FailedPredicateException(this, "!$visibilitySet");
|
|
setState(521);
|
|
match(SolidityParser::Internal);
|
|
dynamic_cast<StateVariableDeclarationContext *>(_localctx)->visibilitySet = true;
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
setState(523);
|
|
|
|
if (!(!_localctx->constantnessSet)) throw FailedPredicateException(this, "!$constantnessSet");
|
|
setState(524);
|
|
match(SolidityParser::Constant);
|
|
dynamic_cast<StateVariableDeclarationContext *>(_localctx)->constantnessSet = true;
|
|
break;
|
|
}
|
|
|
|
case 5: {
|
|
setState(526);
|
|
|
|
if (!(!_localctx->overrideSpecifierSet)) throw FailedPredicateException(this, "!$overrideSpecifierSet");
|
|
setState(527);
|
|
overrideSpecifier();
|
|
dynamic_cast<StateVariableDeclarationContext *>(_localctx)->overrideSpecifierSet = true;
|
|
break;
|
|
}
|
|
|
|
case 6: {
|
|
setState(530);
|
|
|
|
if (!(!_localctx->constantnessSet)) throw FailedPredicateException(this, "!$constantnessSet");
|
|
setState(531);
|
|
match(SolidityParser::Immutable);
|
|
dynamic_cast<StateVariableDeclarationContext *>(_localctx)->constantnessSet = true;
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
setState(537);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 48, _ctx);
|
|
}
|
|
setState(538);
|
|
dynamic_cast<StateVariableDeclarationContext *>(_localctx)->name = identifier();
|
|
setState(541);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == SolidityParser::Assign) {
|
|
setState(539);
|
|
match(SolidityParser::Assign);
|
|
setState(540);
|
|
dynamic_cast<StateVariableDeclarationContext *>(_localctx)->initialValue = expression(0);
|
|
}
|
|
setState(543);
|
|
match(SolidityParser::Semicolon);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- EventParameterContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::EventParameterContext::EventParameterContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
SolidityParser::TypeNameContext* SolidityParser::EventParameterContext::typeName() {
|
|
return getRuleContext<SolidityParser::TypeNameContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::EventParameterContext::Indexed() {
|
|
return getToken(SolidityParser::Indexed, 0);
|
|
}
|
|
|
|
SolidityParser::IdentifierContext* SolidityParser::EventParameterContext::identifier() {
|
|
return getRuleContext<SolidityParser::IdentifierContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::EventParameterContext::getRuleIndex() const {
|
|
return SolidityParser::RuleEventParameter;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::EventParameterContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitEventParameter(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::EventParameterContext* SolidityParser::eventParameter() {
|
|
EventParameterContext *_localctx = _tracker.createInstance<EventParameterContext>(_ctx, getState());
|
|
enterRule(_localctx, 58, SolidityParser::RuleEventParameter);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(545);
|
|
dynamic_cast<EventParameterContext *>(_localctx)->type = typeName(0);
|
|
setState(547);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == SolidityParser::Indexed) {
|
|
setState(546);
|
|
match(SolidityParser::Indexed);
|
|
}
|
|
setState(550);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == SolidityParser::From || _la == SolidityParser::Identifier) {
|
|
setState(549);
|
|
dynamic_cast<EventParameterContext *>(_localctx)->name = identifier();
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- EventDefinitionContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::EventDefinitionContext::EventDefinitionContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::EventDefinitionContext::Event() {
|
|
return getToken(SolidityParser::Event, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::EventDefinitionContext::LParen() {
|
|
return getToken(SolidityParser::LParen, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::EventDefinitionContext::RParen() {
|
|
return getToken(SolidityParser::RParen, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::EventDefinitionContext::Semicolon() {
|
|
return getToken(SolidityParser::Semicolon, 0);
|
|
}
|
|
|
|
SolidityParser::IdentifierContext* SolidityParser::EventDefinitionContext::identifier() {
|
|
return getRuleContext<SolidityParser::IdentifierContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::EventDefinitionContext::Anonymous() {
|
|
return getToken(SolidityParser::Anonymous, 0);
|
|
}
|
|
|
|
std::vector<SolidityParser::EventParameterContext *> SolidityParser::EventDefinitionContext::eventParameter() {
|
|
return getRuleContexts<SolidityParser::EventParameterContext>();
|
|
}
|
|
|
|
SolidityParser::EventParameterContext* SolidityParser::EventDefinitionContext::eventParameter(size_t i) {
|
|
return getRuleContext<SolidityParser::EventParameterContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::EventDefinitionContext::Comma() {
|
|
return getTokens(SolidityParser::Comma);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::EventDefinitionContext::Comma(size_t i) {
|
|
return getToken(SolidityParser::Comma, i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::EventDefinitionContext::getRuleIndex() const {
|
|
return SolidityParser::RuleEventDefinition;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::EventDefinitionContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitEventDefinition(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::EventDefinitionContext* SolidityParser::eventDefinition() {
|
|
EventDefinitionContext *_localctx = _tracker.createInstance<EventDefinitionContext>(_ctx, getState());
|
|
enterRule(_localctx, 60, SolidityParser::RuleEventDefinition);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(552);
|
|
match(SolidityParser::Event);
|
|
setState(553);
|
|
dynamic_cast<EventDefinitionContext *>(_localctx)->name = identifier();
|
|
setState(554);
|
|
match(SolidityParser::LParen);
|
|
setState(563);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 53, _ctx)) {
|
|
case 1: {
|
|
setState(555);
|
|
dynamic_cast<EventDefinitionContext *>(_localctx)->eventParameterContext = eventParameter();
|
|
dynamic_cast<EventDefinitionContext *>(_localctx)->parameters.push_back(dynamic_cast<EventDefinitionContext *>(_localctx)->eventParameterContext);
|
|
setState(560);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == SolidityParser::Comma) {
|
|
setState(556);
|
|
match(SolidityParser::Comma);
|
|
setState(557);
|
|
dynamic_cast<EventDefinitionContext *>(_localctx)->eventParameterContext = eventParameter();
|
|
dynamic_cast<EventDefinitionContext *>(_localctx)->parameters.push_back(dynamic_cast<EventDefinitionContext *>(_localctx)->eventParameterContext);
|
|
setState(562);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
break;
|
|
}
|
|
|
|
}
|
|
setState(565);
|
|
match(SolidityParser::RParen);
|
|
setState(567);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == SolidityParser::Anonymous) {
|
|
setState(566);
|
|
match(SolidityParser::Anonymous);
|
|
}
|
|
setState(569);
|
|
match(SolidityParser::Semicolon);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- UsingDirectiveContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::UsingDirectiveContext::UsingDirectiveContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::UsingDirectiveContext::Using() {
|
|
return getToken(SolidityParser::Using, 0);
|
|
}
|
|
|
|
SolidityParser::UserDefinedTypeNameContext* SolidityParser::UsingDirectiveContext::userDefinedTypeName() {
|
|
return getRuleContext<SolidityParser::UserDefinedTypeNameContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::UsingDirectiveContext::For() {
|
|
return getToken(SolidityParser::For, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::UsingDirectiveContext::Semicolon() {
|
|
return getToken(SolidityParser::Semicolon, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::UsingDirectiveContext::Mul() {
|
|
return getToken(SolidityParser::Mul, 0);
|
|
}
|
|
|
|
SolidityParser::TypeNameContext* SolidityParser::UsingDirectiveContext::typeName() {
|
|
return getRuleContext<SolidityParser::TypeNameContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::UsingDirectiveContext::getRuleIndex() const {
|
|
return SolidityParser::RuleUsingDirective;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::UsingDirectiveContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitUsingDirective(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::UsingDirectiveContext* SolidityParser::usingDirective() {
|
|
UsingDirectiveContext *_localctx = _tracker.createInstance<UsingDirectiveContext>(_ctx, getState());
|
|
enterRule(_localctx, 62, SolidityParser::RuleUsingDirective);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(571);
|
|
match(SolidityParser::Using);
|
|
setState(572);
|
|
userDefinedTypeName();
|
|
setState(573);
|
|
match(SolidityParser::For);
|
|
setState(576);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 55, _ctx)) {
|
|
case 1: {
|
|
setState(574);
|
|
match(SolidityParser::Mul);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(575);
|
|
typeName(0);
|
|
break;
|
|
}
|
|
|
|
}
|
|
setState(578);
|
|
match(SolidityParser::Semicolon);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- TypeNameContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::TypeNameContext::TypeNameContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
SolidityParser::ElementaryTypeNameContext* SolidityParser::TypeNameContext::elementaryTypeName() {
|
|
return getRuleContext<SolidityParser::ElementaryTypeNameContext>(0);
|
|
}
|
|
|
|
SolidityParser::FunctionTypeNameContext* SolidityParser::TypeNameContext::functionTypeName() {
|
|
return getRuleContext<SolidityParser::FunctionTypeNameContext>(0);
|
|
}
|
|
|
|
SolidityParser::MappingTypeContext* SolidityParser::TypeNameContext::mappingType() {
|
|
return getRuleContext<SolidityParser::MappingTypeContext>(0);
|
|
}
|
|
|
|
SolidityParser::UserDefinedTypeNameContext* SolidityParser::TypeNameContext::userDefinedTypeName() {
|
|
return getRuleContext<SolidityParser::UserDefinedTypeNameContext>(0);
|
|
}
|
|
|
|
SolidityParser::TypeNameContext* SolidityParser::TypeNameContext::typeName() {
|
|
return getRuleContext<SolidityParser::TypeNameContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::TypeNameContext::LBrack() {
|
|
return getToken(SolidityParser::LBrack, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::TypeNameContext::RBrack() {
|
|
return getToken(SolidityParser::RBrack, 0);
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::TypeNameContext::expression() {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::TypeNameContext::getRuleIndex() const {
|
|
return SolidityParser::RuleTypeName;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::TypeNameContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitTypeName(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
|
|
SolidityParser::TypeNameContext* SolidityParser::typeName() {
|
|
return typeName(0);
|
|
}
|
|
|
|
SolidityParser::TypeNameContext* SolidityParser::typeName(int precedence) {
|
|
ParserRuleContext *parentContext = _ctx;
|
|
size_t parentState = getState();
|
|
SolidityParser::TypeNameContext *_localctx = _tracker.createInstance<TypeNameContext>(_ctx, parentState);
|
|
SolidityParser::TypeNameContext *previousContext = _localctx;
|
|
(void)previousContext; // Silence compiler, in case the context is not used by generated code.
|
|
size_t startState = 64;
|
|
enterRecursionRule(_localctx, 64, SolidityParser::RuleTypeName, precedence);
|
|
|
|
|
|
|
|
auto onExit = finally([=] {
|
|
unrollRecursionContexts(parentContext);
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(585);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 56, _ctx)) {
|
|
case 1: {
|
|
setState(581);
|
|
elementaryTypeName(true);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(582);
|
|
functionTypeName();
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
setState(583);
|
|
mappingType();
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
setState(584);
|
|
userDefinedTypeName();
|
|
break;
|
|
}
|
|
|
|
}
|
|
_ctx->stop = _input->LT(-1);
|
|
setState(595);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 58, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
if (!_parseListeners.empty())
|
|
triggerExitRuleEvent();
|
|
previousContext = _localctx;
|
|
_localctx = _tracker.createInstance<TypeNameContext>(parentContext, parentState);
|
|
pushNewRecursionContext(_localctx, startState, RuleTypeName);
|
|
setState(587);
|
|
|
|
if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)");
|
|
setState(588);
|
|
match(SolidityParser::LBrack);
|
|
setState(590);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 57, _ctx)) {
|
|
case 1: {
|
|
setState(589);
|
|
expression(0);
|
|
break;
|
|
}
|
|
|
|
}
|
|
setState(592);
|
|
match(SolidityParser::RBrack);
|
|
}
|
|
setState(597);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 58, _ctx);
|
|
}
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ElementaryTypeNameContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::ElementaryTypeNameContext::ElementaryTypeNameContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
SolidityParser::ElementaryTypeNameContext::ElementaryTypeNameContext(ParserRuleContext *parent, size_t invokingState, bool allowAddressPayable)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
this->allowAddressPayable = allowAddressPayable;
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ElementaryTypeNameContext::Address() {
|
|
return getToken(SolidityParser::Address, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ElementaryTypeNameContext::Payable() {
|
|
return getToken(SolidityParser::Payable, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ElementaryTypeNameContext::Bool() {
|
|
return getToken(SolidityParser::Bool, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ElementaryTypeNameContext::String() {
|
|
return getToken(SolidityParser::String, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ElementaryTypeNameContext::Bytes() {
|
|
return getToken(SolidityParser::Bytes, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ElementaryTypeNameContext::SignedIntegerType() {
|
|
return getToken(SolidityParser::SignedIntegerType, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ElementaryTypeNameContext::UnsignedIntegerType() {
|
|
return getToken(SolidityParser::UnsignedIntegerType, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ElementaryTypeNameContext::FixedBytes() {
|
|
return getToken(SolidityParser::FixedBytes, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ElementaryTypeNameContext::Fixed() {
|
|
return getToken(SolidityParser::Fixed, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ElementaryTypeNameContext::Ufixed() {
|
|
return getToken(SolidityParser::Ufixed, 0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::ElementaryTypeNameContext::getRuleIndex() const {
|
|
return SolidityParser::RuleElementaryTypeName;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::ElementaryTypeNameContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitElementaryTypeName(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::ElementaryTypeNameContext* SolidityParser::elementaryTypeName(bool allowAddressPayable) {
|
|
ElementaryTypeNameContext *_localctx = _tracker.createInstance<ElementaryTypeNameContext>(_ctx, getState(), allowAddressPayable);
|
|
enterRule(_localctx, 66, SolidityParser::RuleElementaryTypeName);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(610);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 59, _ctx)) {
|
|
case 1: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(598);
|
|
match(SolidityParser::Address);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(599);
|
|
|
|
if (!(_localctx->allowAddressPayable)) throw FailedPredicateException(this, "$allowAddressPayable");
|
|
setState(600);
|
|
match(SolidityParser::Address);
|
|
setState(601);
|
|
match(SolidityParser::Payable);
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(602);
|
|
match(SolidityParser::Bool);
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
enterOuterAlt(_localctx, 4);
|
|
setState(603);
|
|
match(SolidityParser::String);
|
|
break;
|
|
}
|
|
|
|
case 5: {
|
|
enterOuterAlt(_localctx, 5);
|
|
setState(604);
|
|
match(SolidityParser::Bytes);
|
|
break;
|
|
}
|
|
|
|
case 6: {
|
|
enterOuterAlt(_localctx, 6);
|
|
setState(605);
|
|
match(SolidityParser::SignedIntegerType);
|
|
break;
|
|
}
|
|
|
|
case 7: {
|
|
enterOuterAlt(_localctx, 7);
|
|
setState(606);
|
|
match(SolidityParser::UnsignedIntegerType);
|
|
break;
|
|
}
|
|
|
|
case 8: {
|
|
enterOuterAlt(_localctx, 8);
|
|
setState(607);
|
|
match(SolidityParser::FixedBytes);
|
|
break;
|
|
}
|
|
|
|
case 9: {
|
|
enterOuterAlt(_localctx, 9);
|
|
setState(608);
|
|
match(SolidityParser::Fixed);
|
|
break;
|
|
}
|
|
|
|
case 10: {
|
|
enterOuterAlt(_localctx, 10);
|
|
setState(609);
|
|
match(SolidityParser::Ufixed);
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- FunctionTypeNameContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::FunctionTypeNameContext::FunctionTypeNameContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::FunctionTypeNameContext::Function() {
|
|
return getToken(SolidityParser::Function, 0);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::FunctionTypeNameContext::LParen() {
|
|
return getTokens(SolidityParser::LParen);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::FunctionTypeNameContext::LParen(size_t i) {
|
|
return getToken(SolidityParser::LParen, i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::FunctionTypeNameContext::RParen() {
|
|
return getTokens(SolidityParser::RParen);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::FunctionTypeNameContext::RParen(size_t i) {
|
|
return getToken(SolidityParser::RParen, i);
|
|
}
|
|
|
|
std::vector<SolidityParser::VisibilityContext *> SolidityParser::FunctionTypeNameContext::visibility() {
|
|
return getRuleContexts<SolidityParser::VisibilityContext>();
|
|
}
|
|
|
|
SolidityParser::VisibilityContext* SolidityParser::FunctionTypeNameContext::visibility(size_t i) {
|
|
return getRuleContext<SolidityParser::VisibilityContext>(i);
|
|
}
|
|
|
|
std::vector<SolidityParser::StateMutabilityContext *> SolidityParser::FunctionTypeNameContext::stateMutability() {
|
|
return getRuleContexts<SolidityParser::StateMutabilityContext>();
|
|
}
|
|
|
|
SolidityParser::StateMutabilityContext* SolidityParser::FunctionTypeNameContext::stateMutability(size_t i) {
|
|
return getRuleContext<SolidityParser::StateMutabilityContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::FunctionTypeNameContext::Returns() {
|
|
return getToken(SolidityParser::Returns, 0);
|
|
}
|
|
|
|
std::vector<SolidityParser::ParameterListContext *> SolidityParser::FunctionTypeNameContext::parameterList() {
|
|
return getRuleContexts<SolidityParser::ParameterListContext>();
|
|
}
|
|
|
|
SolidityParser::ParameterListContext* SolidityParser::FunctionTypeNameContext::parameterList(size_t i) {
|
|
return getRuleContext<SolidityParser::ParameterListContext>(i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::FunctionTypeNameContext::getRuleIndex() const {
|
|
return SolidityParser::RuleFunctionTypeName;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::FunctionTypeNameContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitFunctionTypeName(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::FunctionTypeNameContext* SolidityParser::functionTypeName() {
|
|
FunctionTypeNameContext *_localctx = _tracker.createInstance<FunctionTypeNameContext>(_ctx, getState());
|
|
enterRule(_localctx, 68, SolidityParser::RuleFunctionTypeName);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(612);
|
|
match(SolidityParser::Function);
|
|
setState(613);
|
|
match(SolidityParser::LParen);
|
|
setState(615);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 60, _ctx)) {
|
|
case 1: {
|
|
setState(614);
|
|
dynamic_cast<FunctionTypeNameContext *>(_localctx)->arguments = parameterList();
|
|
break;
|
|
}
|
|
|
|
}
|
|
setState(617);
|
|
match(SolidityParser::RParen);
|
|
setState(628);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 62, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
setState(626);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 61, _ctx)) {
|
|
case 1: {
|
|
setState(618);
|
|
|
|
if (!(!_localctx->visibilitySet)) throw FailedPredicateException(this, "!$visibilitySet");
|
|
setState(619);
|
|
visibility();
|
|
dynamic_cast<FunctionTypeNameContext *>(_localctx)->visibilitySet = true;
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(622);
|
|
|
|
if (!(!_localctx->mutabilitySet)) throw FailedPredicateException(this, "!$mutabilitySet");
|
|
setState(623);
|
|
stateMutability();
|
|
dynamic_cast<FunctionTypeNameContext *>(_localctx)->mutabilitySet = true;
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
setState(630);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 62, _ctx);
|
|
}
|
|
setState(636);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 63, _ctx)) {
|
|
case 1: {
|
|
setState(631);
|
|
match(SolidityParser::Returns);
|
|
setState(632);
|
|
match(SolidityParser::LParen);
|
|
setState(633);
|
|
dynamic_cast<FunctionTypeNameContext *>(_localctx)->returnParameters = parameterList();
|
|
setState(634);
|
|
match(SolidityParser::RParen);
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- VariableDeclarationContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::VariableDeclarationContext::VariableDeclarationContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
SolidityParser::TypeNameContext* SolidityParser::VariableDeclarationContext::typeName() {
|
|
return getRuleContext<SolidityParser::TypeNameContext>(0);
|
|
}
|
|
|
|
SolidityParser::IdentifierContext* SolidityParser::VariableDeclarationContext::identifier() {
|
|
return getRuleContext<SolidityParser::IdentifierContext>(0);
|
|
}
|
|
|
|
SolidityParser::DataLocationContext* SolidityParser::VariableDeclarationContext::dataLocation() {
|
|
return getRuleContext<SolidityParser::DataLocationContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::VariableDeclarationContext::getRuleIndex() const {
|
|
return SolidityParser::RuleVariableDeclaration;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::VariableDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitVariableDeclaration(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::VariableDeclarationContext* SolidityParser::variableDeclaration() {
|
|
VariableDeclarationContext *_localctx = _tracker.createInstance<VariableDeclarationContext>(_ctx, getState());
|
|
enterRule(_localctx, 70, SolidityParser::RuleVariableDeclaration);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(638);
|
|
dynamic_cast<VariableDeclarationContext *>(_localctx)->type = typeName(0);
|
|
setState(640);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & ((1ULL << SolidityParser::Calldata)
|
|
| (1ULL << SolidityParser::Memory)
|
|
| (1ULL << SolidityParser::Storage))) != 0)) {
|
|
setState(639);
|
|
dynamic_cast<VariableDeclarationContext *>(_localctx)->location = dataLocation();
|
|
}
|
|
setState(642);
|
|
dynamic_cast<VariableDeclarationContext *>(_localctx)->name = identifier();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- DataLocationContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::DataLocationContext::DataLocationContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::DataLocationContext::Memory() {
|
|
return getToken(SolidityParser::Memory, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::DataLocationContext::Storage() {
|
|
return getToken(SolidityParser::Storage, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::DataLocationContext::Calldata() {
|
|
return getToken(SolidityParser::Calldata, 0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::DataLocationContext::getRuleIndex() const {
|
|
return SolidityParser::RuleDataLocation;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::DataLocationContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitDataLocation(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::DataLocationContext* SolidityParser::dataLocation() {
|
|
DataLocationContext *_localctx = _tracker.createInstance<DataLocationContext>(_ctx, getState());
|
|
enterRule(_localctx, 72, SolidityParser::RuleDataLocation);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(644);
|
|
_la = _input->LA(1);
|
|
if (!((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & ((1ULL << SolidityParser::Calldata)
|
|
| (1ULL << SolidityParser::Memory)
|
|
| (1ULL << SolidityParser::Storage))) != 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;
|
|
}
|
|
|
|
//----------------- ExpressionContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::ExpressionContext::ExpressionContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
|
|
size_t SolidityParser::ExpressionContext::getRuleIndex() const {
|
|
return SolidityParser::RuleExpression;
|
|
}
|
|
|
|
void SolidityParser::ExpressionContext::copyFrom(ExpressionContext *ctx) {
|
|
ParserRuleContext::copyFrom(ctx);
|
|
}
|
|
|
|
//----------------- UnaryPrefixOperationContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::UnaryPrefixOperationContext::expression() {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::UnaryPrefixOperationContext::Inc() {
|
|
return getToken(SolidityParser::Inc, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::UnaryPrefixOperationContext::Dec() {
|
|
return getToken(SolidityParser::Dec, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::UnaryPrefixOperationContext::Not() {
|
|
return getToken(SolidityParser::Not, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::UnaryPrefixOperationContext::BitNot() {
|
|
return getToken(SolidityParser::BitNot, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::UnaryPrefixOperationContext::Delete() {
|
|
return getToken(SolidityParser::Delete, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::UnaryPrefixOperationContext::Sub() {
|
|
return getToken(SolidityParser::Sub, 0);
|
|
}
|
|
|
|
SolidityParser::UnaryPrefixOperationContext::UnaryPrefixOperationContext(ExpressionContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
antlrcpp::Any SolidityParser::UnaryPrefixOperationContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitUnaryPrefixOperation(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- PrimaryExpressionContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::IdentifierContext* SolidityParser::PrimaryExpressionContext::identifier() {
|
|
return getRuleContext<SolidityParser::IdentifierContext>(0);
|
|
}
|
|
|
|
SolidityParser::LiteralContext* SolidityParser::PrimaryExpressionContext::literal() {
|
|
return getRuleContext<SolidityParser::LiteralContext>(0);
|
|
}
|
|
|
|
SolidityParser::ElementaryTypeNameContext* SolidityParser::PrimaryExpressionContext::elementaryTypeName() {
|
|
return getRuleContext<SolidityParser::ElementaryTypeNameContext>(0);
|
|
}
|
|
|
|
SolidityParser::UserDefinedTypeNameContext* SolidityParser::PrimaryExpressionContext::userDefinedTypeName() {
|
|
return getRuleContext<SolidityParser::UserDefinedTypeNameContext>(0);
|
|
}
|
|
|
|
SolidityParser::PrimaryExpressionContext::PrimaryExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
antlrcpp::Any SolidityParser::PrimaryExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitPrimaryExpression(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- OrderComparisonContext ------------------------------------------------------------------
|
|
|
|
std::vector<SolidityParser::ExpressionContext *> SolidityParser::OrderComparisonContext::expression() {
|
|
return getRuleContexts<SolidityParser::ExpressionContext>();
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::OrderComparisonContext::expression(size_t i) {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::OrderComparisonContext::LessThan() {
|
|
return getToken(SolidityParser::LessThan, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::OrderComparisonContext::GreaterThan() {
|
|
return getToken(SolidityParser::GreaterThan, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::OrderComparisonContext::LessThanOrEqual() {
|
|
return getToken(SolidityParser::LessThanOrEqual, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::OrderComparisonContext::GreaterThanOrEqual() {
|
|
return getToken(SolidityParser::GreaterThanOrEqual, 0);
|
|
}
|
|
|
|
SolidityParser::OrderComparisonContext::OrderComparisonContext(ExpressionContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
antlrcpp::Any SolidityParser::OrderComparisonContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitOrderComparison(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ConditionalContext ------------------------------------------------------------------
|
|
|
|
std::vector<SolidityParser::ExpressionContext *> SolidityParser::ConditionalContext::expression() {
|
|
return getRuleContexts<SolidityParser::ExpressionContext>();
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::ConditionalContext::expression(size_t i) {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ConditionalContext::Conditional() {
|
|
return getToken(SolidityParser::Conditional, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ConditionalContext::Colon() {
|
|
return getToken(SolidityParser::Colon, 0);
|
|
}
|
|
|
|
SolidityParser::ConditionalContext::ConditionalContext(ExpressionContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
antlrcpp::Any SolidityParser::ConditionalContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitConditional(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- PayableConversionContext ------------------------------------------------------------------
|
|
|
|
tree::TerminalNode* SolidityParser::PayableConversionContext::Payable() {
|
|
return getToken(SolidityParser::Payable, 0);
|
|
}
|
|
|
|
SolidityParser::CallArgumentListContext* SolidityParser::PayableConversionContext::callArgumentList() {
|
|
return getRuleContext<SolidityParser::CallArgumentListContext>(0);
|
|
}
|
|
|
|
SolidityParser::PayableConversionContext::PayableConversionContext(ExpressionContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
antlrcpp::Any SolidityParser::PayableConversionContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitPayableConversion(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- AssignmentContext ------------------------------------------------------------------
|
|
|
|
std::vector<SolidityParser::ExpressionContext *> SolidityParser::AssignmentContext::expression() {
|
|
return getRuleContexts<SolidityParser::ExpressionContext>();
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::AssignmentContext::expression(size_t i) {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(i);
|
|
}
|
|
|
|
SolidityParser::AssignOpContext* SolidityParser::AssignmentContext::assignOp() {
|
|
return getRuleContext<SolidityParser::AssignOpContext>(0);
|
|
}
|
|
|
|
SolidityParser::AssignmentContext::AssignmentContext(ExpressionContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
antlrcpp::Any SolidityParser::AssignmentContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitAssignment(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- UnarySuffixOperationContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::UnarySuffixOperationContext::expression() {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::UnarySuffixOperationContext::Inc() {
|
|
return getToken(SolidityParser::Inc, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::UnarySuffixOperationContext::Dec() {
|
|
return getToken(SolidityParser::Dec, 0);
|
|
}
|
|
|
|
SolidityParser::UnarySuffixOperationContext::UnarySuffixOperationContext(ExpressionContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
antlrcpp::Any SolidityParser::UnarySuffixOperationContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitUnarySuffixOperation(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ShiftOperationContext ------------------------------------------------------------------
|
|
|
|
std::vector<SolidityParser::ExpressionContext *> SolidityParser::ShiftOperationContext::expression() {
|
|
return getRuleContexts<SolidityParser::ExpressionContext>();
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::ShiftOperationContext::expression(size_t i) {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ShiftOperationContext::Shl() {
|
|
return getToken(SolidityParser::Shl, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ShiftOperationContext::Sar() {
|
|
return getToken(SolidityParser::Sar, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ShiftOperationContext::Shr() {
|
|
return getToken(SolidityParser::Shr, 0);
|
|
}
|
|
|
|
SolidityParser::ShiftOperationContext::ShiftOperationContext(ExpressionContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
antlrcpp::Any SolidityParser::ShiftOperationContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitShiftOperation(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- BitAndOperationContext ------------------------------------------------------------------
|
|
|
|
std::vector<SolidityParser::ExpressionContext *> SolidityParser::BitAndOperationContext::expression() {
|
|
return getRuleContexts<SolidityParser::ExpressionContext>();
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::BitAndOperationContext::expression(size_t i) {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::BitAndOperationContext::BitAnd() {
|
|
return getToken(SolidityParser::BitAnd, 0);
|
|
}
|
|
|
|
SolidityParser::BitAndOperationContext::BitAndOperationContext(ExpressionContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
antlrcpp::Any SolidityParser::BitAndOperationContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitBitAndOperation(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- FunctionCallContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::FunctionCallContext::expression() {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(0);
|
|
}
|
|
|
|
SolidityParser::CallArgumentListContext* SolidityParser::FunctionCallContext::callArgumentList() {
|
|
return getRuleContext<SolidityParser::CallArgumentListContext>(0);
|
|
}
|
|
|
|
SolidityParser::FunctionCallContext::FunctionCallContext(ExpressionContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
antlrcpp::Any SolidityParser::FunctionCallContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitFunctionCall(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- IndexRangeAccessContext ------------------------------------------------------------------
|
|
|
|
std::vector<SolidityParser::ExpressionContext *> SolidityParser::IndexRangeAccessContext::expression() {
|
|
return getRuleContexts<SolidityParser::ExpressionContext>();
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::IndexRangeAccessContext::expression(size_t i) {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::IndexRangeAccessContext::LBrack() {
|
|
return getToken(SolidityParser::LBrack, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::IndexRangeAccessContext::Colon() {
|
|
return getToken(SolidityParser::Colon, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::IndexRangeAccessContext::RBrack() {
|
|
return getToken(SolidityParser::RBrack, 0);
|
|
}
|
|
|
|
SolidityParser::IndexRangeAccessContext::IndexRangeAccessContext(ExpressionContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
antlrcpp::Any SolidityParser::IndexRangeAccessContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitIndexRangeAccess(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- NewExpressionContext ------------------------------------------------------------------
|
|
|
|
tree::TerminalNode* SolidityParser::NewExpressionContext::New() {
|
|
return getToken(SolidityParser::New, 0);
|
|
}
|
|
|
|
SolidityParser::TypeNameContext* SolidityParser::NewExpressionContext::typeName() {
|
|
return getRuleContext<SolidityParser::TypeNameContext>(0);
|
|
}
|
|
|
|
SolidityParser::NewExpressionContext::NewExpressionContext(ExpressionContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
antlrcpp::Any SolidityParser::NewExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitNewExpression(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- IndexAccessContext ------------------------------------------------------------------
|
|
|
|
std::vector<SolidityParser::ExpressionContext *> SolidityParser::IndexAccessContext::expression() {
|
|
return getRuleContexts<SolidityParser::ExpressionContext>();
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::IndexAccessContext::expression(size_t i) {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::IndexAccessContext::LBrack() {
|
|
return getToken(SolidityParser::LBrack, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::IndexAccessContext::RBrack() {
|
|
return getToken(SolidityParser::RBrack, 0);
|
|
}
|
|
|
|
SolidityParser::IndexAccessContext::IndexAccessContext(ExpressionContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
antlrcpp::Any SolidityParser::IndexAccessContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitIndexAccess(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- AddSubOperationContext ------------------------------------------------------------------
|
|
|
|
std::vector<SolidityParser::ExpressionContext *> SolidityParser::AddSubOperationContext::expression() {
|
|
return getRuleContexts<SolidityParser::ExpressionContext>();
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::AddSubOperationContext::expression(size_t i) {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::AddSubOperationContext::Add() {
|
|
return getToken(SolidityParser::Add, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::AddSubOperationContext::Sub() {
|
|
return getToken(SolidityParser::Sub, 0);
|
|
}
|
|
|
|
SolidityParser::AddSubOperationContext::AddSubOperationContext(ExpressionContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
antlrcpp::Any SolidityParser::AddSubOperationContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitAddSubOperation(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- BitOrOperationContext ------------------------------------------------------------------
|
|
|
|
std::vector<SolidityParser::ExpressionContext *> SolidityParser::BitOrOperationContext::expression() {
|
|
return getRuleContexts<SolidityParser::ExpressionContext>();
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::BitOrOperationContext::expression(size_t i) {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::BitOrOperationContext::BitOr() {
|
|
return getToken(SolidityParser::BitOr, 0);
|
|
}
|
|
|
|
SolidityParser::BitOrOperationContext::BitOrOperationContext(ExpressionContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
antlrcpp::Any SolidityParser::BitOrOperationContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitBitOrOperation(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- ExpOperationContext ------------------------------------------------------------------
|
|
|
|
std::vector<SolidityParser::ExpressionContext *> SolidityParser::ExpOperationContext::expression() {
|
|
return getRuleContexts<SolidityParser::ExpressionContext>();
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::ExpOperationContext::expression(size_t i) {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ExpOperationContext::Exp() {
|
|
return getToken(SolidityParser::Exp, 0);
|
|
}
|
|
|
|
SolidityParser::ExpOperationContext::ExpOperationContext(ExpressionContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
antlrcpp::Any SolidityParser::ExpOperationContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitExpOperation(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- AndOperationContext ------------------------------------------------------------------
|
|
|
|
std::vector<SolidityParser::ExpressionContext *> SolidityParser::AndOperationContext::expression() {
|
|
return getRuleContexts<SolidityParser::ExpressionContext>();
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::AndOperationContext::expression(size_t i) {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::AndOperationContext::And() {
|
|
return getToken(SolidityParser::And, 0);
|
|
}
|
|
|
|
SolidityParser::AndOperationContext::AndOperationContext(ExpressionContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
antlrcpp::Any SolidityParser::AndOperationContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitAndOperation(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- InlineArrayContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::InlineArrayExpressionContext* SolidityParser::InlineArrayContext::inlineArrayExpression() {
|
|
return getRuleContext<SolidityParser::InlineArrayExpressionContext>(0);
|
|
}
|
|
|
|
SolidityParser::InlineArrayContext::InlineArrayContext(ExpressionContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
antlrcpp::Any SolidityParser::InlineArrayContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitInlineArray(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- OrOperationContext ------------------------------------------------------------------
|
|
|
|
std::vector<SolidityParser::ExpressionContext *> SolidityParser::OrOperationContext::expression() {
|
|
return getRuleContexts<SolidityParser::ExpressionContext>();
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::OrOperationContext::expression(size_t i) {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::OrOperationContext::Or() {
|
|
return getToken(SolidityParser::Or, 0);
|
|
}
|
|
|
|
SolidityParser::OrOperationContext::OrOperationContext(ExpressionContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
antlrcpp::Any SolidityParser::OrOperationContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitOrOperation(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- MemberAccessContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::MemberAccessContext::expression() {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::MemberAccessContext::Period() {
|
|
return getToken(SolidityParser::Period, 0);
|
|
}
|
|
|
|
SolidityParser::IdentifierContext* SolidityParser::MemberAccessContext::identifier() {
|
|
return getRuleContext<SolidityParser::IdentifierContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::MemberAccessContext::Address() {
|
|
return getToken(SolidityParser::Address, 0);
|
|
}
|
|
|
|
SolidityParser::MemberAccessContext::MemberAccessContext(ExpressionContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
antlrcpp::Any SolidityParser::MemberAccessContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitMemberAccess(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- MulDivModOperationContext ------------------------------------------------------------------
|
|
|
|
std::vector<SolidityParser::ExpressionContext *> SolidityParser::MulDivModOperationContext::expression() {
|
|
return getRuleContexts<SolidityParser::ExpressionContext>();
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::MulDivModOperationContext::expression(size_t i) {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::MulDivModOperationContext::Mul() {
|
|
return getToken(SolidityParser::Mul, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::MulDivModOperationContext::Div() {
|
|
return getToken(SolidityParser::Div, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::MulDivModOperationContext::Mod() {
|
|
return getToken(SolidityParser::Mod, 0);
|
|
}
|
|
|
|
SolidityParser::MulDivModOperationContext::MulDivModOperationContext(ExpressionContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
antlrcpp::Any SolidityParser::MulDivModOperationContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitMulDivModOperation(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- FunctionCallOptionsContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::FunctionCallOptionsContext::expression() {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::FunctionCallOptionsContext::LBrace() {
|
|
return getToken(SolidityParser::LBrace, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::FunctionCallOptionsContext::RBrace() {
|
|
return getToken(SolidityParser::RBrace, 0);
|
|
}
|
|
|
|
std::vector<SolidityParser::NamedArgumentContext *> SolidityParser::FunctionCallOptionsContext::namedArgument() {
|
|
return getRuleContexts<SolidityParser::NamedArgumentContext>();
|
|
}
|
|
|
|
SolidityParser::NamedArgumentContext* SolidityParser::FunctionCallOptionsContext::namedArgument(size_t i) {
|
|
return getRuleContext<SolidityParser::NamedArgumentContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::FunctionCallOptionsContext::Comma() {
|
|
return getTokens(SolidityParser::Comma);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::FunctionCallOptionsContext::Comma(size_t i) {
|
|
return getToken(SolidityParser::Comma, i);
|
|
}
|
|
|
|
SolidityParser::FunctionCallOptionsContext::FunctionCallOptionsContext(ExpressionContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
antlrcpp::Any SolidityParser::FunctionCallOptionsContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitFunctionCallOptions(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- BitXorOperationContext ------------------------------------------------------------------
|
|
|
|
std::vector<SolidityParser::ExpressionContext *> SolidityParser::BitXorOperationContext::expression() {
|
|
return getRuleContexts<SolidityParser::ExpressionContext>();
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::BitXorOperationContext::expression(size_t i) {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::BitXorOperationContext::BitXor() {
|
|
return getToken(SolidityParser::BitXor, 0);
|
|
}
|
|
|
|
SolidityParser::BitXorOperationContext::BitXorOperationContext(ExpressionContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
antlrcpp::Any SolidityParser::BitXorOperationContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitBitXorOperation(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- TupleContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::TupleExpressionContext* SolidityParser::TupleContext::tupleExpression() {
|
|
return getRuleContext<SolidityParser::TupleExpressionContext>(0);
|
|
}
|
|
|
|
SolidityParser::TupleContext::TupleContext(ExpressionContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
antlrcpp::Any SolidityParser::TupleContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitTuple(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- EqualityComparisonContext ------------------------------------------------------------------
|
|
|
|
std::vector<SolidityParser::ExpressionContext *> SolidityParser::EqualityComparisonContext::expression() {
|
|
return getRuleContexts<SolidityParser::ExpressionContext>();
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::EqualityComparisonContext::expression(size_t i) {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::EqualityComparisonContext::Equal() {
|
|
return getToken(SolidityParser::Equal, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::EqualityComparisonContext::NotEqual() {
|
|
return getToken(SolidityParser::NotEqual, 0);
|
|
}
|
|
|
|
SolidityParser::EqualityComparisonContext::EqualityComparisonContext(ExpressionContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
antlrcpp::Any SolidityParser::EqualityComparisonContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitEqualityComparison(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
//----------------- MetaTypeContext ------------------------------------------------------------------
|
|
|
|
tree::TerminalNode* SolidityParser::MetaTypeContext::Type() {
|
|
return getToken(SolidityParser::Type, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::MetaTypeContext::LParen() {
|
|
return getToken(SolidityParser::LParen, 0);
|
|
}
|
|
|
|
SolidityParser::TypeNameContext* SolidityParser::MetaTypeContext::typeName() {
|
|
return getRuleContext<SolidityParser::TypeNameContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::MetaTypeContext::RParen() {
|
|
return getToken(SolidityParser::RParen, 0);
|
|
}
|
|
|
|
SolidityParser::MetaTypeContext::MetaTypeContext(ExpressionContext *ctx) { copyFrom(ctx); }
|
|
|
|
|
|
antlrcpp::Any SolidityParser::MetaTypeContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitMetaType(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::expression() {
|
|
return expression(0);
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::expression(int precedence) {
|
|
ParserRuleContext *parentContext = _ctx;
|
|
size_t parentState = getState();
|
|
SolidityParser::ExpressionContext *_localctx = _tracker.createInstance<ExpressionContext>(_ctx, parentState);
|
|
SolidityParser::ExpressionContext *previousContext = _localctx;
|
|
(void)previousContext; // Silence compiler, in case the context is not used by generated code.
|
|
size_t startState = 74;
|
|
enterRecursionRule(_localctx, 74, SolidityParser::RuleExpression, precedence);
|
|
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
unrollRecursionContexts(parentContext);
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(666);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 66, _ctx)) {
|
|
case 1: {
|
|
_localctx = _tracker.createInstance<PayableConversionContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
|
|
setState(647);
|
|
match(SolidityParser::Payable);
|
|
setState(648);
|
|
callArgumentList();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
_localctx = _tracker.createInstance<MetaTypeContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(649);
|
|
match(SolidityParser::Type);
|
|
setState(650);
|
|
match(SolidityParser::LParen);
|
|
setState(651);
|
|
typeName(0);
|
|
setState(652);
|
|
match(SolidityParser::RParen);
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
_localctx = _tracker.createInstance<UnaryPrefixOperationContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(654);
|
|
_la = _input->LA(1);
|
|
if (!(_la == SolidityParser::Delete || ((((_la - 99) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 99)) & ((1ULL << (SolidityParser::Sub - 99))
|
|
| (1ULL << (SolidityParser::Not - 99))
|
|
| (1ULL << (SolidityParser::BitNot - 99))
|
|
| (1ULL << (SolidityParser::Inc - 99))
|
|
| (1ULL << (SolidityParser::Dec - 99)))) != 0))) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(655);
|
|
expression(19);
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
_localctx = _tracker.createInstance<NewExpressionContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(656);
|
|
match(SolidityParser::New);
|
|
setState(657);
|
|
typeName(0);
|
|
break;
|
|
}
|
|
|
|
case 5: {
|
|
_localctx = _tracker.createInstance<TupleContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(658);
|
|
tupleExpression();
|
|
break;
|
|
}
|
|
|
|
case 6: {
|
|
_localctx = _tracker.createInstance<InlineArrayContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(659);
|
|
inlineArrayExpression();
|
|
break;
|
|
}
|
|
|
|
case 7: {
|
|
_localctx = _tracker.createInstance<PrimaryExpressionContext>(_localctx);
|
|
_ctx = _localctx;
|
|
previousContext = _localctx;
|
|
setState(664);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 65, _ctx)) {
|
|
case 1: {
|
|
setState(660);
|
|
identifier();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(661);
|
|
literal();
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
setState(662);
|
|
elementaryTypeName(false);
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
setState(663);
|
|
userDefinedTypeName();
|
|
break;
|
|
}
|
|
|
|
}
|
|
break;
|
|
}
|
|
|
|
}
|
|
_ctx->stop = _input->LT(-1);
|
|
setState(752);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 74, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
if (!_parseListeners.empty())
|
|
triggerExitRuleEvent();
|
|
previousContext = _localctx;
|
|
setState(750);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 73, _ctx)) {
|
|
case 1: {
|
|
auto newContext = _tracker.createInstance<ExpOperationContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleExpression);
|
|
setState(668);
|
|
|
|
if (!(precpred(_ctx, 17))) throw FailedPredicateException(this, "precpred(_ctx, 17)");
|
|
setState(669);
|
|
match(SolidityParser::Exp);
|
|
setState(670);
|
|
expression(17);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
auto newContext = _tracker.createInstance<MulDivModOperationContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleExpression);
|
|
setState(671);
|
|
|
|
if (!(precpred(_ctx, 16))) throw FailedPredicateException(this, "precpred(_ctx, 16)");
|
|
setState(672);
|
|
_la = _input->LA(1);
|
|
if (!(((((_la - 100) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 100)) & ((1ULL << (SolidityParser::Mul - 100))
|
|
| (1ULL << (SolidityParser::Div - 100))
|
|
| (1ULL << (SolidityParser::Mod - 100)))) != 0))) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(673);
|
|
expression(17);
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
auto newContext = _tracker.createInstance<AddSubOperationContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleExpression);
|
|
setState(674);
|
|
|
|
if (!(precpred(_ctx, 15))) throw FailedPredicateException(this, "precpred(_ctx, 15)");
|
|
setState(675);
|
|
_la = _input->LA(1);
|
|
if (!(_la == SolidityParser::Add
|
|
|
|
|| _la == SolidityParser::Sub)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(676);
|
|
expression(16);
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
auto newContext = _tracker.createInstance<ShiftOperationContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleExpression);
|
|
setState(677);
|
|
|
|
if (!(precpred(_ctx, 14))) throw FailedPredicateException(this, "precpred(_ctx, 14)");
|
|
setState(678);
|
|
_la = _input->LA(1);
|
|
if (!(((((_la - 95) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 95)) & ((1ULL << (SolidityParser::Shl - 95))
|
|
| (1ULL << (SolidityParser::Sar - 95))
|
|
| (1ULL << (SolidityParser::Shr - 95)))) != 0))) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(679);
|
|
expression(15);
|
|
break;
|
|
}
|
|
|
|
case 5: {
|
|
auto newContext = _tracker.createInstance<BitAndOperationContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleExpression);
|
|
setState(680);
|
|
|
|
if (!(precpred(_ctx, 13))) throw FailedPredicateException(this, "precpred(_ctx, 13)");
|
|
setState(681);
|
|
match(SolidityParser::BitAnd);
|
|
setState(682);
|
|
expression(14);
|
|
break;
|
|
}
|
|
|
|
case 6: {
|
|
auto newContext = _tracker.createInstance<BitXorOperationContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleExpression);
|
|
setState(683);
|
|
|
|
if (!(precpred(_ctx, 12))) throw FailedPredicateException(this, "precpred(_ctx, 12)");
|
|
setState(684);
|
|
match(SolidityParser::BitXor);
|
|
setState(685);
|
|
expression(13);
|
|
break;
|
|
}
|
|
|
|
case 7: {
|
|
auto newContext = _tracker.createInstance<BitOrOperationContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleExpression);
|
|
setState(686);
|
|
|
|
if (!(precpred(_ctx, 11))) throw FailedPredicateException(this, "precpred(_ctx, 11)");
|
|
setState(687);
|
|
match(SolidityParser::BitOr);
|
|
setState(688);
|
|
expression(12);
|
|
break;
|
|
}
|
|
|
|
case 8: {
|
|
auto newContext = _tracker.createInstance<OrderComparisonContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleExpression);
|
|
setState(689);
|
|
|
|
if (!(precpred(_ctx, 10))) throw FailedPredicateException(this, "precpred(_ctx, 10)");
|
|
setState(690);
|
|
_la = _input->LA(1);
|
|
if (!(((((_la - 106) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 106)) & ((1ULL << (SolidityParser::LessThan - 106))
|
|
| (1ULL << (SolidityParser::GreaterThan - 106))
|
|
| (1ULL << (SolidityParser::LessThanOrEqual - 106))
|
|
| (1ULL << (SolidityParser::GreaterThanOrEqual - 106)))) != 0))) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(691);
|
|
expression(11);
|
|
break;
|
|
}
|
|
|
|
case 9: {
|
|
auto newContext = _tracker.createInstance<EqualityComparisonContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleExpression);
|
|
setState(692);
|
|
|
|
if (!(precpred(_ctx, 9))) throw FailedPredicateException(this, "precpred(_ctx, 9)");
|
|
setState(693);
|
|
_la = _input->LA(1);
|
|
if (!(_la == SolidityParser::Equal
|
|
|
|
|| _la == SolidityParser::NotEqual)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(694);
|
|
expression(10);
|
|
break;
|
|
}
|
|
|
|
case 10: {
|
|
auto newContext = _tracker.createInstance<AndOperationContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleExpression);
|
|
setState(695);
|
|
|
|
if (!(precpred(_ctx, 8))) throw FailedPredicateException(this, "precpred(_ctx, 8)");
|
|
setState(696);
|
|
match(SolidityParser::And);
|
|
setState(697);
|
|
expression(9);
|
|
break;
|
|
}
|
|
|
|
case 11: {
|
|
auto newContext = _tracker.createInstance<OrOperationContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleExpression);
|
|
setState(698);
|
|
|
|
if (!(precpred(_ctx, 7))) throw FailedPredicateException(this, "precpred(_ctx, 7)");
|
|
setState(699);
|
|
match(SolidityParser::Or);
|
|
setState(700);
|
|
expression(8);
|
|
break;
|
|
}
|
|
|
|
case 12: {
|
|
auto newContext = _tracker.createInstance<ConditionalContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleExpression);
|
|
setState(701);
|
|
|
|
if (!(precpred(_ctx, 6))) throw FailedPredicateException(this, "precpred(_ctx, 6)");
|
|
setState(702);
|
|
match(SolidityParser::Conditional);
|
|
setState(703);
|
|
expression(0);
|
|
setState(704);
|
|
match(SolidityParser::Colon);
|
|
setState(705);
|
|
expression(6);
|
|
break;
|
|
}
|
|
|
|
case 13: {
|
|
auto newContext = _tracker.createInstance<AssignmentContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleExpression);
|
|
setState(707);
|
|
|
|
if (!(precpred(_ctx, 5))) throw FailedPredicateException(this, "precpred(_ctx, 5)");
|
|
setState(708);
|
|
assignOp();
|
|
setState(709);
|
|
expression(5);
|
|
break;
|
|
}
|
|
|
|
case 14: {
|
|
auto newContext = _tracker.createInstance<IndexAccessContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleExpression);
|
|
setState(711);
|
|
|
|
if (!(precpred(_ctx, 26))) throw FailedPredicateException(this, "precpred(_ctx, 26)");
|
|
setState(712);
|
|
match(SolidityParser::LBrack);
|
|
setState(714);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 67, _ctx)) {
|
|
case 1: {
|
|
setState(713);
|
|
dynamic_cast<IndexAccessContext *>(_localctx)->index = expression(0);
|
|
break;
|
|
}
|
|
|
|
}
|
|
setState(716);
|
|
match(SolidityParser::RBrack);
|
|
break;
|
|
}
|
|
|
|
case 15: {
|
|
auto newContext = _tracker.createInstance<IndexRangeAccessContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleExpression);
|
|
setState(717);
|
|
|
|
if (!(precpred(_ctx, 25))) throw FailedPredicateException(this, "precpred(_ctx, 25)");
|
|
setState(718);
|
|
match(SolidityParser::LBrack);
|
|
setState(720);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 68, _ctx)) {
|
|
case 1: {
|
|
setState(719);
|
|
dynamic_cast<IndexRangeAccessContext *>(_localctx)->start = expression(0);
|
|
break;
|
|
}
|
|
|
|
}
|
|
setState(722);
|
|
match(SolidityParser::Colon);
|
|
setState(724);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 69, _ctx)) {
|
|
case 1: {
|
|
setState(723);
|
|
dynamic_cast<IndexRangeAccessContext *>(_localctx)->end = expression(0);
|
|
break;
|
|
}
|
|
|
|
}
|
|
setState(726);
|
|
match(SolidityParser::RBrack);
|
|
break;
|
|
}
|
|
|
|
case 16: {
|
|
auto newContext = _tracker.createInstance<MemberAccessContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleExpression);
|
|
setState(727);
|
|
|
|
if (!(precpred(_ctx, 24))) throw FailedPredicateException(this, "precpred(_ctx, 24)");
|
|
setState(728);
|
|
match(SolidityParser::Period);
|
|
setState(731);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case SolidityParser::From:
|
|
case SolidityParser::Identifier: {
|
|
setState(729);
|
|
identifier();
|
|
break;
|
|
}
|
|
|
|
case SolidityParser::Address: {
|
|
setState(730);
|
|
match(SolidityParser::Address);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 17: {
|
|
auto newContext = _tracker.createInstance<FunctionCallOptionsContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleExpression);
|
|
setState(733);
|
|
|
|
if (!(precpred(_ctx, 23))) throw FailedPredicateException(this, "precpred(_ctx, 23)");
|
|
setState(734);
|
|
match(SolidityParser::LBrace);
|
|
setState(743);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == SolidityParser::From || _la == SolidityParser::Identifier) {
|
|
setState(735);
|
|
namedArgument();
|
|
setState(740);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == SolidityParser::Comma) {
|
|
setState(736);
|
|
match(SolidityParser::Comma);
|
|
setState(737);
|
|
namedArgument();
|
|
setState(742);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
}
|
|
setState(745);
|
|
match(SolidityParser::RBrace);
|
|
break;
|
|
}
|
|
|
|
case 18: {
|
|
auto newContext = _tracker.createInstance<FunctionCallContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleExpression);
|
|
setState(746);
|
|
|
|
if (!(precpred(_ctx, 22))) throw FailedPredicateException(this, "precpred(_ctx, 22)");
|
|
setState(747);
|
|
callArgumentList();
|
|
break;
|
|
}
|
|
|
|
case 19: {
|
|
auto newContext = _tracker.createInstance<UnarySuffixOperationContext>(_tracker.createInstance<ExpressionContext>(parentContext, parentState));
|
|
_localctx = newContext;
|
|
pushNewRecursionContext(newContext, startState, RuleExpression);
|
|
setState(748);
|
|
|
|
if (!(precpred(_ctx, 18))) throw FailedPredicateException(this, "precpred(_ctx, 18)");
|
|
setState(749);
|
|
_la = _input->LA(1);
|
|
if (!(_la == SolidityParser::Inc
|
|
|
|
|| _la == SolidityParser::Dec)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
setState(754);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 74, _ctx);
|
|
}
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- AssignOpContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::AssignOpContext::AssignOpContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::AssignOpContext::Assign() {
|
|
return getToken(SolidityParser::Assign, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::AssignOpContext::AssignBitOr() {
|
|
return getToken(SolidityParser::AssignBitOr, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::AssignOpContext::AssignBitXor() {
|
|
return getToken(SolidityParser::AssignBitXor, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::AssignOpContext::AssignBitAnd() {
|
|
return getToken(SolidityParser::AssignBitAnd, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::AssignOpContext::AssignShl() {
|
|
return getToken(SolidityParser::AssignShl, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::AssignOpContext::AssignSar() {
|
|
return getToken(SolidityParser::AssignSar, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::AssignOpContext::AssignShr() {
|
|
return getToken(SolidityParser::AssignShr, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::AssignOpContext::AssignAdd() {
|
|
return getToken(SolidityParser::AssignAdd, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::AssignOpContext::AssignSub() {
|
|
return getToken(SolidityParser::AssignSub, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::AssignOpContext::AssignMul() {
|
|
return getToken(SolidityParser::AssignMul, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::AssignOpContext::AssignDiv() {
|
|
return getToken(SolidityParser::AssignDiv, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::AssignOpContext::AssignMod() {
|
|
return getToken(SolidityParser::AssignMod, 0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::AssignOpContext::getRuleIndex() const {
|
|
return SolidityParser::RuleAssignOp;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::AssignOpContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitAssignOp(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::AssignOpContext* SolidityParser::assignOp() {
|
|
AssignOpContext *_localctx = _tracker.createInstance<AssignOpContext>(_ctx, getState());
|
|
enterRule(_localctx, 76, SolidityParser::RuleAssignOp);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(755);
|
|
_la = _input->LA(1);
|
|
if (!(((((_la - 77) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 77)) & ((1ULL << (SolidityParser::Assign - 77))
|
|
| (1ULL << (SolidityParser::AssignBitOr - 77))
|
|
| (1ULL << (SolidityParser::AssignBitXor - 77))
|
|
| (1ULL << (SolidityParser::AssignBitAnd - 77))
|
|
| (1ULL << (SolidityParser::AssignShl - 77))
|
|
| (1ULL << (SolidityParser::AssignSar - 77))
|
|
| (1ULL << (SolidityParser::AssignShr - 77))
|
|
| (1ULL << (SolidityParser::AssignAdd - 77))
|
|
| (1ULL << (SolidityParser::AssignSub - 77))
|
|
| (1ULL << (SolidityParser::AssignMul - 77))
|
|
| (1ULL << (SolidityParser::AssignDiv - 77))
|
|
| (1ULL << (SolidityParser::AssignMod - 77)))) != 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;
|
|
}
|
|
|
|
//----------------- TupleExpressionContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::TupleExpressionContext::TupleExpressionContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::TupleExpressionContext::LParen() {
|
|
return getToken(SolidityParser::LParen, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::TupleExpressionContext::RParen() {
|
|
return getToken(SolidityParser::RParen, 0);
|
|
}
|
|
|
|
std::vector<SolidityParser::ExpressionContext *> SolidityParser::TupleExpressionContext::expression() {
|
|
return getRuleContexts<SolidityParser::ExpressionContext>();
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::TupleExpressionContext::expression(size_t i) {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::TupleExpressionContext::Comma() {
|
|
return getTokens(SolidityParser::Comma);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::TupleExpressionContext::Comma(size_t i) {
|
|
return getToken(SolidityParser::Comma, i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::TupleExpressionContext::getRuleIndex() const {
|
|
return SolidityParser::RuleTupleExpression;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::TupleExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitTupleExpression(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::TupleExpressionContext* SolidityParser::tupleExpression() {
|
|
TupleExpressionContext *_localctx = _tracker.createInstance<TupleExpressionContext>(_ctx, getState());
|
|
enterRule(_localctx, 78, SolidityParser::RuleTupleExpression);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(757);
|
|
match(SolidityParser::LParen);
|
|
|
|
setState(759);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 75, _ctx)) {
|
|
case 1: {
|
|
setState(758);
|
|
expression(0);
|
|
break;
|
|
}
|
|
|
|
}
|
|
setState(767);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == SolidityParser::Comma) {
|
|
setState(761);
|
|
match(SolidityParser::Comma);
|
|
setState(763);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 76, _ctx)) {
|
|
case 1: {
|
|
setState(762);
|
|
expression(0);
|
|
break;
|
|
}
|
|
|
|
}
|
|
setState(769);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
setState(770);
|
|
match(SolidityParser::RParen);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- InlineArrayExpressionContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::InlineArrayExpressionContext::InlineArrayExpressionContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::InlineArrayExpressionContext::LBrack() {
|
|
return getToken(SolidityParser::LBrack, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::InlineArrayExpressionContext::RBrack() {
|
|
return getToken(SolidityParser::RBrack, 0);
|
|
}
|
|
|
|
std::vector<SolidityParser::ExpressionContext *> SolidityParser::InlineArrayExpressionContext::expression() {
|
|
return getRuleContexts<SolidityParser::ExpressionContext>();
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::InlineArrayExpressionContext::expression(size_t i) {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::InlineArrayExpressionContext::Comma() {
|
|
return getTokens(SolidityParser::Comma);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::InlineArrayExpressionContext::Comma(size_t i) {
|
|
return getToken(SolidityParser::Comma, i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::InlineArrayExpressionContext::getRuleIndex() const {
|
|
return SolidityParser::RuleInlineArrayExpression;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::InlineArrayExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitInlineArrayExpression(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::InlineArrayExpressionContext* SolidityParser::inlineArrayExpression() {
|
|
InlineArrayExpressionContext *_localctx = _tracker.createInstance<InlineArrayExpressionContext>(_ctx, getState());
|
|
enterRule(_localctx, 80, SolidityParser::RuleInlineArrayExpression);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(772);
|
|
match(SolidityParser::LBrack);
|
|
|
|
setState(773);
|
|
expression(0);
|
|
setState(778);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == SolidityParser::Comma) {
|
|
setState(774);
|
|
match(SolidityParser::Comma);
|
|
setState(775);
|
|
expression(0);
|
|
setState(780);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
setState(781);
|
|
match(SolidityParser::RBrack);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- IdentifierContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::IdentifierContext::IdentifierContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::IdentifierContext::Identifier() {
|
|
return getToken(SolidityParser::Identifier, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::IdentifierContext::From() {
|
|
return getToken(SolidityParser::From, 0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::IdentifierContext::getRuleIndex() const {
|
|
return SolidityParser::RuleIdentifier;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::IdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitIdentifier(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::IdentifierContext* SolidityParser::identifier() {
|
|
IdentifierContext *_localctx = _tracker.createInstance<IdentifierContext>(_ctx, getState());
|
|
enterRule(_localctx, 82, SolidityParser::RuleIdentifier);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(783);
|
|
_la = _input->LA(1);
|
|
if (!(_la == SolidityParser::From || _la == SolidityParser::Identifier)) {
|
|
_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;
|
|
}
|
|
|
|
//----------------- LiteralContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::LiteralContext::LiteralContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
SolidityParser::StringLiteralContext* SolidityParser::LiteralContext::stringLiteral() {
|
|
return getRuleContext<SolidityParser::StringLiteralContext>(0);
|
|
}
|
|
|
|
SolidityParser::NumberLiteralContext* SolidityParser::LiteralContext::numberLiteral() {
|
|
return getRuleContext<SolidityParser::NumberLiteralContext>(0);
|
|
}
|
|
|
|
SolidityParser::boolLiteralContext* SolidityParser::LiteralContext::boolLiteral() {
|
|
return getRuleContext<SolidityParser::boolLiteralContext>(0);
|
|
}
|
|
|
|
SolidityParser::HexStringLiteralContext* SolidityParser::LiteralContext::hexStringLiteral() {
|
|
return getRuleContext<SolidityParser::HexStringLiteralContext>(0);
|
|
}
|
|
|
|
SolidityParser::UnicodeStringLiteralContext* SolidityParser::LiteralContext::unicodeStringLiteral() {
|
|
return getRuleContext<SolidityParser::UnicodeStringLiteralContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::LiteralContext::getRuleIndex() const {
|
|
return SolidityParser::RuleLiteral;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::LiteralContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitLiteral(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::LiteralContext* SolidityParser::literal() {
|
|
LiteralContext *_localctx = _tracker.createInstance<LiteralContext>(_ctx, getState());
|
|
enterRule(_localctx, 84, SolidityParser::RuleLiteral);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(790);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case SolidityParser::StringLiteral: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(785);
|
|
stringLiteral();
|
|
break;
|
|
}
|
|
|
|
case SolidityParser::HexNumber:
|
|
case SolidityParser::DecimalNumber: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(786);
|
|
numberLiteral();
|
|
break;
|
|
}
|
|
|
|
case SolidityParser::False:
|
|
case SolidityParser::True: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(787);
|
|
boolLiteral();
|
|
break;
|
|
}
|
|
|
|
case SolidityParser::HexString: {
|
|
enterOuterAlt(_localctx, 4);
|
|
setState(788);
|
|
hexStringLiteral();
|
|
break;
|
|
}
|
|
|
|
case SolidityParser::UnicodeStringLiteral: {
|
|
enterOuterAlt(_localctx, 5);
|
|
setState(789);
|
|
unicodeStringLiteral();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- boolLiteralContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::boolLiteralContext::boolLiteralContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::boolLiteralContext::True() {
|
|
return getToken(SolidityParser::True, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::boolLiteralContext::False() {
|
|
return getToken(SolidityParser::False, 0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::boolLiteralContext::getRuleIndex() const {
|
|
return SolidityParser::RuleboolLiteral;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::boolLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitBooleanLiteral(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::boolLiteralContext* SolidityParser::boolLiteral() {
|
|
boolLiteralContext *_localctx = _tracker.createInstance<boolLiteralContext>(_ctx, getState());
|
|
enterRule(_localctx, 86, SolidityParser::RuleboolLiteral);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(792);
|
|
_la = _input->LA(1);
|
|
if (!(_la == SolidityParser::False
|
|
|
|
|| _la == SolidityParser::True)) {
|
|
_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;
|
|
}
|
|
|
|
//----------------- StringLiteralContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::StringLiteralContext::StringLiteralContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::StringLiteralContext::StringLiteral() {
|
|
return getTokens(SolidityParser::StringLiteral);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::StringLiteralContext::StringLiteral(size_t i) {
|
|
return getToken(SolidityParser::StringLiteral, i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::StringLiteralContext::getRuleIndex() const {
|
|
return SolidityParser::RuleStringLiteral;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::StringLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitStringLiteral(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::StringLiteralContext* SolidityParser::stringLiteral() {
|
|
StringLiteralContext *_localctx = _tracker.createInstance<StringLiteralContext>(_ctx, getState());
|
|
enterRule(_localctx, 88, SolidityParser::RuleStringLiteral);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(795);
|
|
_errHandler->sync(this);
|
|
alt = 1;
|
|
do {
|
|
switch (alt) {
|
|
case 1: {
|
|
setState(794);
|
|
match(SolidityParser::StringLiteral);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
setState(797);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 80, _ctx);
|
|
} while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- HexStringLiteralContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::HexStringLiteralContext::HexStringLiteralContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::HexStringLiteralContext::HexString() {
|
|
return getTokens(SolidityParser::HexString);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::HexStringLiteralContext::HexString(size_t i) {
|
|
return getToken(SolidityParser::HexString, i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::HexStringLiteralContext::getRuleIndex() const {
|
|
return SolidityParser::RuleHexStringLiteral;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::HexStringLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitHexStringLiteral(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::HexStringLiteralContext* SolidityParser::hexStringLiteral() {
|
|
HexStringLiteralContext *_localctx = _tracker.createInstance<HexStringLiteralContext>(_ctx, getState());
|
|
enterRule(_localctx, 90, SolidityParser::RuleHexStringLiteral);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(800);
|
|
_errHandler->sync(this);
|
|
alt = 1;
|
|
do {
|
|
switch (alt) {
|
|
case 1: {
|
|
setState(799);
|
|
match(SolidityParser::HexString);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
setState(802);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 81, _ctx);
|
|
} while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- UnicodeStringLiteralContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::UnicodeStringLiteralContext::UnicodeStringLiteralContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::UnicodeStringLiteralContext::UnicodeStringLiteral() {
|
|
return getTokens(SolidityParser::UnicodeStringLiteral);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::UnicodeStringLiteralContext::UnicodeStringLiteral(size_t i) {
|
|
return getToken(SolidityParser::UnicodeStringLiteral, i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::UnicodeStringLiteralContext::getRuleIndex() const {
|
|
return SolidityParser::RuleUnicodeStringLiteral;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::UnicodeStringLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitUnicodeStringLiteral(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::UnicodeStringLiteralContext* SolidityParser::unicodeStringLiteral() {
|
|
UnicodeStringLiteralContext *_localctx = _tracker.createInstance<UnicodeStringLiteralContext>(_ctx, getState());
|
|
enterRule(_localctx, 92, SolidityParser::RuleUnicodeStringLiteral);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(805);
|
|
_errHandler->sync(this);
|
|
alt = 1;
|
|
do {
|
|
switch (alt) {
|
|
case 1: {
|
|
setState(804);
|
|
match(SolidityParser::UnicodeStringLiteral);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
setState(807);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 82, _ctx);
|
|
} while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- NumberLiteralContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::NumberLiteralContext::NumberLiteralContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::NumberLiteralContext::DecimalNumber() {
|
|
return getToken(SolidityParser::DecimalNumber, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::NumberLiteralContext::HexNumber() {
|
|
return getToken(SolidityParser::HexNumber, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::NumberLiteralContext::NumberUnit() {
|
|
return getToken(SolidityParser::NumberUnit, 0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::NumberLiteralContext::getRuleIndex() const {
|
|
return SolidityParser::RuleNumberLiteral;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::NumberLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitNumberLiteral(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::NumberLiteralContext* SolidityParser::numberLiteral() {
|
|
NumberLiteralContext *_localctx = _tracker.createInstance<NumberLiteralContext>(_ctx, getState());
|
|
enterRule(_localctx, 94, SolidityParser::RuleNumberLiteral);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(809);
|
|
_la = _input->LA(1);
|
|
if (!(_la == SolidityParser::HexNumber
|
|
|
|
|| _la == SolidityParser::DecimalNumber)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(811);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 83, _ctx)) {
|
|
case 1: {
|
|
setState(810);
|
|
match(SolidityParser::NumberUnit);
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- BlockContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::BlockContext::BlockContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::BlockContext::LBrace() {
|
|
return getToken(SolidityParser::LBrace, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::BlockContext::RBrace() {
|
|
return getToken(SolidityParser::RBrace, 0);
|
|
}
|
|
|
|
std::vector<SolidityParser::StatementContext *> SolidityParser::BlockContext::statement() {
|
|
return getRuleContexts<SolidityParser::StatementContext>();
|
|
}
|
|
|
|
SolidityParser::StatementContext* SolidityParser::BlockContext::statement(size_t i) {
|
|
return getRuleContext<SolidityParser::StatementContext>(i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::BlockContext::getRuleIndex() const {
|
|
return SolidityParser::RuleBlock;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::BlockContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitBlock(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::BlockContext* SolidityParser::block() {
|
|
BlockContext *_localctx = _tracker.createInstance<BlockContext>(_ctx, getState());
|
|
enterRule(_localctx, 96, SolidityParser::RuleBlock);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(813);
|
|
match(SolidityParser::LBrace);
|
|
setState(817);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 84, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
setState(814);
|
|
statement();
|
|
}
|
|
setState(819);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 84, _ctx);
|
|
}
|
|
setState(820);
|
|
match(SolidityParser::RBrace);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- StatementContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::StatementContext::StatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
SolidityParser::BlockContext* SolidityParser::StatementContext::block() {
|
|
return getRuleContext<SolidityParser::BlockContext>(0);
|
|
}
|
|
|
|
SolidityParser::SimpleStatementContext* SolidityParser::StatementContext::simpleStatement() {
|
|
return getRuleContext<SolidityParser::SimpleStatementContext>(0);
|
|
}
|
|
|
|
SolidityParser::IfStatementContext* SolidityParser::StatementContext::ifStatement() {
|
|
return getRuleContext<SolidityParser::IfStatementContext>(0);
|
|
}
|
|
|
|
SolidityParser::ForStatementContext* SolidityParser::StatementContext::forStatement() {
|
|
return getRuleContext<SolidityParser::ForStatementContext>(0);
|
|
}
|
|
|
|
SolidityParser::WhileStatementContext* SolidityParser::StatementContext::whileStatement() {
|
|
return getRuleContext<SolidityParser::WhileStatementContext>(0);
|
|
}
|
|
|
|
SolidityParser::DoWhileStatementContext* SolidityParser::StatementContext::doWhileStatement() {
|
|
return getRuleContext<SolidityParser::DoWhileStatementContext>(0);
|
|
}
|
|
|
|
SolidityParser::ContinueStatementContext* SolidityParser::StatementContext::continueStatement() {
|
|
return getRuleContext<SolidityParser::ContinueStatementContext>(0);
|
|
}
|
|
|
|
SolidityParser::BreakStatementContext* SolidityParser::StatementContext::breakStatement() {
|
|
return getRuleContext<SolidityParser::BreakStatementContext>(0);
|
|
}
|
|
|
|
SolidityParser::TryStatementContext* SolidityParser::StatementContext::tryStatement() {
|
|
return getRuleContext<SolidityParser::TryStatementContext>(0);
|
|
}
|
|
|
|
SolidityParser::ReturnStatementContext* SolidityParser::StatementContext::returnStatement() {
|
|
return getRuleContext<SolidityParser::ReturnStatementContext>(0);
|
|
}
|
|
|
|
SolidityParser::EmitStatementContext* SolidityParser::StatementContext::emitStatement() {
|
|
return getRuleContext<SolidityParser::EmitStatementContext>(0);
|
|
}
|
|
|
|
SolidityParser::AssemblyStatementContext* SolidityParser::StatementContext::assemblyStatement() {
|
|
return getRuleContext<SolidityParser::AssemblyStatementContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::StatementContext::getRuleIndex() const {
|
|
return SolidityParser::RuleStatement;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::StatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::StatementContext* SolidityParser::statement() {
|
|
StatementContext *_localctx = _tracker.createInstance<StatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 98, SolidityParser::RuleStatement);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(834);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 85, _ctx)) {
|
|
case 1: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(822);
|
|
block();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(823);
|
|
simpleStatement();
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(824);
|
|
ifStatement();
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
enterOuterAlt(_localctx, 4);
|
|
setState(825);
|
|
forStatement();
|
|
break;
|
|
}
|
|
|
|
case 5: {
|
|
enterOuterAlt(_localctx, 5);
|
|
setState(826);
|
|
whileStatement();
|
|
break;
|
|
}
|
|
|
|
case 6: {
|
|
enterOuterAlt(_localctx, 6);
|
|
setState(827);
|
|
doWhileStatement();
|
|
break;
|
|
}
|
|
|
|
case 7: {
|
|
enterOuterAlt(_localctx, 7);
|
|
setState(828);
|
|
continueStatement();
|
|
break;
|
|
}
|
|
|
|
case 8: {
|
|
enterOuterAlt(_localctx, 8);
|
|
setState(829);
|
|
breakStatement();
|
|
break;
|
|
}
|
|
|
|
case 9: {
|
|
enterOuterAlt(_localctx, 9);
|
|
setState(830);
|
|
tryStatement();
|
|
break;
|
|
}
|
|
|
|
case 10: {
|
|
enterOuterAlt(_localctx, 10);
|
|
setState(831);
|
|
returnStatement();
|
|
break;
|
|
}
|
|
|
|
case 11: {
|
|
enterOuterAlt(_localctx, 11);
|
|
setState(832);
|
|
emitStatement();
|
|
break;
|
|
}
|
|
|
|
case 12: {
|
|
enterOuterAlt(_localctx, 12);
|
|
setState(833);
|
|
assemblyStatement();
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- SimpleStatementContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::SimpleStatementContext::SimpleStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
SolidityParser::VariableDeclarationStatementContext* SolidityParser::SimpleStatementContext::variableDeclarationStatement() {
|
|
return getRuleContext<SolidityParser::VariableDeclarationStatementContext>(0);
|
|
}
|
|
|
|
SolidityParser::ExpressionStatementContext* SolidityParser::SimpleStatementContext::expressionStatement() {
|
|
return getRuleContext<SolidityParser::ExpressionStatementContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::SimpleStatementContext::getRuleIndex() const {
|
|
return SolidityParser::RuleSimpleStatement;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::SimpleStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitSimpleStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::SimpleStatementContext* SolidityParser::simpleStatement() {
|
|
SimpleStatementContext *_localctx = _tracker.createInstance<SimpleStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 100, SolidityParser::RuleSimpleStatement);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(838);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 86, _ctx)) {
|
|
case 1: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(836);
|
|
variableDeclarationStatement();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(837);
|
|
expressionStatement();
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- IfStatementContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::IfStatementContext::IfStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::IfStatementContext::If() {
|
|
return getToken(SolidityParser::If, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::IfStatementContext::LParen() {
|
|
return getToken(SolidityParser::LParen, 0);
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::IfStatementContext::expression() {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::IfStatementContext::RParen() {
|
|
return getToken(SolidityParser::RParen, 0);
|
|
}
|
|
|
|
std::vector<SolidityParser::StatementContext *> SolidityParser::IfStatementContext::statement() {
|
|
return getRuleContexts<SolidityParser::StatementContext>();
|
|
}
|
|
|
|
SolidityParser::StatementContext* SolidityParser::IfStatementContext::statement(size_t i) {
|
|
return getRuleContext<SolidityParser::StatementContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::IfStatementContext::Else() {
|
|
return getToken(SolidityParser::Else, 0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::IfStatementContext::getRuleIndex() const {
|
|
return SolidityParser::RuleIfStatement;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::IfStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitIfStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::IfStatementContext* SolidityParser::ifStatement() {
|
|
IfStatementContext *_localctx = _tracker.createInstance<IfStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 102, SolidityParser::RuleIfStatement);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(840);
|
|
match(SolidityParser::If);
|
|
setState(841);
|
|
match(SolidityParser::LParen);
|
|
setState(842);
|
|
expression(0);
|
|
setState(843);
|
|
match(SolidityParser::RParen);
|
|
setState(844);
|
|
statement();
|
|
setState(847);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 87, _ctx)) {
|
|
case 1: {
|
|
setState(845);
|
|
match(SolidityParser::Else);
|
|
setState(846);
|
|
statement();
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ForStatementContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::ForStatementContext::ForStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ForStatementContext::For() {
|
|
return getToken(SolidityParser::For, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ForStatementContext::LParen() {
|
|
return getToken(SolidityParser::LParen, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ForStatementContext::RParen() {
|
|
return getToken(SolidityParser::RParen, 0);
|
|
}
|
|
|
|
SolidityParser::StatementContext* SolidityParser::ForStatementContext::statement() {
|
|
return getRuleContext<SolidityParser::StatementContext>(0);
|
|
}
|
|
|
|
SolidityParser::SimpleStatementContext* SolidityParser::ForStatementContext::simpleStatement() {
|
|
return getRuleContext<SolidityParser::SimpleStatementContext>(0);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::ForStatementContext::Semicolon() {
|
|
return getTokens(SolidityParser::Semicolon);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ForStatementContext::Semicolon(size_t i) {
|
|
return getToken(SolidityParser::Semicolon, i);
|
|
}
|
|
|
|
SolidityParser::ExpressionStatementContext* SolidityParser::ForStatementContext::expressionStatement() {
|
|
return getRuleContext<SolidityParser::ExpressionStatementContext>(0);
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::ForStatementContext::expression() {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::ForStatementContext::getRuleIndex() const {
|
|
return SolidityParser::RuleForStatement;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::ForStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitForStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::ForStatementContext* SolidityParser::forStatement() {
|
|
ForStatementContext *_localctx = _tracker.createInstance<ForStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 104, SolidityParser::RuleForStatement);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(849);
|
|
match(SolidityParser::For);
|
|
setState(850);
|
|
match(SolidityParser::LParen);
|
|
setState(853);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 88, _ctx)) {
|
|
case 1: {
|
|
setState(851);
|
|
simpleStatement();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(852);
|
|
match(SolidityParser::Semicolon);
|
|
break;
|
|
}
|
|
|
|
}
|
|
setState(857);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 89, _ctx)) {
|
|
case 1: {
|
|
setState(855);
|
|
expressionStatement();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(856);
|
|
match(SolidityParser::Semicolon);
|
|
break;
|
|
}
|
|
|
|
}
|
|
setState(860);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 90, _ctx)) {
|
|
case 1: {
|
|
setState(859);
|
|
expression(0);
|
|
break;
|
|
}
|
|
|
|
}
|
|
setState(862);
|
|
match(SolidityParser::RParen);
|
|
setState(863);
|
|
statement();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- WhileStatementContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::WhileStatementContext::WhileStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::WhileStatementContext::While() {
|
|
return getToken(SolidityParser::While, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::WhileStatementContext::LParen() {
|
|
return getToken(SolidityParser::LParen, 0);
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::WhileStatementContext::expression() {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::WhileStatementContext::RParen() {
|
|
return getToken(SolidityParser::RParen, 0);
|
|
}
|
|
|
|
SolidityParser::StatementContext* SolidityParser::WhileStatementContext::statement() {
|
|
return getRuleContext<SolidityParser::StatementContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::WhileStatementContext::getRuleIndex() const {
|
|
return SolidityParser::RuleWhileStatement;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::WhileStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitWhileStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::WhileStatementContext* SolidityParser::whileStatement() {
|
|
WhileStatementContext *_localctx = _tracker.createInstance<WhileStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 106, SolidityParser::RuleWhileStatement);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(865);
|
|
match(SolidityParser::While);
|
|
setState(866);
|
|
match(SolidityParser::LParen);
|
|
setState(867);
|
|
expression(0);
|
|
setState(868);
|
|
match(SolidityParser::RParen);
|
|
setState(869);
|
|
statement();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- DoWhileStatementContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::DoWhileStatementContext::DoWhileStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::DoWhileStatementContext::Do() {
|
|
return getToken(SolidityParser::Do, 0);
|
|
}
|
|
|
|
SolidityParser::StatementContext* SolidityParser::DoWhileStatementContext::statement() {
|
|
return getRuleContext<SolidityParser::StatementContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::DoWhileStatementContext::While() {
|
|
return getToken(SolidityParser::While, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::DoWhileStatementContext::LParen() {
|
|
return getToken(SolidityParser::LParen, 0);
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::DoWhileStatementContext::expression() {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::DoWhileStatementContext::RParen() {
|
|
return getToken(SolidityParser::RParen, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::DoWhileStatementContext::Semicolon() {
|
|
return getToken(SolidityParser::Semicolon, 0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::DoWhileStatementContext::getRuleIndex() const {
|
|
return SolidityParser::RuleDoWhileStatement;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::DoWhileStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitDoWhileStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::DoWhileStatementContext* SolidityParser::doWhileStatement() {
|
|
DoWhileStatementContext *_localctx = _tracker.createInstance<DoWhileStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 108, SolidityParser::RuleDoWhileStatement);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(871);
|
|
match(SolidityParser::Do);
|
|
setState(872);
|
|
statement();
|
|
setState(873);
|
|
match(SolidityParser::While);
|
|
setState(874);
|
|
match(SolidityParser::LParen);
|
|
setState(875);
|
|
expression(0);
|
|
setState(876);
|
|
match(SolidityParser::RParen);
|
|
setState(877);
|
|
match(SolidityParser::Semicolon);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ContinueStatementContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::ContinueStatementContext::ContinueStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ContinueStatementContext::Continue() {
|
|
return getToken(SolidityParser::Continue, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ContinueStatementContext::Semicolon() {
|
|
return getToken(SolidityParser::Semicolon, 0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::ContinueStatementContext::getRuleIndex() const {
|
|
return SolidityParser::RuleContinueStatement;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::ContinueStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitContinueStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::ContinueStatementContext* SolidityParser::continueStatement() {
|
|
ContinueStatementContext *_localctx = _tracker.createInstance<ContinueStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 110, SolidityParser::RuleContinueStatement);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(879);
|
|
match(SolidityParser::Continue);
|
|
setState(880);
|
|
match(SolidityParser::Semicolon);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- BreakStatementContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::BreakStatementContext::BreakStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::BreakStatementContext::Break() {
|
|
return getToken(SolidityParser::Break, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::BreakStatementContext::Semicolon() {
|
|
return getToken(SolidityParser::Semicolon, 0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::BreakStatementContext::getRuleIndex() const {
|
|
return SolidityParser::RuleBreakStatement;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::BreakStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitBreakStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::BreakStatementContext* SolidityParser::breakStatement() {
|
|
BreakStatementContext *_localctx = _tracker.createInstance<BreakStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 112, SolidityParser::RuleBreakStatement);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(882);
|
|
match(SolidityParser::Break);
|
|
setState(883);
|
|
match(SolidityParser::Semicolon);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- TryStatementContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::TryStatementContext::TryStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::TryStatementContext::Try() {
|
|
return getToken(SolidityParser::Try, 0);
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::TryStatementContext::expression() {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(0);
|
|
}
|
|
|
|
SolidityParser::BlockContext* SolidityParser::TryStatementContext::block() {
|
|
return getRuleContext<SolidityParser::BlockContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::TryStatementContext::Returns() {
|
|
return getToken(SolidityParser::Returns, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::TryStatementContext::LParen() {
|
|
return getToken(SolidityParser::LParen, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::TryStatementContext::RParen() {
|
|
return getToken(SolidityParser::RParen, 0);
|
|
}
|
|
|
|
std::vector<SolidityParser::CatchClauseContext *> SolidityParser::TryStatementContext::catchClause() {
|
|
return getRuleContexts<SolidityParser::CatchClauseContext>();
|
|
}
|
|
|
|
SolidityParser::CatchClauseContext* SolidityParser::TryStatementContext::catchClause(size_t i) {
|
|
return getRuleContext<SolidityParser::CatchClauseContext>(i);
|
|
}
|
|
|
|
SolidityParser::ParameterListContext* SolidityParser::TryStatementContext::parameterList() {
|
|
return getRuleContext<SolidityParser::ParameterListContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::TryStatementContext::getRuleIndex() const {
|
|
return SolidityParser::RuleTryStatement;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::TryStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitTryStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::TryStatementContext* SolidityParser::tryStatement() {
|
|
TryStatementContext *_localctx = _tracker.createInstance<TryStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 114, SolidityParser::RuleTryStatement);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(885);
|
|
match(SolidityParser::Try);
|
|
setState(886);
|
|
expression(0);
|
|
setState(892);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == SolidityParser::Returns) {
|
|
setState(887);
|
|
match(SolidityParser::Returns);
|
|
setState(888);
|
|
match(SolidityParser::LParen);
|
|
setState(889);
|
|
dynamic_cast<TryStatementContext *>(_localctx)->returnParameters = parameterList();
|
|
setState(890);
|
|
match(SolidityParser::RParen);
|
|
}
|
|
setState(894);
|
|
block();
|
|
setState(896);
|
|
_errHandler->sync(this);
|
|
alt = 1;
|
|
do {
|
|
switch (alt) {
|
|
case 1: {
|
|
setState(895);
|
|
catchClause();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
setState(898);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 92, _ctx);
|
|
} while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- CatchClauseContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::CatchClauseContext::CatchClauseContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::CatchClauseContext::Catch() {
|
|
return getToken(SolidityParser::Catch, 0);
|
|
}
|
|
|
|
SolidityParser::BlockContext* SolidityParser::CatchClauseContext::block() {
|
|
return getRuleContext<SolidityParser::BlockContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::CatchClauseContext::LParen() {
|
|
return getToken(SolidityParser::LParen, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::CatchClauseContext::RParen() {
|
|
return getToken(SolidityParser::RParen, 0);
|
|
}
|
|
|
|
SolidityParser::IdentifierContext* SolidityParser::CatchClauseContext::identifier() {
|
|
return getRuleContext<SolidityParser::IdentifierContext>(0);
|
|
}
|
|
|
|
SolidityParser::ParameterListContext* SolidityParser::CatchClauseContext::parameterList() {
|
|
return getRuleContext<SolidityParser::ParameterListContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::CatchClauseContext::getRuleIndex() const {
|
|
return SolidityParser::RuleCatchClause;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::CatchClauseContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitCatchClause(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::CatchClauseContext* SolidityParser::catchClause() {
|
|
CatchClauseContext *_localctx = _tracker.createInstance<CatchClauseContext>(_ctx, getState());
|
|
enterRule(_localctx, 116, SolidityParser::RuleCatchClause);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(900);
|
|
match(SolidityParser::Catch);
|
|
setState(908);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == SolidityParser::From || _la == SolidityParser::LParen
|
|
|
|
|| _la == SolidityParser::Identifier) {
|
|
setState(902);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == SolidityParser::From || _la == SolidityParser::Identifier) {
|
|
setState(901);
|
|
identifier();
|
|
}
|
|
setState(904);
|
|
match(SolidityParser::LParen);
|
|
|
|
setState(905);
|
|
dynamic_cast<CatchClauseContext *>(_localctx)->arguments = parameterList();
|
|
setState(906);
|
|
match(SolidityParser::RParen);
|
|
}
|
|
setState(910);
|
|
block();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ReturnStatementContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::ReturnStatementContext::ReturnStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ReturnStatementContext::Return() {
|
|
return getToken(SolidityParser::Return, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ReturnStatementContext::Semicolon() {
|
|
return getToken(SolidityParser::Semicolon, 0);
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::ReturnStatementContext::expression() {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::ReturnStatementContext::getRuleIndex() const {
|
|
return SolidityParser::RuleReturnStatement;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::ReturnStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitReturnStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::ReturnStatementContext* SolidityParser::returnStatement() {
|
|
ReturnStatementContext *_localctx = _tracker.createInstance<ReturnStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 118, SolidityParser::RuleReturnStatement);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(912);
|
|
match(SolidityParser::Return);
|
|
setState(914);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 95, _ctx)) {
|
|
case 1: {
|
|
setState(913);
|
|
expression(0);
|
|
break;
|
|
}
|
|
|
|
}
|
|
setState(916);
|
|
match(SolidityParser::Semicolon);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- EmitStatementContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::EmitStatementContext::EmitStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::EmitStatementContext::Emit() {
|
|
return getToken(SolidityParser::Emit, 0);
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::EmitStatementContext::expression() {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(0);
|
|
}
|
|
|
|
SolidityParser::CallArgumentListContext* SolidityParser::EmitStatementContext::callArgumentList() {
|
|
return getRuleContext<SolidityParser::CallArgumentListContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::EmitStatementContext::Semicolon() {
|
|
return getToken(SolidityParser::Semicolon, 0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::EmitStatementContext::getRuleIndex() const {
|
|
return SolidityParser::RuleEmitStatement;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::EmitStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitEmitStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::EmitStatementContext* SolidityParser::emitStatement() {
|
|
EmitStatementContext *_localctx = _tracker.createInstance<EmitStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 120, SolidityParser::RuleEmitStatement);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(918);
|
|
match(SolidityParser::Emit);
|
|
setState(919);
|
|
expression(0);
|
|
setState(920);
|
|
callArgumentList();
|
|
setState(921);
|
|
match(SolidityParser::Semicolon);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- AssemblyStatementContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::AssemblyStatementContext::AssemblyStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::AssemblyStatementContext::Assembly() {
|
|
return getToken(SolidityParser::Assembly, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::AssemblyStatementContext::AssemblyLBrace() {
|
|
return getToken(SolidityParser::AssemblyLBrace, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::AssemblyStatementContext::YulRBrace() {
|
|
return getToken(SolidityParser::YulRBrace, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::AssemblyStatementContext::AssemblyDialect() {
|
|
return getToken(SolidityParser::AssemblyDialect, 0);
|
|
}
|
|
|
|
std::vector<SolidityParser::YulStatementContext *> SolidityParser::AssemblyStatementContext::yulStatement() {
|
|
return getRuleContexts<SolidityParser::YulStatementContext>();
|
|
}
|
|
|
|
SolidityParser::YulStatementContext* SolidityParser::AssemblyStatementContext::yulStatement(size_t i) {
|
|
return getRuleContext<SolidityParser::YulStatementContext>(i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::AssemblyStatementContext::getRuleIndex() const {
|
|
return SolidityParser::RuleAssemblyStatement;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::AssemblyStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitAssemblyStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::AssemblyStatementContext* SolidityParser::assemblyStatement() {
|
|
AssemblyStatementContext *_localctx = _tracker.createInstance<AssemblyStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 122, SolidityParser::RuleAssemblyStatement);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(923);
|
|
match(SolidityParser::Assembly);
|
|
setState(925);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == SolidityParser::AssemblyDialect) {
|
|
setState(924);
|
|
match(SolidityParser::AssemblyDialect);
|
|
}
|
|
setState(927);
|
|
match(SolidityParser::AssemblyLBrace);
|
|
setState(931);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (((((_la - 129) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 129)) & ((1ULL << (SolidityParser::YulBreak - 129))
|
|
| (1ULL << (SolidityParser::YulContinue - 129))
|
|
| (1ULL << (SolidityParser::YulFor - 129))
|
|
| (1ULL << (SolidityParser::YulFunction - 129))
|
|
| (1ULL << (SolidityParser::YulIf - 129))
|
|
| (1ULL << (SolidityParser::YulLeave - 129))
|
|
| (1ULL << (SolidityParser::YulLet - 129))
|
|
| (1ULL << (SolidityParser::YulSwitch - 129))
|
|
| (1ULL << (SolidityParser::YulEVMBuiltin - 129))
|
|
| (1ULL << (SolidityParser::YulLBrace - 129))
|
|
| (1ULL << (SolidityParser::YulIdentifier - 129)))) != 0)) {
|
|
setState(928);
|
|
yulStatement();
|
|
setState(933);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
setState(934);
|
|
match(SolidityParser::YulRBrace);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- VariableDeclarationListContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::VariableDeclarationListContext::VariableDeclarationListContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<SolidityParser::VariableDeclarationContext *> SolidityParser::VariableDeclarationListContext::variableDeclaration() {
|
|
return getRuleContexts<SolidityParser::VariableDeclarationContext>();
|
|
}
|
|
|
|
SolidityParser::VariableDeclarationContext* SolidityParser::VariableDeclarationListContext::variableDeclaration(size_t i) {
|
|
return getRuleContext<SolidityParser::VariableDeclarationContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::VariableDeclarationListContext::Comma() {
|
|
return getTokens(SolidityParser::Comma);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::VariableDeclarationListContext::Comma(size_t i) {
|
|
return getToken(SolidityParser::Comma, i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::VariableDeclarationListContext::getRuleIndex() const {
|
|
return SolidityParser::RuleVariableDeclarationList;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::VariableDeclarationListContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitVariableDeclarationList(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::VariableDeclarationListContext* SolidityParser::variableDeclarationList() {
|
|
VariableDeclarationListContext *_localctx = _tracker.createInstance<VariableDeclarationListContext>(_ctx, getState());
|
|
enterRule(_localctx, 124, SolidityParser::RuleVariableDeclarationList);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(936);
|
|
dynamic_cast<VariableDeclarationListContext *>(_localctx)->variableDeclarationContext = variableDeclaration();
|
|
dynamic_cast<VariableDeclarationListContext *>(_localctx)->variableDeclarations.push_back(dynamic_cast<VariableDeclarationListContext *>(_localctx)->variableDeclarationContext);
|
|
setState(941);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == SolidityParser::Comma) {
|
|
setState(937);
|
|
match(SolidityParser::Comma);
|
|
setState(938);
|
|
dynamic_cast<VariableDeclarationListContext *>(_localctx)->variableDeclarationContext = variableDeclaration();
|
|
dynamic_cast<VariableDeclarationListContext *>(_localctx)->variableDeclarations.push_back(dynamic_cast<VariableDeclarationListContext *>(_localctx)->variableDeclarationContext);
|
|
setState(943);
|
|
_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;
|
|
}
|
|
|
|
//----------------- VariableDeclarationTupleContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::VariableDeclarationTupleContext::VariableDeclarationTupleContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::VariableDeclarationTupleContext::LParen() {
|
|
return getToken(SolidityParser::LParen, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::VariableDeclarationTupleContext::RParen() {
|
|
return getToken(SolidityParser::RParen, 0);
|
|
}
|
|
|
|
std::vector<SolidityParser::VariableDeclarationContext *> SolidityParser::VariableDeclarationTupleContext::variableDeclaration() {
|
|
return getRuleContexts<SolidityParser::VariableDeclarationContext>();
|
|
}
|
|
|
|
SolidityParser::VariableDeclarationContext* SolidityParser::VariableDeclarationTupleContext::variableDeclaration(size_t i) {
|
|
return getRuleContext<SolidityParser::VariableDeclarationContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::VariableDeclarationTupleContext::Comma() {
|
|
return getTokens(SolidityParser::Comma);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::VariableDeclarationTupleContext::Comma(size_t i) {
|
|
return getToken(SolidityParser::Comma, i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::VariableDeclarationTupleContext::getRuleIndex() const {
|
|
return SolidityParser::RuleVariableDeclarationTuple;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::VariableDeclarationTupleContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitVariableDeclarationTuple(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::VariableDeclarationTupleContext* SolidityParser::variableDeclarationTuple() {
|
|
VariableDeclarationTupleContext *_localctx = _tracker.createInstance<VariableDeclarationTupleContext>(_ctx, getState());
|
|
enterRule(_localctx, 126, SolidityParser::RuleVariableDeclarationTuple);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(944);
|
|
match(SolidityParser::LParen);
|
|
|
|
setState(948);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 99, _ctx);
|
|
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
|
if (alt == 1) {
|
|
setState(945);
|
|
match(SolidityParser::Comma);
|
|
}
|
|
setState(950);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 99, _ctx);
|
|
}
|
|
setState(951);
|
|
dynamic_cast<VariableDeclarationTupleContext *>(_localctx)->variableDeclarationContext = variableDeclaration();
|
|
dynamic_cast<VariableDeclarationTupleContext *>(_localctx)->variableDeclarations.push_back(dynamic_cast<VariableDeclarationTupleContext *>(_localctx)->variableDeclarationContext);
|
|
setState(959);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == SolidityParser::Comma) {
|
|
setState(953);
|
|
match(SolidityParser::Comma);
|
|
setState(955);
|
|
_errHandler->sync(this);
|
|
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 100, _ctx)) {
|
|
case 1: {
|
|
setState(954);
|
|
dynamic_cast<VariableDeclarationTupleContext *>(_localctx)->variableDeclarationContext = variableDeclaration();
|
|
dynamic_cast<VariableDeclarationTupleContext *>(_localctx)->variableDeclarations.push_back(dynamic_cast<VariableDeclarationTupleContext *>(_localctx)->variableDeclarationContext);
|
|
break;
|
|
}
|
|
|
|
}
|
|
setState(961);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
setState(962);
|
|
match(SolidityParser::RParen);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- VariableDeclarationStatementContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::VariableDeclarationStatementContext::VariableDeclarationStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::VariableDeclarationStatementContext::Semicolon() {
|
|
return getToken(SolidityParser::Semicolon, 0);
|
|
}
|
|
|
|
SolidityParser::VariableDeclarationContext* SolidityParser::VariableDeclarationStatementContext::variableDeclaration() {
|
|
return getRuleContext<SolidityParser::VariableDeclarationContext>(0);
|
|
}
|
|
|
|
SolidityParser::VariableDeclarationTupleContext* SolidityParser::VariableDeclarationStatementContext::variableDeclarationTuple() {
|
|
return getRuleContext<SolidityParser::VariableDeclarationTupleContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::VariableDeclarationStatementContext::Assign() {
|
|
return getToken(SolidityParser::Assign, 0);
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::VariableDeclarationStatementContext::expression() {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::VariableDeclarationStatementContext::getRuleIndex() const {
|
|
return SolidityParser::RuleVariableDeclarationStatement;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::VariableDeclarationStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitVariableDeclarationStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::VariableDeclarationStatementContext* SolidityParser::variableDeclarationStatement() {
|
|
VariableDeclarationStatementContext *_localctx = _tracker.createInstance<VariableDeclarationStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 128, SolidityParser::RuleVariableDeclarationStatement);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(973);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 103, _ctx)) {
|
|
case 1: {
|
|
setState(964);
|
|
variableDeclaration();
|
|
setState(967);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == SolidityParser::Assign) {
|
|
setState(965);
|
|
match(SolidityParser::Assign);
|
|
setState(966);
|
|
expression(0);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(969);
|
|
variableDeclarationTuple();
|
|
setState(970);
|
|
match(SolidityParser::Assign);
|
|
setState(971);
|
|
expression(0);
|
|
break;
|
|
}
|
|
|
|
}
|
|
setState(975);
|
|
match(SolidityParser::Semicolon);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- ExpressionStatementContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::ExpressionStatementContext::ExpressionStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
SolidityParser::ExpressionContext* SolidityParser::ExpressionStatementContext::expression() {
|
|
return getRuleContext<SolidityParser::ExpressionContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::ExpressionStatementContext::Semicolon() {
|
|
return getToken(SolidityParser::Semicolon, 0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::ExpressionStatementContext::getRuleIndex() const {
|
|
return SolidityParser::RuleExpressionStatement;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::ExpressionStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitExpressionStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::ExpressionStatementContext* SolidityParser::expressionStatement() {
|
|
ExpressionStatementContext *_localctx = _tracker.createInstance<ExpressionStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 130, SolidityParser::RuleExpressionStatement);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(977);
|
|
expression(0);
|
|
setState(978);
|
|
match(SolidityParser::Semicolon);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- MappingTypeContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::MappingTypeContext::MappingTypeContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::MappingTypeContext::Mapping() {
|
|
return getToken(SolidityParser::Mapping, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::MappingTypeContext::LParen() {
|
|
return getToken(SolidityParser::LParen, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::MappingTypeContext::Arrow() {
|
|
return getToken(SolidityParser::Arrow, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::MappingTypeContext::RParen() {
|
|
return getToken(SolidityParser::RParen, 0);
|
|
}
|
|
|
|
SolidityParser::MappingKeyTypeContext* SolidityParser::MappingTypeContext::mappingKeyType() {
|
|
return getRuleContext<SolidityParser::MappingKeyTypeContext>(0);
|
|
}
|
|
|
|
SolidityParser::TypeNameContext* SolidityParser::MappingTypeContext::typeName() {
|
|
return getRuleContext<SolidityParser::TypeNameContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::MappingTypeContext::getRuleIndex() const {
|
|
return SolidityParser::RuleMappingType;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::MappingTypeContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitMappingType(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::MappingTypeContext* SolidityParser::mappingType() {
|
|
MappingTypeContext *_localctx = _tracker.createInstance<MappingTypeContext>(_ctx, getState());
|
|
enterRule(_localctx, 132, SolidityParser::RuleMappingType);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(980);
|
|
match(SolidityParser::Mapping);
|
|
setState(981);
|
|
match(SolidityParser::LParen);
|
|
setState(982);
|
|
dynamic_cast<MappingTypeContext *>(_localctx)->key = mappingKeyType();
|
|
setState(983);
|
|
match(SolidityParser::Arrow);
|
|
setState(984);
|
|
dynamic_cast<MappingTypeContext *>(_localctx)->value = typeName(0);
|
|
setState(985);
|
|
match(SolidityParser::RParen);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- MappingKeyTypeContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::MappingKeyTypeContext::MappingKeyTypeContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
SolidityParser::ElementaryTypeNameContext* SolidityParser::MappingKeyTypeContext::elementaryTypeName() {
|
|
return getRuleContext<SolidityParser::ElementaryTypeNameContext>(0);
|
|
}
|
|
|
|
SolidityParser::UserDefinedTypeNameContext* SolidityParser::MappingKeyTypeContext::userDefinedTypeName() {
|
|
return getRuleContext<SolidityParser::UserDefinedTypeNameContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::MappingKeyTypeContext::getRuleIndex() const {
|
|
return SolidityParser::RuleMappingKeyType;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::MappingKeyTypeContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitMappingKeyType(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::MappingKeyTypeContext* SolidityParser::mappingKeyType() {
|
|
MappingKeyTypeContext *_localctx = _tracker.createInstance<MappingKeyTypeContext>(_ctx, getState());
|
|
enterRule(_localctx, 134, SolidityParser::RuleMappingKeyType);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(989);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 104, _ctx)) {
|
|
case 1: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(987);
|
|
elementaryTypeName(false);
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(988);
|
|
userDefinedTypeName();
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- YulStatementContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::YulStatementContext::YulStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
SolidityParser::YulBlockContext* SolidityParser::YulStatementContext::yulBlock() {
|
|
return getRuleContext<SolidityParser::YulBlockContext>(0);
|
|
}
|
|
|
|
SolidityParser::YulVariableDeclarationContext* SolidityParser::YulStatementContext::yulVariableDeclaration() {
|
|
return getRuleContext<SolidityParser::YulVariableDeclarationContext>(0);
|
|
}
|
|
|
|
SolidityParser::YulAssignmentContext* SolidityParser::YulStatementContext::yulAssignment() {
|
|
return getRuleContext<SolidityParser::YulAssignmentContext>(0);
|
|
}
|
|
|
|
SolidityParser::YulFunctionCallContext* SolidityParser::YulStatementContext::yulFunctionCall() {
|
|
return getRuleContext<SolidityParser::YulFunctionCallContext>(0);
|
|
}
|
|
|
|
SolidityParser::YulIfStatementContext* SolidityParser::YulStatementContext::yulIfStatement() {
|
|
return getRuleContext<SolidityParser::YulIfStatementContext>(0);
|
|
}
|
|
|
|
SolidityParser::YulForStatementContext* SolidityParser::YulStatementContext::yulForStatement() {
|
|
return getRuleContext<SolidityParser::YulForStatementContext>(0);
|
|
}
|
|
|
|
SolidityParser::YulSwitchStatementContext* SolidityParser::YulStatementContext::yulSwitchStatement() {
|
|
return getRuleContext<SolidityParser::YulSwitchStatementContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulStatementContext::YulLeave() {
|
|
return getToken(SolidityParser::YulLeave, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulStatementContext::YulBreak() {
|
|
return getToken(SolidityParser::YulBreak, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulStatementContext::YulContinue() {
|
|
return getToken(SolidityParser::YulContinue, 0);
|
|
}
|
|
|
|
SolidityParser::YulFunctionDefinitionContext* SolidityParser::YulStatementContext::yulFunctionDefinition() {
|
|
return getRuleContext<SolidityParser::YulFunctionDefinitionContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::YulStatementContext::getRuleIndex() const {
|
|
return SolidityParser::RuleYulStatement;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::YulStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitYulStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::YulStatementContext* SolidityParser::yulStatement() {
|
|
YulStatementContext *_localctx = _tracker.createInstance<YulStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 136, SolidityParser::RuleYulStatement);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(1002);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 105, _ctx)) {
|
|
case 1: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(991);
|
|
yulBlock();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(992);
|
|
yulVariableDeclaration();
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(993);
|
|
yulAssignment();
|
|
break;
|
|
}
|
|
|
|
case 4: {
|
|
enterOuterAlt(_localctx, 4);
|
|
setState(994);
|
|
yulFunctionCall();
|
|
break;
|
|
}
|
|
|
|
case 5: {
|
|
enterOuterAlt(_localctx, 5);
|
|
setState(995);
|
|
yulIfStatement();
|
|
break;
|
|
}
|
|
|
|
case 6: {
|
|
enterOuterAlt(_localctx, 6);
|
|
setState(996);
|
|
yulForStatement();
|
|
break;
|
|
}
|
|
|
|
case 7: {
|
|
enterOuterAlt(_localctx, 7);
|
|
setState(997);
|
|
yulSwitchStatement();
|
|
break;
|
|
}
|
|
|
|
case 8: {
|
|
enterOuterAlt(_localctx, 8);
|
|
setState(998);
|
|
match(SolidityParser::YulLeave);
|
|
break;
|
|
}
|
|
|
|
case 9: {
|
|
enterOuterAlt(_localctx, 9);
|
|
setState(999);
|
|
match(SolidityParser::YulBreak);
|
|
break;
|
|
}
|
|
|
|
case 10: {
|
|
enterOuterAlt(_localctx, 10);
|
|
setState(1000);
|
|
match(SolidityParser::YulContinue);
|
|
break;
|
|
}
|
|
|
|
case 11: {
|
|
enterOuterAlt(_localctx, 11);
|
|
setState(1001);
|
|
yulFunctionDefinition();
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- YulBlockContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::YulBlockContext::YulBlockContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulBlockContext::YulLBrace() {
|
|
return getToken(SolidityParser::YulLBrace, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulBlockContext::YulRBrace() {
|
|
return getToken(SolidityParser::YulRBrace, 0);
|
|
}
|
|
|
|
std::vector<SolidityParser::YulStatementContext *> SolidityParser::YulBlockContext::yulStatement() {
|
|
return getRuleContexts<SolidityParser::YulStatementContext>();
|
|
}
|
|
|
|
SolidityParser::YulStatementContext* SolidityParser::YulBlockContext::yulStatement(size_t i) {
|
|
return getRuleContext<SolidityParser::YulStatementContext>(i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::YulBlockContext::getRuleIndex() const {
|
|
return SolidityParser::RuleYulBlock;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::YulBlockContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitYulBlock(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::YulBlockContext* SolidityParser::yulBlock() {
|
|
YulBlockContext *_localctx = _tracker.createInstance<YulBlockContext>(_ctx, getState());
|
|
enterRule(_localctx, 138, SolidityParser::RuleYulBlock);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1004);
|
|
match(SolidityParser::YulLBrace);
|
|
setState(1008);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (((((_la - 129) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 129)) & ((1ULL << (SolidityParser::YulBreak - 129))
|
|
| (1ULL << (SolidityParser::YulContinue - 129))
|
|
| (1ULL << (SolidityParser::YulFor - 129))
|
|
| (1ULL << (SolidityParser::YulFunction - 129))
|
|
| (1ULL << (SolidityParser::YulIf - 129))
|
|
| (1ULL << (SolidityParser::YulLeave - 129))
|
|
| (1ULL << (SolidityParser::YulLet - 129))
|
|
| (1ULL << (SolidityParser::YulSwitch - 129))
|
|
| (1ULL << (SolidityParser::YulEVMBuiltin - 129))
|
|
| (1ULL << (SolidityParser::YulLBrace - 129))
|
|
| (1ULL << (SolidityParser::YulIdentifier - 129)))) != 0)) {
|
|
setState(1005);
|
|
yulStatement();
|
|
setState(1010);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
setState(1011);
|
|
match(SolidityParser::YulRBrace);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- YulVariableDeclarationContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::YulVariableDeclarationContext::YulVariableDeclarationContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulVariableDeclarationContext::YulLet() {
|
|
return getToken(SolidityParser::YulLet, 0);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::YulVariableDeclarationContext::YulIdentifier() {
|
|
return getTokens(SolidityParser::YulIdentifier);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulVariableDeclarationContext::YulIdentifier(size_t i) {
|
|
return getToken(SolidityParser::YulIdentifier, i);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulVariableDeclarationContext::YulAssign() {
|
|
return getToken(SolidityParser::YulAssign, 0);
|
|
}
|
|
|
|
SolidityParser::YulExpressionContext* SolidityParser::YulVariableDeclarationContext::yulExpression() {
|
|
return getRuleContext<SolidityParser::YulExpressionContext>(0);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::YulVariableDeclarationContext::YulComma() {
|
|
return getTokens(SolidityParser::YulComma);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulVariableDeclarationContext::YulComma(size_t i) {
|
|
return getToken(SolidityParser::YulComma, i);
|
|
}
|
|
|
|
SolidityParser::YulFunctionCallContext* SolidityParser::YulVariableDeclarationContext::yulFunctionCall() {
|
|
return getRuleContext<SolidityParser::YulFunctionCallContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::YulVariableDeclarationContext::getRuleIndex() const {
|
|
return SolidityParser::RuleYulVariableDeclaration;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::YulVariableDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitYulVariableDeclaration(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::YulVariableDeclarationContext* SolidityParser::yulVariableDeclaration() {
|
|
YulVariableDeclarationContext *_localctx = _tracker.createInstance<YulVariableDeclarationContext>(_ctx, getState());
|
|
enterRule(_localctx, 140, SolidityParser::RuleYulVariableDeclaration);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(1032);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 110, _ctx)) {
|
|
case 1: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1013);
|
|
match(SolidityParser::YulLet);
|
|
setState(1014);
|
|
dynamic_cast<YulVariableDeclarationContext *>(_localctx)->yulidentifierToken = match(SolidityParser::YulIdentifier);
|
|
dynamic_cast<YulVariableDeclarationContext *>(_localctx)->variables.push_back(dynamic_cast<YulVariableDeclarationContext *>(_localctx)->yulidentifierToken);
|
|
setState(1017);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == SolidityParser::YulAssign) {
|
|
setState(1015);
|
|
match(SolidityParser::YulAssign);
|
|
setState(1016);
|
|
yulExpression();
|
|
}
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(1019);
|
|
match(SolidityParser::YulLet);
|
|
setState(1020);
|
|
dynamic_cast<YulVariableDeclarationContext *>(_localctx)->yulidentifierToken = match(SolidityParser::YulIdentifier);
|
|
dynamic_cast<YulVariableDeclarationContext *>(_localctx)->variables.push_back(dynamic_cast<YulVariableDeclarationContext *>(_localctx)->yulidentifierToken);
|
|
setState(1025);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == SolidityParser::YulComma) {
|
|
setState(1021);
|
|
match(SolidityParser::YulComma);
|
|
setState(1022);
|
|
dynamic_cast<YulVariableDeclarationContext *>(_localctx)->yulidentifierToken = match(SolidityParser::YulIdentifier);
|
|
dynamic_cast<YulVariableDeclarationContext *>(_localctx)->variables.push_back(dynamic_cast<YulVariableDeclarationContext *>(_localctx)->yulidentifierToken);
|
|
setState(1027);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
setState(1030);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == SolidityParser::YulAssign) {
|
|
setState(1028);
|
|
match(SolidityParser::YulAssign);
|
|
setState(1029);
|
|
yulFunctionCall();
|
|
}
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- YulAssignmentContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::YulAssignmentContext::YulAssignmentContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<SolidityParser::YulPathContext *> SolidityParser::YulAssignmentContext::yulPath() {
|
|
return getRuleContexts<SolidityParser::YulPathContext>();
|
|
}
|
|
|
|
SolidityParser::YulPathContext* SolidityParser::YulAssignmentContext::yulPath(size_t i) {
|
|
return getRuleContext<SolidityParser::YulPathContext>(i);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulAssignmentContext::YulAssign() {
|
|
return getToken(SolidityParser::YulAssign, 0);
|
|
}
|
|
|
|
SolidityParser::YulExpressionContext* SolidityParser::YulAssignmentContext::yulExpression() {
|
|
return getRuleContext<SolidityParser::YulExpressionContext>(0);
|
|
}
|
|
|
|
SolidityParser::YulFunctionCallContext* SolidityParser::YulAssignmentContext::yulFunctionCall() {
|
|
return getRuleContext<SolidityParser::YulFunctionCallContext>(0);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::YulAssignmentContext::YulComma() {
|
|
return getTokens(SolidityParser::YulComma);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulAssignmentContext::YulComma(size_t i) {
|
|
return getToken(SolidityParser::YulComma, i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::YulAssignmentContext::getRuleIndex() const {
|
|
return SolidityParser::RuleYulAssignment;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::YulAssignmentContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitYulAssignment(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::YulAssignmentContext* SolidityParser::yulAssignment() {
|
|
YulAssignmentContext *_localctx = _tracker.createInstance<YulAssignmentContext>(_ctx, getState());
|
|
enterRule(_localctx, 142, SolidityParser::RuleYulAssignment);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(1048);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 112, _ctx)) {
|
|
case 1: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1034);
|
|
yulPath();
|
|
setState(1035);
|
|
match(SolidityParser::YulAssign);
|
|
setState(1036);
|
|
yulExpression();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(1038);
|
|
yulPath();
|
|
setState(1041);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
do {
|
|
setState(1039);
|
|
match(SolidityParser::YulComma);
|
|
setState(1040);
|
|
yulPath();
|
|
setState(1043);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
} while (_la == SolidityParser::YulComma);
|
|
setState(1045);
|
|
match(SolidityParser::YulAssign);
|
|
setState(1046);
|
|
yulFunctionCall();
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- YulIfStatementContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::YulIfStatementContext::YulIfStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulIfStatementContext::YulIf() {
|
|
return getToken(SolidityParser::YulIf, 0);
|
|
}
|
|
|
|
SolidityParser::YulExpressionContext* SolidityParser::YulIfStatementContext::yulExpression() {
|
|
return getRuleContext<SolidityParser::YulExpressionContext>(0);
|
|
}
|
|
|
|
SolidityParser::YulBlockContext* SolidityParser::YulIfStatementContext::yulBlock() {
|
|
return getRuleContext<SolidityParser::YulBlockContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::YulIfStatementContext::getRuleIndex() const {
|
|
return SolidityParser::RuleYulIfStatement;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::YulIfStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitYulIfStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::YulIfStatementContext* SolidityParser::yulIfStatement() {
|
|
YulIfStatementContext *_localctx = _tracker.createInstance<YulIfStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 144, SolidityParser::RuleYulIfStatement);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1050);
|
|
match(SolidityParser::YulIf);
|
|
setState(1051);
|
|
dynamic_cast<YulIfStatementContext *>(_localctx)->cond = yulExpression();
|
|
setState(1052);
|
|
dynamic_cast<YulIfStatementContext *>(_localctx)->body = yulBlock();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- YulForStatementContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::YulForStatementContext::YulForStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulForStatementContext::YulFor() {
|
|
return getToken(SolidityParser::YulFor, 0);
|
|
}
|
|
|
|
std::vector<SolidityParser::YulBlockContext *> SolidityParser::YulForStatementContext::yulBlock() {
|
|
return getRuleContexts<SolidityParser::YulBlockContext>();
|
|
}
|
|
|
|
SolidityParser::YulBlockContext* SolidityParser::YulForStatementContext::yulBlock(size_t i) {
|
|
return getRuleContext<SolidityParser::YulBlockContext>(i);
|
|
}
|
|
|
|
SolidityParser::YulExpressionContext* SolidityParser::YulForStatementContext::yulExpression() {
|
|
return getRuleContext<SolidityParser::YulExpressionContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::YulForStatementContext::getRuleIndex() const {
|
|
return SolidityParser::RuleYulForStatement;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::YulForStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitYulForStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::YulForStatementContext* SolidityParser::yulForStatement() {
|
|
YulForStatementContext *_localctx = _tracker.createInstance<YulForStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 146, SolidityParser::RuleYulForStatement);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1054);
|
|
match(SolidityParser::YulFor);
|
|
setState(1055);
|
|
dynamic_cast<YulForStatementContext *>(_localctx)->init = yulBlock();
|
|
setState(1056);
|
|
dynamic_cast<YulForStatementContext *>(_localctx)->cond = yulExpression();
|
|
setState(1057);
|
|
dynamic_cast<YulForStatementContext *>(_localctx)->post = yulBlock();
|
|
setState(1058);
|
|
dynamic_cast<YulForStatementContext *>(_localctx)->body = yulBlock();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- YulSwitchCaseContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::YulSwitchCaseContext::YulSwitchCaseContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulSwitchCaseContext::YulCase() {
|
|
return getToken(SolidityParser::YulCase, 0);
|
|
}
|
|
|
|
SolidityParser::YulLiteralContext* SolidityParser::YulSwitchCaseContext::yulLiteral() {
|
|
return getRuleContext<SolidityParser::YulLiteralContext>(0);
|
|
}
|
|
|
|
SolidityParser::YulBlockContext* SolidityParser::YulSwitchCaseContext::yulBlock() {
|
|
return getRuleContext<SolidityParser::YulBlockContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::YulSwitchCaseContext::getRuleIndex() const {
|
|
return SolidityParser::RuleYulSwitchCase;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::YulSwitchCaseContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitYulSwitchCase(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::YulSwitchCaseContext* SolidityParser::yulSwitchCase() {
|
|
YulSwitchCaseContext *_localctx = _tracker.createInstance<YulSwitchCaseContext>(_ctx, getState());
|
|
enterRule(_localctx, 148, SolidityParser::RuleYulSwitchCase);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1060);
|
|
match(SolidityParser::YulCase);
|
|
setState(1061);
|
|
yulLiteral();
|
|
setState(1062);
|
|
yulBlock();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- YulSwitchStatementContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::YulSwitchStatementContext::YulSwitchStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulSwitchStatementContext::YulSwitch() {
|
|
return getToken(SolidityParser::YulSwitch, 0);
|
|
}
|
|
|
|
SolidityParser::YulExpressionContext* SolidityParser::YulSwitchStatementContext::yulExpression() {
|
|
return getRuleContext<SolidityParser::YulExpressionContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulSwitchStatementContext::YulDefault() {
|
|
return getToken(SolidityParser::YulDefault, 0);
|
|
}
|
|
|
|
SolidityParser::YulBlockContext* SolidityParser::YulSwitchStatementContext::yulBlock() {
|
|
return getRuleContext<SolidityParser::YulBlockContext>(0);
|
|
}
|
|
|
|
std::vector<SolidityParser::YulSwitchCaseContext *> SolidityParser::YulSwitchStatementContext::yulSwitchCase() {
|
|
return getRuleContexts<SolidityParser::YulSwitchCaseContext>();
|
|
}
|
|
|
|
SolidityParser::YulSwitchCaseContext* SolidityParser::YulSwitchStatementContext::yulSwitchCase(size_t i) {
|
|
return getRuleContext<SolidityParser::YulSwitchCaseContext>(i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::YulSwitchStatementContext::getRuleIndex() const {
|
|
return SolidityParser::RuleYulSwitchStatement;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::YulSwitchStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitYulSwitchStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::YulSwitchStatementContext* SolidityParser::yulSwitchStatement() {
|
|
YulSwitchStatementContext *_localctx = _tracker.createInstance<YulSwitchStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 150, SolidityParser::RuleYulSwitchStatement);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1064);
|
|
match(SolidityParser::YulSwitch);
|
|
setState(1065);
|
|
yulExpression();
|
|
setState(1077);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case SolidityParser::YulCase: {
|
|
setState(1067);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
do {
|
|
setState(1066);
|
|
yulSwitchCase();
|
|
setState(1069);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
} while (_la == SolidityParser::YulCase);
|
|
setState(1073);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == SolidityParser::YulDefault) {
|
|
setState(1071);
|
|
match(SolidityParser::YulDefault);
|
|
setState(1072);
|
|
yulBlock();
|
|
}
|
|
break;
|
|
}
|
|
|
|
case SolidityParser::YulDefault: {
|
|
setState(1075);
|
|
match(SolidityParser::YulDefault);
|
|
setState(1076);
|
|
yulBlock();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- YulFunctionDefinitionContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::YulFunctionDefinitionContext::YulFunctionDefinitionContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulFunctionDefinitionContext::YulFunction() {
|
|
return getToken(SolidityParser::YulFunction, 0);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::YulFunctionDefinitionContext::YulIdentifier() {
|
|
return getTokens(SolidityParser::YulIdentifier);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulFunctionDefinitionContext::YulIdentifier(size_t i) {
|
|
return getToken(SolidityParser::YulIdentifier, i);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulFunctionDefinitionContext::YulLParen() {
|
|
return getToken(SolidityParser::YulLParen, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulFunctionDefinitionContext::YulRParen() {
|
|
return getToken(SolidityParser::YulRParen, 0);
|
|
}
|
|
|
|
SolidityParser::YulBlockContext* SolidityParser::YulFunctionDefinitionContext::yulBlock() {
|
|
return getRuleContext<SolidityParser::YulBlockContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulFunctionDefinitionContext::YulArrow() {
|
|
return getToken(SolidityParser::YulArrow, 0);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::YulFunctionDefinitionContext::YulComma() {
|
|
return getTokens(SolidityParser::YulComma);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulFunctionDefinitionContext::YulComma(size_t i) {
|
|
return getToken(SolidityParser::YulComma, i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::YulFunctionDefinitionContext::getRuleIndex() const {
|
|
return SolidityParser::RuleYulFunctionDefinition;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::YulFunctionDefinitionContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitYulFunctionDefinition(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::YulFunctionDefinitionContext* SolidityParser::yulFunctionDefinition() {
|
|
YulFunctionDefinitionContext *_localctx = _tracker.createInstance<YulFunctionDefinitionContext>(_ctx, getState());
|
|
enterRule(_localctx, 152, SolidityParser::RuleYulFunctionDefinition);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1079);
|
|
match(SolidityParser::YulFunction);
|
|
setState(1080);
|
|
match(SolidityParser::YulIdentifier);
|
|
setState(1081);
|
|
match(SolidityParser::YulLParen);
|
|
setState(1090);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == SolidityParser::YulIdentifier) {
|
|
setState(1082);
|
|
dynamic_cast<YulFunctionDefinitionContext *>(_localctx)->yulidentifierToken = match(SolidityParser::YulIdentifier);
|
|
dynamic_cast<YulFunctionDefinitionContext *>(_localctx)->arguments.push_back(dynamic_cast<YulFunctionDefinitionContext *>(_localctx)->yulidentifierToken);
|
|
setState(1087);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == SolidityParser::YulComma) {
|
|
setState(1083);
|
|
match(SolidityParser::YulComma);
|
|
setState(1084);
|
|
dynamic_cast<YulFunctionDefinitionContext *>(_localctx)->yulidentifierToken = match(SolidityParser::YulIdentifier);
|
|
dynamic_cast<YulFunctionDefinitionContext *>(_localctx)->arguments.push_back(dynamic_cast<YulFunctionDefinitionContext *>(_localctx)->yulidentifierToken);
|
|
setState(1089);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
}
|
|
setState(1092);
|
|
match(SolidityParser::YulRParen);
|
|
setState(1102);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (_la == SolidityParser::YulArrow) {
|
|
setState(1093);
|
|
match(SolidityParser::YulArrow);
|
|
setState(1094);
|
|
dynamic_cast<YulFunctionDefinitionContext *>(_localctx)->yulidentifierToken = match(SolidityParser::YulIdentifier);
|
|
dynamic_cast<YulFunctionDefinitionContext *>(_localctx)->returnParameters.push_back(dynamic_cast<YulFunctionDefinitionContext *>(_localctx)->yulidentifierToken);
|
|
setState(1099);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == SolidityParser::YulComma) {
|
|
setState(1095);
|
|
match(SolidityParser::YulComma);
|
|
setState(1096);
|
|
dynamic_cast<YulFunctionDefinitionContext *>(_localctx)->yulidentifierToken = match(SolidityParser::YulIdentifier);
|
|
dynamic_cast<YulFunctionDefinitionContext *>(_localctx)->returnParameters.push_back(dynamic_cast<YulFunctionDefinitionContext *>(_localctx)->yulidentifierToken);
|
|
setState(1101);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
}
|
|
setState(1104);
|
|
dynamic_cast<YulFunctionDefinitionContext *>(_localctx)->body = yulBlock();
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- YulPathContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::YulPathContext::YulPathContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::YulPathContext::YulIdentifier() {
|
|
return getTokens(SolidityParser::YulIdentifier);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulPathContext::YulIdentifier(size_t i) {
|
|
return getToken(SolidityParser::YulIdentifier, i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::YulPathContext::YulPeriod() {
|
|
return getTokens(SolidityParser::YulPeriod);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulPathContext::YulPeriod(size_t i) {
|
|
return getToken(SolidityParser::YulPeriod, i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::YulPathContext::getRuleIndex() const {
|
|
return SolidityParser::RuleYulPath;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::YulPathContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitYulPath(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::YulPathContext* SolidityParser::yulPath() {
|
|
YulPathContext *_localctx = _tracker.createInstance<YulPathContext>(_ctx, getState());
|
|
enterRule(_localctx, 154, SolidityParser::RuleYulPath);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1106);
|
|
match(SolidityParser::YulIdentifier);
|
|
setState(1111);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == SolidityParser::YulPeriod) {
|
|
setState(1107);
|
|
match(SolidityParser::YulPeriod);
|
|
setState(1108);
|
|
match(SolidityParser::YulIdentifier);
|
|
setState(1113);
|
|
_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;
|
|
}
|
|
|
|
//----------------- YulFunctionCallContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::YulFunctionCallContext::YulFunctionCallContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulFunctionCallContext::YulLParen() {
|
|
return getToken(SolidityParser::YulLParen, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulFunctionCallContext::YulRParen() {
|
|
return getToken(SolidityParser::YulRParen, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulFunctionCallContext::YulIdentifier() {
|
|
return getToken(SolidityParser::YulIdentifier, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulFunctionCallContext::YulEVMBuiltin() {
|
|
return getToken(SolidityParser::YulEVMBuiltin, 0);
|
|
}
|
|
|
|
std::vector<SolidityParser::YulExpressionContext *> SolidityParser::YulFunctionCallContext::yulExpression() {
|
|
return getRuleContexts<SolidityParser::YulExpressionContext>();
|
|
}
|
|
|
|
SolidityParser::YulExpressionContext* SolidityParser::YulFunctionCallContext::yulExpression(size_t i) {
|
|
return getRuleContext<SolidityParser::YulExpressionContext>(i);
|
|
}
|
|
|
|
std::vector<tree::TerminalNode *> SolidityParser::YulFunctionCallContext::YulComma() {
|
|
return getTokens(SolidityParser::YulComma);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulFunctionCallContext::YulComma(size_t i) {
|
|
return getToken(SolidityParser::YulComma, i);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::YulFunctionCallContext::getRuleIndex() const {
|
|
return SolidityParser::RuleYulFunctionCall;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::YulFunctionCallContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitYulFunctionCall(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::YulFunctionCallContext* SolidityParser::yulFunctionCall() {
|
|
YulFunctionCallContext *_localctx = _tracker.createInstance<YulFunctionCallContext>(_ctx, getState());
|
|
enterRule(_localctx, 156, SolidityParser::RuleYulFunctionCall);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1114);
|
|
_la = _input->LA(1);
|
|
if (!(_la == SolidityParser::YulEVMBuiltin
|
|
|
|
|| _la == SolidityParser::YulIdentifier)) {
|
|
_errHandler->recoverInline(this);
|
|
}
|
|
else {
|
|
_errHandler->reportMatch(this);
|
|
consume();
|
|
}
|
|
setState(1115);
|
|
match(SolidityParser::YulLParen);
|
|
setState(1124);
|
|
_errHandler->sync(this);
|
|
|
|
_la = _input->LA(1);
|
|
if (((((_la - 133) & ~ 0x3fULL) == 0) &&
|
|
((1ULL << (_la - 133)) & ((1ULL << (SolidityParser::YulFalse - 133))
|
|
| (1ULL << (SolidityParser::YulTrue - 133))
|
|
| (1ULL << (SolidityParser::YulEVMBuiltin - 133))
|
|
| (1ULL << (SolidityParser::YulIdentifier - 133))
|
|
| (1ULL << (SolidityParser::YulHexNumber - 133))
|
|
| (1ULL << (SolidityParser::YulDecimalNumber - 133))
|
|
| (1ULL << (SolidityParser::YulStringLiteral - 133)))) != 0)) {
|
|
setState(1116);
|
|
yulExpression();
|
|
setState(1121);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while (_la == SolidityParser::YulComma) {
|
|
setState(1117);
|
|
match(SolidityParser::YulComma);
|
|
setState(1118);
|
|
yulExpression();
|
|
setState(1123);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
}
|
|
setState(1126);
|
|
match(SolidityParser::YulRParen);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- YulboolContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::YulboolContext::YulboolContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulboolContext::YulTrue() {
|
|
return getToken(SolidityParser::YulTrue, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulboolContext::YulFalse() {
|
|
return getToken(SolidityParser::YulFalse, 0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::YulboolContext::getRuleIndex() const {
|
|
return SolidityParser::RuleYulbool;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::YulboolContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitYulBoolean(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::YulboolContext* SolidityParser::yulbool() {
|
|
YulboolContext *_localctx = _tracker.createInstance<YulboolContext>(_ctx, getState());
|
|
enterRule(_localctx, 158, SolidityParser::RuleYulbool);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1128);
|
|
_la = _input->LA(1);
|
|
if (!(_la == SolidityParser::YulFalse
|
|
|
|
|| _la == SolidityParser::YulTrue)) {
|
|
_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;
|
|
}
|
|
|
|
//----------------- YulLiteralContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::YulLiteralContext::YulLiteralContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulLiteralContext::YulDecimalNumber() {
|
|
return getToken(SolidityParser::YulDecimalNumber, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulLiteralContext::YulStringLiteral() {
|
|
return getToken(SolidityParser::YulStringLiteral, 0);
|
|
}
|
|
|
|
tree::TerminalNode* SolidityParser::YulLiteralContext::YulHexNumber() {
|
|
return getToken(SolidityParser::YulHexNumber, 0);
|
|
}
|
|
|
|
SolidityParser::YulboolContext* SolidityParser::YulLiteralContext::yulbool() {
|
|
return getRuleContext<SolidityParser::YulboolContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::YulLiteralContext::getRuleIndex() const {
|
|
return SolidityParser::RuleYulLiteral;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::YulLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitYulLiteral(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::YulLiteralContext* SolidityParser::yulLiteral() {
|
|
YulLiteralContext *_localctx = _tracker.createInstance<YulLiteralContext>(_ctx, getState());
|
|
enterRule(_localctx, 160, SolidityParser::RuleYulLiteral);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(1134);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case SolidityParser::YulDecimalNumber: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1130);
|
|
match(SolidityParser::YulDecimalNumber);
|
|
break;
|
|
}
|
|
|
|
case SolidityParser::YulStringLiteral: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(1131);
|
|
match(SolidityParser::YulStringLiteral);
|
|
break;
|
|
}
|
|
|
|
case SolidityParser::YulHexNumber: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(1132);
|
|
match(SolidityParser::YulHexNumber);
|
|
break;
|
|
}
|
|
|
|
case SolidityParser::YulFalse:
|
|
case SolidityParser::YulTrue: {
|
|
enterOuterAlt(_localctx, 4);
|
|
setState(1133);
|
|
yulbool();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- YulExpressionContext ------------------------------------------------------------------
|
|
|
|
SolidityParser::YulExpressionContext::YulExpressionContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
SolidityParser::YulPathContext* SolidityParser::YulExpressionContext::yulPath() {
|
|
return getRuleContext<SolidityParser::YulPathContext>(0);
|
|
}
|
|
|
|
SolidityParser::YulFunctionCallContext* SolidityParser::YulExpressionContext::yulFunctionCall() {
|
|
return getRuleContext<SolidityParser::YulFunctionCallContext>(0);
|
|
}
|
|
|
|
SolidityParser::YulLiteralContext* SolidityParser::YulExpressionContext::yulLiteral() {
|
|
return getRuleContext<SolidityParser::YulLiteralContext>(0);
|
|
}
|
|
|
|
|
|
size_t SolidityParser::YulExpressionContext::getRuleIndex() const {
|
|
return SolidityParser::RuleYulExpression;
|
|
}
|
|
|
|
|
|
antlrcpp::Any SolidityParser::YulExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<SolidityVisitor*>(visitor))
|
|
return parserVisitor->visitYulExpression(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
SolidityParser::YulExpressionContext* SolidityParser::yulExpression() {
|
|
YulExpressionContext *_localctx = _tracker.createInstance<YulExpressionContext>(_ctx, getState());
|
|
enterRule(_localctx, 162, SolidityParser::RuleYulExpression);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(1139);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 124, _ctx)) {
|
|
case 1: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(1136);
|
|
yulPath();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(1137);
|
|
yulFunctionCall();
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(1138);
|
|
yulLiteral();
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
bool SolidityParser::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) {
|
|
switch (ruleIndex) {
|
|
case 19: return constructorDefinitionSempred(dynamic_cast<ConstructorDefinitionContext *>(context), predicateIndex);
|
|
case 22: return functionDefinitionSempred(dynamic_cast<FunctionDefinitionContext *>(context), predicateIndex);
|
|
case 23: return modifierDefinitionSempred(dynamic_cast<ModifierDefinitionContext *>(context), predicateIndex);
|
|
case 24: return fallbackReceiveFunctionDefinitionSempred(dynamic_cast<FallbackReceiveFunctionDefinitionContext *>(context), predicateIndex);
|
|
case 28: return stateVariableDeclarationSempred(dynamic_cast<StateVariableDeclarationContext *>(context), predicateIndex);
|
|
case 32: return typeNameSempred(dynamic_cast<TypeNameContext *>(context), predicateIndex);
|
|
case 33: return elementaryTypeNameSempred(dynamic_cast<ElementaryTypeNameContext *>(context), predicateIndex);
|
|
case 34: return functionTypeNameSempred(dynamic_cast<FunctionTypeNameContext *>(context), predicateIndex);
|
|
case 37: return expressionSempred(dynamic_cast<ExpressionContext *>(context), predicateIndex);
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool SolidityParser::constructorDefinitionSempred(ConstructorDefinitionContext *_localctx, size_t predicateIndex) {
|
|
switch (predicateIndex) {
|
|
case 0: return !_localctx->payableSet;
|
|
case 1: return !_localctx->visibilitySet;
|
|
case 2: return !_localctx->visibilitySet;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool SolidityParser::functionDefinitionSempred(FunctionDefinitionContext *_localctx, size_t predicateIndex) {
|
|
switch (predicateIndex) {
|
|
case 3: return !_localctx->visibilitySet;
|
|
case 4: return !_localctx->mutabilitySet;
|
|
case 5: return !_localctx->virtualSet;
|
|
case 6: return !_localctx->overrideSpecifierSet;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool SolidityParser::modifierDefinitionSempred(ModifierDefinitionContext *_localctx, size_t predicateIndex) {
|
|
switch (predicateIndex) {
|
|
case 7: return !_localctx->virtualSet;
|
|
case 8: return !_localctx->overrideSpecifierSet;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool SolidityParser::fallbackReceiveFunctionDefinitionSempred(FallbackReceiveFunctionDefinitionContext *_localctx, size_t predicateIndex) {
|
|
switch (predicateIndex) {
|
|
case 9: return !_localctx->visibilitySet;
|
|
case 10: return !_localctx->mutabilitySet;
|
|
case 11: return !_localctx->virtualSet;
|
|
case 12: return !_localctx->overrideSpecifierSet;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool SolidityParser::stateVariableDeclarationSempred(StateVariableDeclarationContext *_localctx, size_t predicateIndex) {
|
|
switch (predicateIndex) {
|
|
case 13: return !_localctx->visibilitySet;
|
|
case 14: return !_localctx->visibilitySet;
|
|
case 15: return !_localctx->visibilitySet;
|
|
case 16: return !_localctx->constantnessSet;
|
|
case 17: return !_localctx->overrideSpecifierSet;
|
|
case 18: return !_localctx->constantnessSet;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool SolidityParser::typeNameSempred(TypeNameContext *, size_t predicateIndex) {
|
|
switch (predicateIndex) {
|
|
case 19: return precpred(_ctx, 1);
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool SolidityParser::elementaryTypeNameSempred(ElementaryTypeNameContext *_localctx, size_t predicateIndex) {
|
|
switch (predicateIndex) {
|
|
case 20: return _localctx->allowAddressPayable;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool SolidityParser::functionTypeNameSempred(FunctionTypeNameContext *_localctx, size_t predicateIndex) {
|
|
switch (predicateIndex) {
|
|
case 21: return !_localctx->visibilitySet;
|
|
case 22: return !_localctx->mutabilitySet;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool SolidityParser::expressionSempred(ExpressionContext *, size_t predicateIndex) {
|
|
switch (predicateIndex) {
|
|
case 23: return precpred(_ctx, 17);
|
|
case 24: return precpred(_ctx, 16);
|
|
case 25: return precpred(_ctx, 15);
|
|
case 26: return precpred(_ctx, 14);
|
|
case 27: return precpred(_ctx, 13);
|
|
case 28: return precpred(_ctx, 12);
|
|
case 29: return precpred(_ctx, 11);
|
|
case 30: return precpred(_ctx, 10);
|
|
case 31: return precpred(_ctx, 9);
|
|
case 32: return precpred(_ctx, 8);
|
|
case 33: return precpred(_ctx, 7);
|
|
case 34: return precpred(_ctx, 6);
|
|
case 35: return precpred(_ctx, 5);
|
|
case 36: return precpred(_ctx, 26);
|
|
case 37: return precpred(_ctx, 25);
|
|
case 38: return precpred(_ctx, 24);
|
|
case 39: return precpred(_ctx, 23);
|
|
case 40: return precpred(_ctx, 22);
|
|
case 41: return precpred(_ctx, 18);
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Static vars and initialization.
|
|
std::vector<dfa::DFA> SolidityParser::_decisionToDFA;
|
|
atn::PredictionContextCache SolidityParser::_sharedContextCache;
|
|
|
|
// We own the ATN which in turn owns the ATN states.
|
|
atn::ATN SolidityParser::_atn;
|
|
std::vector<uint16_t> SolidityParser::_serializedATN;
|
|
|
|
std::vector<std::string> SolidityParser::_ruleNames = {
|
|
"sourceUnit", "pragmaDirective", "importDirective", "importAliases", "path",
|
|
"symbolAliases", "contractDefinition", "interfaceDefinition", "libraryDefinition",
|
|
"inheritanceSpecifierList", "inheritanceSpecifier", "contractBodyElement",
|
|
"namedArgument", "callArgumentList", "userDefinedTypeName", "modifierInvocation",
|
|
"visibility", "parameterList", "parameterDeclaration", "constructorDefinition",
|
|
"stateMutability", "overrideSpecifier", "functionDefinition", "modifierDefinition",
|
|
"fallbackReceiveFunctionDefinition", "structDefinition", "structMember",
|
|
"enumDefinition", "stateVariableDeclaration", "eventParameter", "eventDefinition",
|
|
"usingDirective", "typeName", "elementaryTypeName", "functionTypeName",
|
|
"variableDeclaration", "dataLocation", "expression", "assignOp", "tupleExpression",
|
|
"inlineArrayExpression", "identifier", "literal", "boolLiteral", "stringLiteral",
|
|
"hexStringLiteral", "unicodeStringLiteral", "numberLiteral", "block",
|
|
"statement", "simpleStatement", "ifStatement", "forStatement", "whileStatement",
|
|
"doWhileStatement", "continueStatement", "breakStatement", "tryStatement",
|
|
"catchClause", "returnStatement", "emitStatement", "assemblyStatement",
|
|
"variableDeclarationList", "variableDeclarationTuple", "variableDeclarationStatement",
|
|
"expressionStatement", "mappingType", "mappingKeyType", "yulStatement",
|
|
"yulBlock", "yulVariableDeclaration", "yulAssignment", "yulIfStatement",
|
|
"yulForStatement", "yulSwitchCase", "yulSwitchStatement", "yulFunctionDefinition",
|
|
"yulPath", "yulFunctionCall", "yulbool", "yulLiteral", "yulExpression"
|
|
};
|
|
|
|
std::vector<std::string> SolidityParser::_literalNames = {
|
|
"", "", "'pragma'", "'abstract'", "'anonymous'", "'address'", "'as'",
|
|
"'assembly'", "'bool'", "", "'bytes'", "'calldata'", "'catch'", "'constant'",
|
|
"'constructor'", "", "'contract'", "'delete'", "'do'", "'else'", "'emit'",
|
|
"'enum'", "'event'", "'external'", "'fallback'", "", "", "'from'", "",
|
|
"", "", "'hex'", "", "'immutable'", "'import'", "'indexed'", "'interface'",
|
|
"'internal'", "'is'", "'library'", "'mapping'", "'memory'", "'modifier'",
|
|
"'new'", "", "'override'", "'payable'", "'private'", "'public'", "'pure'",
|
|
"'receive'", "'return'", "'returns'", "", "'storage'", "'string'", "'struct'",
|
|
"", "'try'", "'type'", "", "", "'using'", "'view'", "'virtual'", "'while'",
|
|
"", "", "'['", "']'", "", "", "':'", "", "", "'?'", "'=>'", "'='", "'|='",
|
|
"'^='", "'&='", "'<<='", "'>>='", "'>>>='", "'+='", "'-='", "'*='", "'/='",
|
|
"'%='", "", "'||'", "'&&'", "'|'", "'^'", "'&'", "'<<'", "'>>'", "'>>>'",
|
|
"'+'", "'-'", "'*'", "'/'", "'%'", "'**'", "'=='", "'!='", "'<'", "'>'",
|
|
"'<='", "'>='", "'!'", "'~'", "'++'", "'--'", "", "", "", "", "", "",
|
|
"", "", "", "", "'\"evmasm\"'", "", "", "", "", "", "'case'", "", "'default'",
|
|
"", "", "", "", "'leave'", "'let'", "'switch'", "", "", "", "", "", "",
|
|
"':='"
|
|
};
|
|
|
|
std::vector<std::string> SolidityParser::_symbolicNames = {
|
|
"", "ReservedKeywords", "Pragma", "Abstract", "Anonymous", "Address",
|
|
"As", "Assembly", "Bool", "Break", "Bytes", "Calldata", "Catch", "Constant",
|
|
"Constructor", "Continue", "Contract", "Delete", "Do", "Else", "Emit",
|
|
"Enum", "Event", "External", "Fallback", "False", "Fixed", "From", "FixedBytes",
|
|
"For", "Function", "Hex", "If", "Immutable", "Import", "Indexed", "Interface",
|
|
"Internal", "Is", "Library", "Mapping", "Memory", "Modifier", "New", "NumberUnit",
|
|
"Override", "Payable", "Private", "Public", "Pure", "Receive", "Return",
|
|
"Returns", "SignedIntegerType", "Storage", "String", "Struct", "True",
|
|
"Try", "Type", "Ufixed", "UnsignedIntegerType", "Using", "View", "Virtual",
|
|
"While", "LParen", "RParen", "LBrack", "RBrack", "LBrace", "RBrace", "Colon",
|
|
"Semicolon", "Period", "Conditional", "Arrow", "Assign", "AssignBitOr",
|
|
"AssignBitXor", "AssignBitAnd", "AssignShl", "AssignSar", "AssignShr",
|
|
"AssignAdd", "AssignSub", "AssignMul", "AssignDiv", "AssignMod", "Comma",
|
|
"Or", "And", "BitOr", "BitXor", "BitAnd", "Shl", "Sar", "Shr", "Add",
|
|
"Sub", "Mul", "Div", "Mod", "Exp", "Equal", "NotEqual", "LessThan", "GreaterThan",
|
|
"LessThanOrEqual", "GreaterThanOrEqual", "Not", "BitNot", "Inc", "Dec",
|
|
"StringLiteral", "NonEmptyStringLiteral", "UnicodeStringLiteral", "HexString",
|
|
"HexNumber", "DecimalNumber", "Identifier", "WS", "COMMENT", "LINE_COMMENT",
|
|
"AssemblyDialect", "AssemblyLBrace", "AssemblyBlockWS", "AssemblyBlockCOMMENT",
|
|
"AssemblyBlockLINE_COMMENT", "YulBreak", "YulCase", "YulContinue", "YulDefault",
|
|
"YulFalse", "YulFor", "YulFunction", "YulIf", "YulLeave", "YulLet", "YulSwitch",
|
|
"YulTrue", "YulEVMBuiltin", "YulLBrace", "YulRBrace", "YulLParen", "YulRParen",
|
|
"YulAssign", "YulPeriod", "YulComma", "YulArrow", "YulIdentifier", "YulHexNumber",
|
|
"YulDecimalNumber", "YulStringLiteral", "YulWS", "YulCOMMENT", "YulLINE_COMMENT",
|
|
"PragmaToken", "PragmaSemicolon", "PragmaWS", "PragmaCOMMENT", "PragmaLINE_COMMENT"
|
|
};
|
|
|
|
dfa::Vocabulary SolidityParser::_vocabulary(_literalNames, _symbolicNames);
|
|
|
|
std::vector<std::string> SolidityParser::_tokenNames;
|
|
|
|
SolidityParser::Initializer::Initializer() {
|
|
for (size_t i = 0; i < _symbolicNames.size(); ++i) {
|
|
std::string name = _vocabulary.getLiteralName(i);
|
|
if (name.empty()) {
|
|
name = _vocabulary.getSymbolicName(i);
|
|
}
|
|
|
|
if (name.empty()) {
|
|
_tokenNames.push_back("<INVALID>");
|
|
} else {
|
|
_tokenNames.push_back(name);
|
|
}
|
|
}
|
|
|
|
_serializedATN = {
|
|
0x3, 0x608b, 0xa72a, 0x8133, 0xb9ed, 0x417c, 0x3be7, 0x7786, 0x5964,
|
|
0x3, 0xa3, 0x478, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x4, 0x4,
|
|
0x9, 0x4, 0x4, 0x5, 0x9, 0x5, 0x4, 0x6, 0x9, 0x6, 0x4, 0x7, 0x9, 0x7,
|
|
0x4, 0x8, 0x9, 0x8, 0x4, 0x9, 0x9, 0x9, 0x4, 0xa, 0x9, 0xa, 0x4, 0xb,
|
|
0x9, 0xb, 0x4, 0xc, 0x9, 0xc, 0x4, 0xd, 0x9, 0xd, 0x4, 0xe, 0x9, 0xe,
|
|
0x4, 0xf, 0x9, 0xf, 0x4, 0x10, 0x9, 0x10, 0x4, 0x11, 0x9, 0x11, 0x4,
|
|
0x12, 0x9, 0x12, 0x4, 0x13, 0x9, 0x13, 0x4, 0x14, 0x9, 0x14, 0x4, 0x15,
|
|
0x9, 0x15, 0x4, 0x16, 0x9, 0x16, 0x4, 0x17, 0x9, 0x17, 0x4, 0x18, 0x9,
|
|
0x18, 0x4, 0x19, 0x9, 0x19, 0x4, 0x1a, 0x9, 0x1a, 0x4, 0x1b, 0x9, 0x1b,
|
|
0x4, 0x1c, 0x9, 0x1c, 0x4, 0x1d, 0x9, 0x1d, 0x4, 0x1e, 0x9, 0x1e, 0x4,
|
|
0x1f, 0x9, 0x1f, 0x4, 0x20, 0x9, 0x20, 0x4, 0x21, 0x9, 0x21, 0x4, 0x22,
|
|
0x9, 0x22, 0x4, 0x23, 0x9, 0x23, 0x4, 0x24, 0x9, 0x24, 0x4, 0x25, 0x9,
|
|
0x25, 0x4, 0x26, 0x9, 0x26, 0x4, 0x27, 0x9, 0x27, 0x4, 0x28, 0x9, 0x28,
|
|
0x4, 0x29, 0x9, 0x29, 0x4, 0x2a, 0x9, 0x2a, 0x4, 0x2b, 0x9, 0x2b, 0x4,
|
|
0x2c, 0x9, 0x2c, 0x4, 0x2d, 0x9, 0x2d, 0x4, 0x2e, 0x9, 0x2e, 0x4, 0x2f,
|
|
0x9, 0x2f, 0x4, 0x30, 0x9, 0x30, 0x4, 0x31, 0x9, 0x31, 0x4, 0x32, 0x9,
|
|
0x32, 0x4, 0x33, 0x9, 0x33, 0x4, 0x34, 0x9, 0x34, 0x4, 0x35, 0x9, 0x35,
|
|
0x4, 0x36, 0x9, 0x36, 0x4, 0x37, 0x9, 0x37, 0x4, 0x38, 0x9, 0x38, 0x4,
|
|
0x39, 0x9, 0x39, 0x4, 0x3a, 0x9, 0x3a, 0x4, 0x3b, 0x9, 0x3b, 0x4, 0x3c,
|
|
0x9, 0x3c, 0x4, 0x3d, 0x9, 0x3d, 0x4, 0x3e, 0x9, 0x3e, 0x4, 0x3f, 0x9,
|
|
0x3f, 0x4, 0x40, 0x9, 0x40, 0x4, 0x41, 0x9, 0x41, 0x4, 0x42, 0x9, 0x42,
|
|
0x4, 0x43, 0x9, 0x43, 0x4, 0x44, 0x9, 0x44, 0x4, 0x45, 0x9, 0x45, 0x4,
|
|
0x46, 0x9, 0x46, 0x4, 0x47, 0x9, 0x47, 0x4, 0x48, 0x9, 0x48, 0x4, 0x49,
|
|
0x9, 0x49, 0x4, 0x4a, 0x9, 0x4a, 0x4, 0x4b, 0x9, 0x4b, 0x4, 0x4c, 0x9,
|
|
0x4c, 0x4, 0x4d, 0x9, 0x4d, 0x4, 0x4e, 0x9, 0x4e, 0x4, 0x4f, 0x9, 0x4f,
|
|
0x4, 0x50, 0x9, 0x50, 0x4, 0x51, 0x9, 0x51, 0x4, 0x52, 0x9, 0x52, 0x4,
|
|
0x53, 0x9, 0x53, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3,
|
|
0x2, 0x3, 0x2, 0x3, 0x2, 0x7, 0x2, 0xaf, 0xa, 0x2, 0xc, 0x2, 0xe, 0x2,
|
|
0xb2, 0xb, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x3, 0x3, 0x3, 0x6, 0x3, 0xb8,
|
|
0xa, 0x3, 0xd, 0x3, 0xe, 0x3, 0xb9, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3,
|
|
0x4, 0x3, 0x4, 0x3, 0x4, 0x5, 0x4, 0xc2, 0xa, 0x4, 0x3, 0x4, 0x3, 0x4,
|
|
0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4,
|
|
0x3, 0x4, 0x5, 0x4, 0xce, 0xa, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x5, 0x3,
|
|
0x5, 0x3, 0x5, 0x5, 0x5, 0xd5, 0xa, 0x5, 0x3, 0x6, 0x3, 0x6, 0x3, 0x7,
|
|
0x3, 0x7, 0x3, 0x7, 0x3, 0x7, 0x7, 0x7, 0xdd, 0xa, 0x7, 0xc, 0x7, 0xe,
|
|
0x7, 0xe0, 0xb, 0x7, 0x3, 0x7, 0x3, 0x7, 0x3, 0x8, 0x5, 0x8, 0xe5, 0xa,
|
|
0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x5, 0x8, 0xea, 0xa, 0x8, 0x3, 0x8,
|
|
0x3, 0x8, 0x7, 0x8, 0xee, 0xa, 0x8, 0xc, 0x8, 0xe, 0x8, 0xf1, 0xb, 0x8,
|
|
0x3, 0x8, 0x3, 0x8, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x5, 0x9, 0xf8, 0xa,
|
|
0x9, 0x3, 0x9, 0x3, 0x9, 0x7, 0x9, 0xfc, 0xa, 0x9, 0xc, 0x9, 0xe, 0x9,
|
|
0xff, 0xb, 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3,
|
|
0xa, 0x7, 0xa, 0x107, 0xa, 0xa, 0xc, 0xa, 0xe, 0xa, 0x10a, 0xb, 0xa,
|
|
0x3, 0xa, 0x3, 0xa, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x7, 0xb,
|
|
0x112, 0xa, 0xb, 0xc, 0xb, 0xe, 0xb, 0x115, 0xb, 0xb, 0x3, 0xc, 0x3,
|
|
0xc, 0x5, 0xc, 0x119, 0xa, 0xc, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd,
|
|
0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x5, 0xd, 0x124, 0xa,
|
|
0xd, 0x3, 0xe, 0x3, 0xe, 0x3, 0xe, 0x3, 0xe, 0x3, 0xf, 0x3, 0xf, 0x3,
|
|
0xf, 0x3, 0xf, 0x7, 0xf, 0x12e, 0xa, 0xf, 0xc, 0xf, 0xe, 0xf, 0x131,
|
|
0xb, 0xf, 0x5, 0xf, 0x133, 0xa, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3,
|
|
0xf, 0x7, 0xf, 0x139, 0xa, 0xf, 0xc, 0xf, 0xe, 0xf, 0x13c, 0xb, 0xf,
|
|
0x5, 0xf, 0x13e, 0xa, 0xf, 0x3, 0xf, 0x5, 0xf, 0x141, 0xa, 0xf, 0x3,
|
|
0xf, 0x3, 0xf, 0x3, 0x10, 0x3, 0x10, 0x3, 0x10, 0x7, 0x10, 0x148, 0xa,
|
|
0x10, 0xc, 0x10, 0xe, 0x10, 0x14b, 0xb, 0x10, 0x3, 0x11, 0x3, 0x11,
|
|
0x5, 0x11, 0x14f, 0xa, 0x11, 0x3, 0x12, 0x3, 0x12, 0x3, 0x13, 0x3, 0x13,
|
|
0x3, 0x13, 0x7, 0x13, 0x156, 0xa, 0x13, 0xc, 0x13, 0xe, 0x13, 0x159,
|
|
0xb, 0x13, 0x3, 0x14, 0x3, 0x14, 0x5, 0x14, 0x15d, 0xa, 0x14, 0x3, 0x14,
|
|
0x5, 0x14, 0x160, 0xa, 0x14, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x5, 0x15,
|
|
0x165, 0xa, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15,
|
|
0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x7,
|
|
0x15, 0x172, 0xa, 0x15, 0xc, 0x15, 0xe, 0x15, 0x175, 0xb, 0x15, 0x3,
|
|
0x15, 0x3, 0x15, 0x3, 0x16, 0x3, 0x16, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17,
|
|
0x3, 0x17, 0x3, 0x17, 0x7, 0x17, 0x180, 0xa, 0x17, 0xc, 0x17, 0xe, 0x17,
|
|
0x183, 0xb, 0x17, 0x3, 0x17, 0x3, 0x17, 0x5, 0x17, 0x187, 0xa, 0x17,
|
|
0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x5, 0x18, 0x18d, 0xa, 0x18,
|
|
0x3, 0x18, 0x3, 0x18, 0x5, 0x18, 0x191, 0xa, 0x18, 0x3, 0x18, 0x3, 0x18,
|
|
0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3,
|
|
0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18,
|
|
0x3, 0x18, 0x3, 0x18, 0x7, 0x18, 0x1a4, 0xa, 0x18, 0xc, 0x18, 0xe, 0x18,
|
|
0x1a7, 0xb, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18,
|
|
0x5, 0x18, 0x1ae, 0xa, 0x18, 0x3, 0x18, 0x3, 0x18, 0x5, 0x18, 0x1b2,
|
|
0xa, 0x18, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x5, 0x19, 0x1b8,
|
|
0xa, 0x19, 0x3, 0x19, 0x5, 0x19, 0x1bb, 0xa, 0x19, 0x3, 0x19, 0x3, 0x19,
|
|
0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x7, 0x19, 0x1c4,
|
|
0xa, 0x19, 0xc, 0x19, 0xe, 0x19, 0x1c7, 0xb, 0x19, 0x3, 0x19, 0x3, 0x19,
|
|
0x5, 0x19, 0x1cb, 0xa, 0x19, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a,
|
|
0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3,
|
|
0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a,
|
|
0x3, 0x1a, 0x3, 0x1a, 0x7, 0x1a, 0x1e0, 0xa, 0x1a, 0xc, 0x1a, 0xe, 0x1a,
|
|
0x1e3, 0xb, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x5, 0x1a, 0x1e7, 0xa, 0x1a,
|
|
0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x6, 0x1b, 0x1ed, 0xa, 0x1b,
|
|
0xd, 0x1b, 0xe, 0x1b, 0x1ee, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1c, 0x3, 0x1c,
|
|
0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3,
|
|
0x1d, 0x3, 0x1d, 0x7, 0x1d, 0x1fd, 0xa, 0x1d, 0xc, 0x1d, 0xe, 0x1d,
|
|
0x200, 0xb, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e,
|
|
0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x3,
|
|
0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e,
|
|
0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x7, 0x1e, 0x218, 0xa, 0x1e,
|
|
0xc, 0x1e, 0xe, 0x1e, 0x21b, 0xb, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e,
|
|
0x5, 0x1e, 0x220, 0xa, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1f, 0x3, 0x1f,
|
|
0x5, 0x1f, 0x226, 0xa, 0x1f, 0x3, 0x1f, 0x5, 0x1f, 0x229, 0xa, 0x1f,
|
|
0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x7,
|
|
0x20, 0x231, 0xa, 0x20, 0xc, 0x20, 0xe, 0x20, 0x234, 0xb, 0x20, 0x5,
|
|
0x20, 0x236, 0xa, 0x20, 0x3, 0x20, 0x3, 0x20, 0x5, 0x20, 0x23a, 0xa,
|
|
0x20, 0x3, 0x20, 0x3, 0x20, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21,
|
|
0x3, 0x21, 0x5, 0x21, 0x243, 0xa, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x22,
|
|
0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 0x5, 0x22, 0x24c, 0xa, 0x22,
|
|
0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 0x5, 0x22, 0x251, 0xa, 0x22, 0x3, 0x22,
|
|
0x7, 0x22, 0x254, 0xa, 0x22, 0xc, 0x22, 0xe, 0x22, 0x257, 0xb, 0x22,
|
|
0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3,
|
|
0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, 0x5, 0x23,
|
|
0x265, 0xa, 0x23, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x5, 0x24, 0x26a,
|
|
0xa, 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x3,
|
|
0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x7, 0x24, 0x275, 0xa, 0x24,
|
|
0xc, 0x24, 0xe, 0x24, 0x278, 0xb, 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24,
|
|
0x3, 0x24, 0x3, 0x24, 0x5, 0x24, 0x27f, 0xa, 0x24, 0x3, 0x25, 0x3, 0x25,
|
|
0x5, 0x25, 0x283, 0xa, 0x25, 0x3, 0x25, 0x3, 0x25, 0x3, 0x26, 0x3, 0x26,
|
|
0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3,
|
|
0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27,
|
|
0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x5, 0x27, 0x29b,
|
|
0xa, 0x27, 0x5, 0x27, 0x29d, 0xa, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27,
|
|
0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3,
|
|
0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27,
|
|
0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3,
|
|
0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27,
|
|
0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3,
|
|
0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27,
|
|
0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x5, 0x27, 0x2cd, 0xa, 0x27,
|
|
0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x5, 0x27, 0x2d3, 0xa, 0x27,
|
|
0x3, 0x27, 0x3, 0x27, 0x5, 0x27, 0x2d7, 0xa, 0x27, 0x3, 0x27, 0x3, 0x27,
|
|
0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x5, 0x27, 0x2de, 0xa, 0x27, 0x3, 0x27,
|
|
0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x7, 0x27, 0x2e5, 0xa, 0x27,
|
|
0xc, 0x27, 0xe, 0x27, 0x2e8, 0xb, 0x27, 0x5, 0x27, 0x2ea, 0xa, 0x27,
|
|
0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x3, 0x27, 0x7, 0x27, 0x2f1,
|
|
0xa, 0x27, 0xc, 0x27, 0xe, 0x27, 0x2f4, 0xb, 0x27, 0x3, 0x28, 0x3, 0x28,
|
|
0x3, 0x29, 0x3, 0x29, 0x5, 0x29, 0x2fa, 0xa, 0x29, 0x3, 0x29, 0x3, 0x29,
|
|
0x5, 0x29, 0x2fe, 0xa, 0x29, 0x7, 0x29, 0x300, 0xa, 0x29, 0xc, 0x29,
|
|
0xe, 0x29, 0x303, 0xb, 0x29, 0x3, 0x29, 0x3, 0x29, 0x3, 0x2a, 0x3, 0x2a,
|
|
0x3, 0x2a, 0x3, 0x2a, 0x7, 0x2a, 0x30b, 0xa, 0x2a, 0xc, 0x2a, 0xe, 0x2a,
|
|
0x30e, 0xb, 0x2a, 0x3, 0x2a, 0x3, 0x2a, 0x3, 0x2b, 0x3, 0x2b, 0x3, 0x2c,
|
|
0x3, 0x2c, 0x3, 0x2c, 0x3, 0x2c, 0x3, 0x2c, 0x5, 0x2c, 0x319, 0xa, 0x2c,
|
|
0x3, 0x2d, 0x3, 0x2d, 0x3, 0x2e, 0x6, 0x2e, 0x31e, 0xa, 0x2e, 0xd, 0x2e,
|
|
0xe, 0x2e, 0x31f, 0x3, 0x2f, 0x6, 0x2f, 0x323, 0xa, 0x2f, 0xd, 0x2f,
|
|
0xe, 0x2f, 0x324, 0x3, 0x30, 0x6, 0x30, 0x328, 0xa, 0x30, 0xd, 0x30,
|
|
0xe, 0x30, 0x329, 0x3, 0x31, 0x3, 0x31, 0x5, 0x31, 0x32e, 0xa, 0x31,
|
|
0x3, 0x32, 0x3, 0x32, 0x7, 0x32, 0x332, 0xa, 0x32, 0xc, 0x32, 0xe, 0x32,
|
|
0x335, 0xb, 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x33, 0x3, 0x33, 0x3, 0x33,
|
|
0x3, 0x33, 0x3, 0x33, 0x3, 0x33, 0x3, 0x33, 0x3, 0x33, 0x3, 0x33, 0x3,
|
|
0x33, 0x3, 0x33, 0x3, 0x33, 0x5, 0x33, 0x345, 0xa, 0x33, 0x3, 0x34,
|
|
0x3, 0x34, 0x5, 0x34, 0x349, 0xa, 0x34, 0x3, 0x35, 0x3, 0x35, 0x3, 0x35,
|
|
0x3, 0x35, 0x3, 0x35, 0x3, 0x35, 0x3, 0x35, 0x5, 0x35, 0x352, 0xa, 0x35,
|
|
0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x5, 0x36, 0x358, 0xa, 0x36,
|
|
0x3, 0x36, 0x3, 0x36, 0x5, 0x36, 0x35c, 0xa, 0x36, 0x3, 0x36, 0x5, 0x36,
|
|
0x35f, 0xa, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x36, 0x3, 0x37, 0x3, 0x37,
|
|
0x3, 0x37, 0x3, 0x37, 0x3, 0x37, 0x3, 0x37, 0x3, 0x38, 0x3, 0x38, 0x3,
|
|
0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x38, 0x3, 0x39,
|
|
0x3, 0x39, 0x3, 0x39, 0x3, 0x3a, 0x3, 0x3a, 0x3, 0x3a, 0x3, 0x3b, 0x3,
|
|
0x3b, 0x3, 0x3b, 0x3, 0x3b, 0x3, 0x3b, 0x3, 0x3b, 0x3, 0x3b, 0x5, 0x3b,
|
|
0x37f, 0xa, 0x3b, 0x3, 0x3b, 0x3, 0x3b, 0x6, 0x3b, 0x383, 0xa, 0x3b,
|
|
0xd, 0x3b, 0xe, 0x3b, 0x384, 0x3, 0x3c, 0x3, 0x3c, 0x5, 0x3c, 0x389,
|
|
0xa, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x5, 0x3c, 0x38f,
|
|
0xa, 0x3c, 0x3, 0x3c, 0x3, 0x3c, 0x3, 0x3d, 0x3, 0x3d, 0x5, 0x3d, 0x395,
|
|
0xa, 0x3d, 0x3, 0x3d, 0x3, 0x3d, 0x3, 0x3e, 0x3, 0x3e, 0x3, 0x3e, 0x3,
|
|
0x3e, 0x3, 0x3e, 0x3, 0x3f, 0x3, 0x3f, 0x5, 0x3f, 0x3a0, 0xa, 0x3f,
|
|
0x3, 0x3f, 0x3, 0x3f, 0x7, 0x3f, 0x3a4, 0xa, 0x3f, 0xc, 0x3f, 0xe, 0x3f,
|
|
0x3a7, 0xb, 0x3f, 0x3, 0x3f, 0x3, 0x3f, 0x3, 0x40, 0x3, 0x40, 0x3, 0x40,
|
|
0x7, 0x40, 0x3ae, 0xa, 0x40, 0xc, 0x40, 0xe, 0x40, 0x3b1, 0xb, 0x40,
|
|
0x3, 0x41, 0x3, 0x41, 0x7, 0x41, 0x3b5, 0xa, 0x41, 0xc, 0x41, 0xe, 0x41,
|
|
0x3b8, 0xb, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x41, 0x5, 0x41,
|
|
0x3be, 0xa, 0x41, 0x7, 0x41, 0x3c0, 0xa, 0x41, 0xc, 0x41, 0xe, 0x41,
|
|
0x3c3, 0xb, 0x41, 0x3, 0x41, 0x3, 0x41, 0x3, 0x42, 0x3, 0x42, 0x3, 0x42,
|
|
0x5, 0x42, 0x3ca, 0xa, 0x42, 0x3, 0x42, 0x3, 0x42, 0x3, 0x42, 0x3, 0x42,
|
|
0x5, 0x42, 0x3d0, 0xa, 0x42, 0x3, 0x42, 0x3, 0x42, 0x3, 0x43, 0x3, 0x43,
|
|
0x3, 0x43, 0x3, 0x44, 0x3, 0x44, 0x3, 0x44, 0x3, 0x44, 0x3, 0x44, 0x3,
|
|
0x44, 0x3, 0x44, 0x3, 0x45, 0x3, 0x45, 0x5, 0x45, 0x3e0, 0xa, 0x45,
|
|
0x3, 0x46, 0x3, 0x46, 0x3, 0x46, 0x3, 0x46, 0x3, 0x46, 0x3, 0x46, 0x3,
|
|
0x46, 0x3, 0x46, 0x3, 0x46, 0x3, 0x46, 0x3, 0x46, 0x5, 0x46, 0x3ed,
|
|
0xa, 0x46, 0x3, 0x47, 0x3, 0x47, 0x7, 0x47, 0x3f1, 0xa, 0x47, 0xc, 0x47,
|
|
0xe, 0x47, 0x3f4, 0xb, 0x47, 0x3, 0x47, 0x3, 0x47, 0x3, 0x48, 0x3, 0x48,
|
|
0x3, 0x48, 0x3, 0x48, 0x5, 0x48, 0x3fc, 0xa, 0x48, 0x3, 0x48, 0x3, 0x48,
|
|
0x3, 0x48, 0x3, 0x48, 0x7, 0x48, 0x402, 0xa, 0x48, 0xc, 0x48, 0xe, 0x48,
|
|
0x405, 0xb, 0x48, 0x3, 0x48, 0x3, 0x48, 0x5, 0x48, 0x409, 0xa, 0x48,
|
|
0x5, 0x48, 0x40b, 0xa, 0x48, 0x3, 0x49, 0x3, 0x49, 0x3, 0x49, 0x3, 0x49,
|
|
0x3, 0x49, 0x3, 0x49, 0x3, 0x49, 0x6, 0x49, 0x414, 0xa, 0x49, 0xd, 0x49,
|
|
0xe, 0x49, 0x415, 0x3, 0x49, 0x3, 0x49, 0x3, 0x49, 0x5, 0x49, 0x41b,
|
|
0xa, 0x49, 0x3, 0x4a, 0x3, 0x4a, 0x3, 0x4a, 0x3, 0x4a, 0x3, 0x4b, 0x3,
|
|
0x4b, 0x3, 0x4b, 0x3, 0x4b, 0x3, 0x4b, 0x3, 0x4b, 0x3, 0x4c, 0x3, 0x4c,
|
|
0x3, 0x4c, 0x3, 0x4c, 0x3, 0x4d, 0x3, 0x4d, 0x3, 0x4d, 0x6, 0x4d, 0x42e,
|
|
0xa, 0x4d, 0xd, 0x4d, 0xe, 0x4d, 0x42f, 0x3, 0x4d, 0x3, 0x4d, 0x5, 0x4d,
|
|
0x434, 0xa, 0x4d, 0x3, 0x4d, 0x3, 0x4d, 0x5, 0x4d, 0x438, 0xa, 0x4d,
|
|
0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4e, 0x7,
|
|
0x4e, 0x440, 0xa, 0x4e, 0xc, 0x4e, 0xe, 0x4e, 0x443, 0xb, 0x4e, 0x5,
|
|
0x4e, 0x445, 0xa, 0x4e, 0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4e,
|
|
0x3, 0x4e, 0x7, 0x4e, 0x44c, 0xa, 0x4e, 0xc, 0x4e, 0xe, 0x4e, 0x44f,
|
|
0xb, 0x4e, 0x5, 0x4e, 0x451, 0xa, 0x4e, 0x3, 0x4e, 0x3, 0x4e, 0x3, 0x4f,
|
|
0x3, 0x4f, 0x3, 0x4f, 0x7, 0x4f, 0x458, 0xa, 0x4f, 0xc, 0x4f, 0xe, 0x4f,
|
|
0x45b, 0xb, 0x4f, 0x3, 0x50, 0x3, 0x50, 0x3, 0x50, 0x3, 0x50, 0x3, 0x50,
|
|
0x7, 0x50, 0x462, 0xa, 0x50, 0xc, 0x50, 0xe, 0x50, 0x465, 0xb, 0x50,
|
|
0x5, 0x50, 0x467, 0xa, 0x50, 0x3, 0x50, 0x3, 0x50, 0x3, 0x51, 0x3, 0x51,
|
|
0x3, 0x52, 0x3, 0x52, 0x3, 0x52, 0x3, 0x52, 0x5, 0x52, 0x471, 0xa, 0x52,
|
|
0x3, 0x53, 0x3, 0x53, 0x3, 0x53, 0x5, 0x53, 0x476, 0xa, 0x53, 0x3, 0x53,
|
|
0x3, 0x113, 0x4, 0x42, 0x4c, 0x54, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe,
|
|
0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e, 0x20, 0x22, 0x24, 0x26,
|
|
0x28, 0x2a, 0x2c, 0x2e, 0x30, 0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c, 0x3e,
|
|
0x40, 0x42, 0x44, 0x46, 0x48, 0x4a, 0x4c, 0x4e, 0x50, 0x52, 0x54, 0x56,
|
|
0x58, 0x5a, 0x5c, 0x5e, 0x60, 0x62, 0x64, 0x66, 0x68, 0x6a, 0x6c, 0x6e,
|
|
0x70, 0x72, 0x74, 0x76, 0x78, 0x7a, 0x7c, 0x7e, 0x80, 0x82, 0x84, 0x86,
|
|
0x88, 0x8a, 0x8c, 0x8e, 0x90, 0x92, 0x94, 0x96, 0x98, 0x9a, 0x9c, 0x9e,
|
|
0xa0, 0xa2, 0xa4, 0x2, 0x13, 0x5, 0x2, 0x19, 0x19, 0x27, 0x27, 0x31,
|
|
0x32, 0x5, 0x2, 0x30, 0x30, 0x33, 0x33, 0x41, 0x41, 0x4, 0x2, 0x1a,
|
|
0x1a, 0x34, 0x34, 0x5, 0x2, 0xd, 0xd, 0x2b, 0x2b, 0x38, 0x38, 0x5, 0x2,
|
|
0x13, 0x13, 0x65, 0x65, 0x70, 0x73, 0x3, 0x2, 0x66, 0x68, 0x3, 0x2,
|
|
0x64, 0x65, 0x3, 0x2, 0x61, 0x63, 0x3, 0x2, 0x6c, 0x6f, 0x3, 0x2, 0x6a,
|
|
0x6b, 0x3, 0x2, 0x72, 0x73, 0x3, 0x2, 0x4f, 0x5a, 0x4, 0x2, 0x1d, 0x1d,
|
|
0x7a, 0x7a, 0x4, 0x2, 0x1b, 0x1b, 0x3b, 0x3b, 0x3, 0x2, 0x78, 0x79,
|
|
0x4, 0x2, 0x8f, 0x8f, 0x98, 0x98, 0x4, 0x2, 0x87, 0x87, 0x8e, 0x8e,
|
|
0x2, 0x4f8, 0x2, 0xb0, 0x3, 0x2, 0x2, 0x2, 0x4, 0xb5, 0x3, 0x2, 0x2,
|
|
0x2, 0x6, 0xbd, 0x3, 0x2, 0x2, 0x2, 0x8, 0xd1, 0x3, 0x2, 0x2, 0x2, 0xa,
|
|
0xd6, 0x3, 0x2, 0x2, 0x2, 0xc, 0xd8, 0x3, 0x2, 0x2, 0x2, 0xe, 0xe4,
|
|
0x3, 0x2, 0x2, 0x2, 0x10, 0xf4, 0x3, 0x2, 0x2, 0x2, 0x12, 0x102, 0x3,
|
|
0x2, 0x2, 0x2, 0x14, 0x10d, 0x3, 0x2, 0x2, 0x2, 0x16, 0x116, 0x3, 0x2,
|
|
0x2, 0x2, 0x18, 0x123, 0x3, 0x2, 0x2, 0x2, 0x1a, 0x125, 0x3, 0x2, 0x2,
|
|
0x2, 0x1c, 0x129, 0x3, 0x2, 0x2, 0x2, 0x1e, 0x144, 0x3, 0x2, 0x2, 0x2,
|
|
0x20, 0x14c, 0x3, 0x2, 0x2, 0x2, 0x22, 0x150, 0x3, 0x2, 0x2, 0x2, 0x24,
|
|
0x152, 0x3, 0x2, 0x2, 0x2, 0x26, 0x15a, 0x3, 0x2, 0x2, 0x2, 0x28, 0x161,
|
|
0x3, 0x2, 0x2, 0x2, 0x2a, 0x178, 0x3, 0x2, 0x2, 0x2, 0x2c, 0x17a, 0x3,
|
|
0x2, 0x2, 0x2, 0x2e, 0x188, 0x3, 0x2, 0x2, 0x2, 0x30, 0x1b3, 0x3, 0x2,
|
|
0x2, 0x2, 0x32, 0x1cc, 0x3, 0x2, 0x2, 0x2, 0x34, 0x1e8, 0x3, 0x2, 0x2,
|
|
0x2, 0x36, 0x1f2, 0x3, 0x2, 0x2, 0x2, 0x38, 0x1f6, 0x3, 0x2, 0x2, 0x2,
|
|
0x3a, 0x203, 0x3, 0x2, 0x2, 0x2, 0x3c, 0x223, 0x3, 0x2, 0x2, 0x2, 0x3e,
|
|
0x22a, 0x3, 0x2, 0x2, 0x2, 0x40, 0x23d, 0x3, 0x2, 0x2, 0x2, 0x42, 0x24b,
|
|
0x3, 0x2, 0x2, 0x2, 0x44, 0x264, 0x3, 0x2, 0x2, 0x2, 0x46, 0x266, 0x3,
|
|
0x2, 0x2, 0x2, 0x48, 0x280, 0x3, 0x2, 0x2, 0x2, 0x4a, 0x286, 0x3, 0x2,
|
|
0x2, 0x2, 0x4c, 0x29c, 0x3, 0x2, 0x2, 0x2, 0x4e, 0x2f5, 0x3, 0x2, 0x2,
|
|
0x2, 0x50, 0x2f7, 0x3, 0x2, 0x2, 0x2, 0x52, 0x306, 0x3, 0x2, 0x2, 0x2,
|
|
0x54, 0x311, 0x3, 0x2, 0x2, 0x2, 0x56, 0x318, 0x3, 0x2, 0x2, 0x2, 0x58,
|
|
0x31a, 0x3, 0x2, 0x2, 0x2, 0x5a, 0x31d, 0x3, 0x2, 0x2, 0x2, 0x5c, 0x322,
|
|
0x3, 0x2, 0x2, 0x2, 0x5e, 0x327, 0x3, 0x2, 0x2, 0x2, 0x60, 0x32b, 0x3,
|
|
0x2, 0x2, 0x2, 0x62, 0x32f, 0x3, 0x2, 0x2, 0x2, 0x64, 0x344, 0x3, 0x2,
|
|
0x2, 0x2, 0x66, 0x348, 0x3, 0x2, 0x2, 0x2, 0x68, 0x34a, 0x3, 0x2, 0x2,
|
|
0x2, 0x6a, 0x353, 0x3, 0x2, 0x2, 0x2, 0x6c, 0x363, 0x3, 0x2, 0x2, 0x2,
|
|
0x6e, 0x369, 0x3, 0x2, 0x2, 0x2, 0x70, 0x371, 0x3, 0x2, 0x2, 0x2, 0x72,
|
|
0x374, 0x3, 0x2, 0x2, 0x2, 0x74, 0x377, 0x3, 0x2, 0x2, 0x2, 0x76, 0x386,
|
|
0x3, 0x2, 0x2, 0x2, 0x78, 0x392, 0x3, 0x2, 0x2, 0x2, 0x7a, 0x398, 0x3,
|
|
0x2, 0x2, 0x2, 0x7c, 0x39d, 0x3, 0x2, 0x2, 0x2, 0x7e, 0x3aa, 0x3, 0x2,
|
|
0x2, 0x2, 0x80, 0x3b2, 0x3, 0x2, 0x2, 0x2, 0x82, 0x3cf, 0x3, 0x2, 0x2,
|
|
0x2, 0x84, 0x3d3, 0x3, 0x2, 0x2, 0x2, 0x86, 0x3d6, 0x3, 0x2, 0x2, 0x2,
|
|
0x88, 0x3df, 0x3, 0x2, 0x2, 0x2, 0x8a, 0x3ec, 0x3, 0x2, 0x2, 0x2, 0x8c,
|
|
0x3ee, 0x3, 0x2, 0x2, 0x2, 0x8e, 0x40a, 0x3, 0x2, 0x2, 0x2, 0x90, 0x41a,
|
|
0x3, 0x2, 0x2, 0x2, 0x92, 0x41c, 0x3, 0x2, 0x2, 0x2, 0x94, 0x420, 0x3,
|
|
0x2, 0x2, 0x2, 0x96, 0x426, 0x3, 0x2, 0x2, 0x2, 0x98, 0x42a, 0x3, 0x2,
|
|
0x2, 0x2, 0x9a, 0x439, 0x3, 0x2, 0x2, 0x2, 0x9c, 0x454, 0x3, 0x2, 0x2,
|
|
0x2, 0x9e, 0x45c, 0x3, 0x2, 0x2, 0x2, 0xa0, 0x46a, 0x3, 0x2, 0x2, 0x2,
|
|
0xa2, 0x470, 0x3, 0x2, 0x2, 0x2, 0xa4, 0x475, 0x3, 0x2, 0x2, 0x2, 0xa6,
|
|
0xaf, 0x5, 0x4, 0x3, 0x2, 0xa7, 0xaf, 0x5, 0x6, 0x4, 0x2, 0xa8, 0xaf,
|
|
0x5, 0xe, 0x8, 0x2, 0xa9, 0xaf, 0x5, 0x10, 0x9, 0x2, 0xaa, 0xaf, 0x5,
|
|
0x12, 0xa, 0x2, 0xab, 0xaf, 0x5, 0x2e, 0x18, 0x2, 0xac, 0xaf, 0x5, 0x34,
|
|
0x1b, 0x2, 0xad, 0xaf, 0x5, 0x38, 0x1d, 0x2, 0xae, 0xa6, 0x3, 0x2, 0x2,
|
|
0x2, 0xae, 0xa7, 0x3, 0x2, 0x2, 0x2, 0xae, 0xa8, 0x3, 0x2, 0x2, 0x2,
|
|
0xae, 0xa9, 0x3, 0x2, 0x2, 0x2, 0xae, 0xaa, 0x3, 0x2, 0x2, 0x2, 0xae,
|
|
0xab, 0x3, 0x2, 0x2, 0x2, 0xae, 0xac, 0x3, 0x2, 0x2, 0x2, 0xae, 0xad,
|
|
0x3, 0x2, 0x2, 0x2, 0xaf, 0xb2, 0x3, 0x2, 0x2, 0x2, 0xb0, 0xae, 0x3,
|
|
0x2, 0x2, 0x2, 0xb0, 0xb1, 0x3, 0x2, 0x2, 0x2, 0xb1, 0xb3, 0x3, 0x2,
|
|
0x2, 0x2, 0xb2, 0xb0, 0x3, 0x2, 0x2, 0x2, 0xb3, 0xb4, 0x7, 0x2, 0x2,
|
|
0x3, 0xb4, 0x3, 0x3, 0x2, 0x2, 0x2, 0xb5, 0xb7, 0x7, 0x4, 0x2, 0x2,
|
|
0xb6, 0xb8, 0x7, 0x9f, 0x2, 0x2, 0xb7, 0xb6, 0x3, 0x2, 0x2, 0x2, 0xb8,
|
|
0xb9, 0x3, 0x2, 0x2, 0x2, 0xb9, 0xb7, 0x3, 0x2, 0x2, 0x2, 0xb9, 0xba,
|
|
0x3, 0x2, 0x2, 0x2, 0xba, 0xbb, 0x3, 0x2, 0x2, 0x2, 0xbb, 0xbc, 0x7,
|
|
0xa0, 0x2, 0x2, 0xbc, 0x5, 0x3, 0x2, 0x2, 0x2, 0xbd, 0xcd, 0x7, 0x24,
|
|
0x2, 0x2, 0xbe, 0xc1, 0x5, 0xa, 0x6, 0x2, 0xbf, 0xc0, 0x7, 0x8, 0x2,
|
|
0x2, 0xc0, 0xc2, 0x5, 0x54, 0x2b, 0x2, 0xc1, 0xbf, 0x3, 0x2, 0x2, 0x2,
|
|
0xc1, 0xc2, 0x3, 0x2, 0x2, 0x2, 0xc2, 0xce, 0x3, 0x2, 0x2, 0x2, 0xc3,
|
|
0xc4, 0x5, 0xc, 0x7, 0x2, 0xc4, 0xc5, 0x7, 0x1d, 0x2, 0x2, 0xc5, 0xc6,
|
|
0x5, 0xa, 0x6, 0x2, 0xc6, 0xce, 0x3, 0x2, 0x2, 0x2, 0xc7, 0xc8, 0x7,
|
|
0x66, 0x2, 0x2, 0xc8, 0xc9, 0x7, 0x8, 0x2, 0x2, 0xc9, 0xca, 0x5, 0x54,
|
|
0x2b, 0x2, 0xca, 0xcb, 0x7, 0x1d, 0x2, 0x2, 0xcb, 0xcc, 0x5, 0xa, 0x6,
|
|
0x2, 0xcc, 0xce, 0x3, 0x2, 0x2, 0x2, 0xcd, 0xbe, 0x3, 0x2, 0x2, 0x2,
|
|
0xcd, 0xc3, 0x3, 0x2, 0x2, 0x2, 0xcd, 0xc7, 0x3, 0x2, 0x2, 0x2, 0xce,
|
|
0xcf, 0x3, 0x2, 0x2, 0x2, 0xcf, 0xd0, 0x7, 0x4b, 0x2, 0x2, 0xd0, 0x7,
|
|
0x3, 0x2, 0x2, 0x2, 0xd1, 0xd4, 0x5, 0x54, 0x2b, 0x2, 0xd2, 0xd3, 0x7,
|
|
0x8, 0x2, 0x2, 0xd3, 0xd5, 0x5, 0x54, 0x2b, 0x2, 0xd4, 0xd2, 0x3, 0x2,
|
|
0x2, 0x2, 0xd4, 0xd5, 0x3, 0x2, 0x2, 0x2, 0xd5, 0x9, 0x3, 0x2, 0x2,
|
|
0x2, 0xd6, 0xd7, 0x7, 0x75, 0x2, 0x2, 0xd7, 0xb, 0x3, 0x2, 0x2, 0x2,
|
|
0xd8, 0xd9, 0x7, 0x48, 0x2, 0x2, 0xd9, 0xde, 0x5, 0x8, 0x5, 0x2, 0xda,
|
|
0xdb, 0x7, 0x5b, 0x2, 0x2, 0xdb, 0xdd, 0x5, 0x8, 0x5, 0x2, 0xdc, 0xda,
|
|
0x3, 0x2, 0x2, 0x2, 0xdd, 0xe0, 0x3, 0x2, 0x2, 0x2, 0xde, 0xdc, 0x3,
|
|
0x2, 0x2, 0x2, 0xde, 0xdf, 0x3, 0x2, 0x2, 0x2, 0xdf, 0xe1, 0x3, 0x2,
|
|
0x2, 0x2, 0xe0, 0xde, 0x3, 0x2, 0x2, 0x2, 0xe1, 0xe2, 0x7, 0x49, 0x2,
|
|
0x2, 0xe2, 0xd, 0x3, 0x2, 0x2, 0x2, 0xe3, 0xe5, 0x7, 0x5, 0x2, 0x2,
|
|
0xe4, 0xe3, 0x3, 0x2, 0x2, 0x2, 0xe4, 0xe5, 0x3, 0x2, 0x2, 0x2, 0xe5,
|
|
0xe6, 0x3, 0x2, 0x2, 0x2, 0xe6, 0xe7, 0x7, 0x12, 0x2, 0x2, 0xe7, 0xe9,
|
|
0x5, 0x54, 0x2b, 0x2, 0xe8, 0xea, 0x5, 0x14, 0xb, 0x2, 0xe9, 0xe8, 0x3,
|
|
0x2, 0x2, 0x2, 0xe9, 0xea, 0x3, 0x2, 0x2, 0x2, 0xea, 0xeb, 0x3, 0x2,
|
|
0x2, 0x2, 0xeb, 0xef, 0x7, 0x48, 0x2, 0x2, 0xec, 0xee, 0x5, 0x18, 0xd,
|
|
0x2, 0xed, 0xec, 0x3, 0x2, 0x2, 0x2, 0xee, 0xf1, 0x3, 0x2, 0x2, 0x2,
|
|
0xef, 0xed, 0x3, 0x2, 0x2, 0x2, 0xef, 0xf0, 0x3, 0x2, 0x2, 0x2, 0xf0,
|
|
0xf2, 0x3, 0x2, 0x2, 0x2, 0xf1, 0xef, 0x3, 0x2, 0x2, 0x2, 0xf2, 0xf3,
|
|
0x7, 0x49, 0x2, 0x2, 0xf3, 0xf, 0x3, 0x2, 0x2, 0x2, 0xf4, 0xf5, 0x7,
|
|
0x26, 0x2, 0x2, 0xf5, 0xf7, 0x5, 0x54, 0x2b, 0x2, 0xf6, 0xf8, 0x5, 0x14,
|
|
0xb, 0x2, 0xf7, 0xf6, 0x3, 0x2, 0x2, 0x2, 0xf7, 0xf8, 0x3, 0x2, 0x2,
|
|
0x2, 0xf8, 0xf9, 0x3, 0x2, 0x2, 0x2, 0xf9, 0xfd, 0x7, 0x48, 0x2, 0x2,
|
|
0xfa, 0xfc, 0x5, 0x18, 0xd, 0x2, 0xfb, 0xfa, 0x3, 0x2, 0x2, 0x2, 0xfc,
|
|
0xff, 0x3, 0x2, 0x2, 0x2, 0xfd, 0xfb, 0x3, 0x2, 0x2, 0x2, 0xfd, 0xfe,
|
|
0x3, 0x2, 0x2, 0x2, 0xfe, 0x100, 0x3, 0x2, 0x2, 0x2, 0xff, 0xfd, 0x3,
|
|
0x2, 0x2, 0x2, 0x100, 0x101, 0x7, 0x49, 0x2, 0x2, 0x101, 0x11, 0x3,
|
|
0x2, 0x2, 0x2, 0x102, 0x103, 0x7, 0x29, 0x2, 0x2, 0x103, 0x104, 0x5,
|
|
0x54, 0x2b, 0x2, 0x104, 0x108, 0x7, 0x48, 0x2, 0x2, 0x105, 0x107, 0x5,
|
|
0x18, 0xd, 0x2, 0x106, 0x105, 0x3, 0x2, 0x2, 0x2, 0x107, 0x10a, 0x3,
|
|
0x2, 0x2, 0x2, 0x108, 0x106, 0x3, 0x2, 0x2, 0x2, 0x108, 0x109, 0x3,
|
|
0x2, 0x2, 0x2, 0x109, 0x10b, 0x3, 0x2, 0x2, 0x2, 0x10a, 0x108, 0x3,
|
|
0x2, 0x2, 0x2, 0x10b, 0x10c, 0x7, 0x49, 0x2, 0x2, 0x10c, 0x13, 0x3,
|
|
0x2, 0x2, 0x2, 0x10d, 0x10e, 0x7, 0x28, 0x2, 0x2, 0x10e, 0x113, 0x5,
|
|
0x16, 0xc, 0x2, 0x10f, 0x110, 0x7, 0x5b, 0x2, 0x2, 0x110, 0x112, 0x5,
|
|
0x16, 0xc, 0x2, 0x111, 0x10f, 0x3, 0x2, 0x2, 0x2, 0x112, 0x115, 0x3,
|
|
0x2, 0x2, 0x2, 0x113, 0x114, 0x3, 0x2, 0x2, 0x2, 0x113, 0x111, 0x3,
|
|
0x2, 0x2, 0x2, 0x114, 0x15, 0x3, 0x2, 0x2, 0x2, 0x115, 0x113, 0x3, 0x2,
|
|
0x2, 0x2, 0x116, 0x118, 0x5, 0x1e, 0x10, 0x2, 0x117, 0x119, 0x5, 0x1c,
|
|
0xf, 0x2, 0x118, 0x117, 0x3, 0x2, 0x2, 0x2, 0x118, 0x119, 0x3, 0x2,
|
|
0x2, 0x2, 0x119, 0x17, 0x3, 0x2, 0x2, 0x2, 0x11a, 0x124, 0x5, 0x28,
|
|
0x15, 0x2, 0x11b, 0x124, 0x5, 0x2e, 0x18, 0x2, 0x11c, 0x124, 0x5, 0x30,
|
|
0x19, 0x2, 0x11d, 0x124, 0x5, 0x32, 0x1a, 0x2, 0x11e, 0x124, 0x5, 0x34,
|
|
0x1b, 0x2, 0x11f, 0x124, 0x5, 0x38, 0x1d, 0x2, 0x120, 0x124, 0x5, 0x3a,
|
|
0x1e, 0x2, 0x121, 0x124, 0x5, 0x3e, 0x20, 0x2, 0x122, 0x124, 0x5, 0x40,
|
|
0x21, 0x2, 0x123, 0x11a, 0x3, 0x2, 0x2, 0x2, 0x123, 0x11b, 0x3, 0x2,
|
|
0x2, 0x2, 0x123, 0x11c, 0x3, 0x2, 0x2, 0x2, 0x123, 0x11d, 0x3, 0x2,
|
|
0x2, 0x2, 0x123, 0x11e, 0x3, 0x2, 0x2, 0x2, 0x123, 0x11f, 0x3, 0x2,
|
|
0x2, 0x2, 0x123, 0x120, 0x3, 0x2, 0x2, 0x2, 0x123, 0x121, 0x3, 0x2,
|
|
0x2, 0x2, 0x123, 0x122, 0x3, 0x2, 0x2, 0x2, 0x124, 0x19, 0x3, 0x2, 0x2,
|
|
0x2, 0x125, 0x126, 0x5, 0x54, 0x2b, 0x2, 0x126, 0x127, 0x7, 0x4a, 0x2,
|
|
0x2, 0x127, 0x128, 0x5, 0x4c, 0x27, 0x2, 0x128, 0x1b, 0x3, 0x2, 0x2,
|
|
0x2, 0x129, 0x140, 0x7, 0x44, 0x2, 0x2, 0x12a, 0x12f, 0x5, 0x4c, 0x27,
|
|
0x2, 0x12b, 0x12c, 0x7, 0x5b, 0x2, 0x2, 0x12c, 0x12e, 0x5, 0x4c, 0x27,
|
|
0x2, 0x12d, 0x12b, 0x3, 0x2, 0x2, 0x2, 0x12e, 0x131, 0x3, 0x2, 0x2,
|
|
0x2, 0x12f, 0x12d, 0x3, 0x2, 0x2, 0x2, 0x12f, 0x130, 0x3, 0x2, 0x2,
|
|
0x2, 0x130, 0x133, 0x3, 0x2, 0x2, 0x2, 0x131, 0x12f, 0x3, 0x2, 0x2,
|
|
0x2, 0x132, 0x12a, 0x3, 0x2, 0x2, 0x2, 0x132, 0x133, 0x3, 0x2, 0x2,
|
|
0x2, 0x133, 0x141, 0x3, 0x2, 0x2, 0x2, 0x134, 0x13d, 0x7, 0x48, 0x2,
|
|
0x2, 0x135, 0x13a, 0x5, 0x1a, 0xe, 0x2, 0x136, 0x137, 0x7, 0x5b, 0x2,
|
|
0x2, 0x137, 0x139, 0x5, 0x1a, 0xe, 0x2, 0x138, 0x136, 0x3, 0x2, 0x2,
|
|
0x2, 0x139, 0x13c, 0x3, 0x2, 0x2, 0x2, 0x13a, 0x138, 0x3, 0x2, 0x2,
|
|
0x2, 0x13a, 0x13b, 0x3, 0x2, 0x2, 0x2, 0x13b, 0x13e, 0x3, 0x2, 0x2,
|
|
0x2, 0x13c, 0x13a, 0x3, 0x2, 0x2, 0x2, 0x13d, 0x135, 0x3, 0x2, 0x2,
|
|
0x2, 0x13d, 0x13e, 0x3, 0x2, 0x2, 0x2, 0x13e, 0x13f, 0x3, 0x2, 0x2,
|
|
0x2, 0x13f, 0x141, 0x7, 0x49, 0x2, 0x2, 0x140, 0x132, 0x3, 0x2, 0x2,
|
|
0x2, 0x140, 0x134, 0x3, 0x2, 0x2, 0x2, 0x141, 0x142, 0x3, 0x2, 0x2,
|
|
0x2, 0x142, 0x143, 0x7, 0x45, 0x2, 0x2, 0x143, 0x1d, 0x3, 0x2, 0x2,
|
|
0x2, 0x144, 0x149, 0x5, 0x54, 0x2b, 0x2, 0x145, 0x146, 0x7, 0x4c, 0x2,
|
|
0x2, 0x146, 0x148, 0x5, 0x54, 0x2b, 0x2, 0x147, 0x145, 0x3, 0x2, 0x2,
|
|
0x2, 0x148, 0x14b, 0x3, 0x2, 0x2, 0x2, 0x149, 0x147, 0x3, 0x2, 0x2,
|
|
0x2, 0x149, 0x14a, 0x3, 0x2, 0x2, 0x2, 0x14a, 0x1f, 0x3, 0x2, 0x2, 0x2,
|
|
0x14b, 0x149, 0x3, 0x2, 0x2, 0x2, 0x14c, 0x14e, 0x5, 0x54, 0x2b, 0x2,
|
|
0x14d, 0x14f, 0x5, 0x1c, 0xf, 0x2, 0x14e, 0x14d, 0x3, 0x2, 0x2, 0x2,
|
|
0x14e, 0x14f, 0x3, 0x2, 0x2, 0x2, 0x14f, 0x21, 0x3, 0x2, 0x2, 0x2, 0x150,
|
|
0x151, 0x9, 0x2, 0x2, 0x2, 0x151, 0x23, 0x3, 0x2, 0x2, 0x2, 0x152, 0x157,
|
|
0x5, 0x26, 0x14, 0x2, 0x153, 0x154, 0x7, 0x5b, 0x2, 0x2, 0x154, 0x156,
|
|
0x5, 0x26, 0x14, 0x2, 0x155, 0x153, 0x3, 0x2, 0x2, 0x2, 0x156, 0x159,
|
|
0x3, 0x2, 0x2, 0x2, 0x157, 0x155, 0x3, 0x2, 0x2, 0x2, 0x157, 0x158,
|
|
0x3, 0x2, 0x2, 0x2, 0x158, 0x25, 0x3, 0x2, 0x2, 0x2, 0x159, 0x157, 0x3,
|
|
0x2, 0x2, 0x2, 0x15a, 0x15c, 0x5, 0x42, 0x22, 0x2, 0x15b, 0x15d, 0x5,
|
|
0x4a, 0x26, 0x2, 0x15c, 0x15b, 0x3, 0x2, 0x2, 0x2, 0x15c, 0x15d, 0x3,
|
|
0x2, 0x2, 0x2, 0x15d, 0x15f, 0x3, 0x2, 0x2, 0x2, 0x15e, 0x160, 0x5,
|
|
0x54, 0x2b, 0x2, 0x15f, 0x15e, 0x3, 0x2, 0x2, 0x2, 0x15f, 0x160, 0x3,
|
|
0x2, 0x2, 0x2, 0x160, 0x27, 0x3, 0x2, 0x2, 0x2, 0x161, 0x162, 0x7, 0x10,
|
|
0x2, 0x2, 0x162, 0x164, 0x7, 0x44, 0x2, 0x2, 0x163, 0x165, 0x5, 0x24,
|
|
0x13, 0x2, 0x164, 0x163, 0x3, 0x2, 0x2, 0x2, 0x164, 0x165, 0x3, 0x2,
|
|
0x2, 0x2, 0x165, 0x166, 0x3, 0x2, 0x2, 0x2, 0x166, 0x173, 0x7, 0x45,
|
|
0x2, 0x2, 0x167, 0x172, 0x5, 0x20, 0x11, 0x2, 0x168, 0x169, 0x6, 0x15,
|
|
0x2, 0x3, 0x169, 0x16a, 0x7, 0x30, 0x2, 0x2, 0x16a, 0x172, 0x8, 0x15,
|
|
0x1, 0x2, 0x16b, 0x16c, 0x6, 0x15, 0x3, 0x3, 0x16c, 0x16d, 0x7, 0x27,
|
|
0x2, 0x2, 0x16d, 0x172, 0x8, 0x15, 0x1, 0x2, 0x16e, 0x16f, 0x6, 0x15,
|
|
0x4, 0x3, 0x16f, 0x170, 0x7, 0x32, 0x2, 0x2, 0x170, 0x172, 0x8, 0x15,
|
|
0x1, 0x2, 0x171, 0x167, 0x3, 0x2, 0x2, 0x2, 0x171, 0x168, 0x3, 0x2,
|
|
0x2, 0x2, 0x171, 0x16b, 0x3, 0x2, 0x2, 0x2, 0x171, 0x16e, 0x3, 0x2,
|
|
0x2, 0x2, 0x172, 0x175, 0x3, 0x2, 0x2, 0x2, 0x173, 0x171, 0x3, 0x2,
|
|
0x2, 0x2, 0x173, 0x174, 0x3, 0x2, 0x2, 0x2, 0x174, 0x176, 0x3, 0x2,
|
|
0x2, 0x2, 0x175, 0x173, 0x3, 0x2, 0x2, 0x2, 0x176, 0x177, 0x5, 0x62,
|
|
0x32, 0x2, 0x177, 0x29, 0x3, 0x2, 0x2, 0x2, 0x178, 0x179, 0x9, 0x3,
|
|
0x2, 0x2, 0x179, 0x2b, 0x3, 0x2, 0x2, 0x2, 0x17a, 0x186, 0x7, 0x2f,
|
|
0x2, 0x2, 0x17b, 0x17c, 0x7, 0x44, 0x2, 0x2, 0x17c, 0x181, 0x5, 0x1e,
|
|
0x10, 0x2, 0x17d, 0x17e, 0x7, 0x5b, 0x2, 0x2, 0x17e, 0x180, 0x5, 0x1e,
|
|
0x10, 0x2, 0x17f, 0x17d, 0x3, 0x2, 0x2, 0x2, 0x180, 0x183, 0x3, 0x2,
|
|
0x2, 0x2, 0x181, 0x17f, 0x3, 0x2, 0x2, 0x2, 0x181, 0x182, 0x3, 0x2,
|
|
0x2, 0x2, 0x182, 0x184, 0x3, 0x2, 0x2, 0x2, 0x183, 0x181, 0x3, 0x2,
|
|
0x2, 0x2, 0x184, 0x185, 0x7, 0x45, 0x2, 0x2, 0x185, 0x187, 0x3, 0x2,
|
|
0x2, 0x2, 0x186, 0x17b, 0x3, 0x2, 0x2, 0x2, 0x186, 0x187, 0x3, 0x2,
|
|
0x2, 0x2, 0x187, 0x2d, 0x3, 0x2, 0x2, 0x2, 0x188, 0x18c, 0x7, 0x20,
|
|
0x2, 0x2, 0x189, 0x18d, 0x5, 0x54, 0x2b, 0x2, 0x18a, 0x18d, 0x7, 0x1a,
|
|
0x2, 0x2, 0x18b, 0x18d, 0x7, 0x34, 0x2, 0x2, 0x18c, 0x189, 0x3, 0x2,
|
|
0x2, 0x2, 0x18c, 0x18a, 0x3, 0x2, 0x2, 0x2, 0x18c, 0x18b, 0x3, 0x2,
|
|
0x2, 0x2, 0x18d, 0x18e, 0x3, 0x2, 0x2, 0x2, 0x18e, 0x190, 0x7, 0x44,
|
|
0x2, 0x2, 0x18f, 0x191, 0x5, 0x24, 0x13, 0x2, 0x190, 0x18f, 0x3, 0x2,
|
|
0x2, 0x2, 0x190, 0x191, 0x3, 0x2, 0x2, 0x2, 0x191, 0x192, 0x3, 0x2,
|
|
0x2, 0x2, 0x192, 0x1a5, 0x7, 0x45, 0x2, 0x2, 0x193, 0x194, 0x6, 0x18,
|
|
0x5, 0x3, 0x194, 0x195, 0x5, 0x22, 0x12, 0x2, 0x195, 0x196, 0x8, 0x18,
|
|
0x1, 0x2, 0x196, 0x1a4, 0x3, 0x2, 0x2, 0x2, 0x197, 0x198, 0x6, 0x18,
|
|
0x6, 0x3, 0x198, 0x199, 0x5, 0x2a, 0x16, 0x2, 0x199, 0x19a, 0x8, 0x18,
|
|
0x1, 0x2, 0x19a, 0x1a4, 0x3, 0x2, 0x2, 0x2, 0x19b, 0x1a4, 0x5, 0x20,
|
|
0x11, 0x2, 0x19c, 0x19d, 0x6, 0x18, 0x7, 0x3, 0x19d, 0x19e, 0x7, 0x42,
|
|
0x2, 0x2, 0x19e, 0x1a4, 0x8, 0x18, 0x1, 0x2, 0x19f, 0x1a0, 0x6, 0x18,
|
|
0x8, 0x3, 0x1a0, 0x1a1, 0x5, 0x2c, 0x17, 0x2, 0x1a1, 0x1a2, 0x8, 0x18,
|
|
0x1, 0x2, 0x1a2, 0x1a4, 0x3, 0x2, 0x2, 0x2, 0x1a3, 0x193, 0x3, 0x2,
|
|
0x2, 0x2, 0x1a3, 0x197, 0x3, 0x2, 0x2, 0x2, 0x1a3, 0x19b, 0x3, 0x2,
|
|
0x2, 0x2, 0x1a3, 0x19c, 0x3, 0x2, 0x2, 0x2, 0x1a3, 0x19f, 0x3, 0x2,
|
|
0x2, 0x2, 0x1a4, 0x1a7, 0x3, 0x2, 0x2, 0x2, 0x1a5, 0x1a3, 0x3, 0x2,
|
|
0x2, 0x2, 0x1a5, 0x1a6, 0x3, 0x2, 0x2, 0x2, 0x1a6, 0x1ad, 0x3, 0x2,
|
|
0x2, 0x2, 0x1a7, 0x1a5, 0x3, 0x2, 0x2, 0x2, 0x1a8, 0x1a9, 0x7, 0x36,
|
|
0x2, 0x2, 0x1a9, 0x1aa, 0x7, 0x44, 0x2, 0x2, 0x1aa, 0x1ab, 0x5, 0x24,
|
|
0x13, 0x2, 0x1ab, 0x1ac, 0x7, 0x45, 0x2, 0x2, 0x1ac, 0x1ae, 0x3, 0x2,
|
|
0x2, 0x2, 0x1ad, 0x1a8, 0x3, 0x2, 0x2, 0x2, 0x1ad, 0x1ae, 0x3, 0x2,
|
|
0x2, 0x2, 0x1ae, 0x1b1, 0x3, 0x2, 0x2, 0x2, 0x1af, 0x1b2, 0x7, 0x4b,
|
|
0x2, 0x2, 0x1b0, 0x1b2, 0x5, 0x62, 0x32, 0x2, 0x1b1, 0x1af, 0x3, 0x2,
|
|
0x2, 0x2, 0x1b1, 0x1b0, 0x3, 0x2, 0x2, 0x2, 0x1b2, 0x2f, 0x3, 0x2, 0x2,
|
|
0x2, 0x1b3, 0x1b4, 0x7, 0x2c, 0x2, 0x2, 0x1b4, 0x1ba, 0x5, 0x54, 0x2b,
|
|
0x2, 0x1b5, 0x1b7, 0x7, 0x44, 0x2, 0x2, 0x1b6, 0x1b8, 0x5, 0x24, 0x13,
|
|
0x2, 0x1b7, 0x1b6, 0x3, 0x2, 0x2, 0x2, 0x1b7, 0x1b8, 0x3, 0x2, 0x2,
|
|
0x2, 0x1b8, 0x1b9, 0x3, 0x2, 0x2, 0x2, 0x1b9, 0x1bb, 0x7, 0x45, 0x2,
|
|
0x2, 0x1ba, 0x1b5, 0x3, 0x2, 0x2, 0x2, 0x1ba, 0x1bb, 0x3, 0x2, 0x2,
|
|
0x2, 0x1bb, 0x1c5, 0x3, 0x2, 0x2, 0x2, 0x1bc, 0x1bd, 0x6, 0x19, 0x9,
|
|
0x3, 0x1bd, 0x1be, 0x7, 0x42, 0x2, 0x2, 0x1be, 0x1c4, 0x8, 0x19, 0x1,
|
|
0x2, 0x1bf, 0x1c0, 0x6, 0x19, 0xa, 0x3, 0x1c0, 0x1c1, 0x5, 0x2c, 0x17,
|
|
0x2, 0x1c1, 0x1c2, 0x8, 0x19, 0x1, 0x2, 0x1c2, 0x1c4, 0x3, 0x2, 0x2,
|
|
0x2, 0x1c3, 0x1bc, 0x3, 0x2, 0x2, 0x2, 0x1c3, 0x1bf, 0x3, 0x2, 0x2,
|
|
0x2, 0x1c4, 0x1c7, 0x3, 0x2, 0x2, 0x2, 0x1c5, 0x1c3, 0x3, 0x2, 0x2,
|
|
0x2, 0x1c5, 0x1c6, 0x3, 0x2, 0x2, 0x2, 0x1c6, 0x1ca, 0x3, 0x2, 0x2,
|
|
0x2, 0x1c7, 0x1c5, 0x3, 0x2, 0x2, 0x2, 0x1c8, 0x1cb, 0x7, 0x4b, 0x2,
|
|
0x2, 0x1c9, 0x1cb, 0x5, 0x62, 0x32, 0x2, 0x1ca, 0x1c8, 0x3, 0x2, 0x2,
|
|
0x2, 0x1ca, 0x1c9, 0x3, 0x2, 0x2, 0x2, 0x1cb, 0x31, 0x3, 0x2, 0x2, 0x2,
|
|
0x1cc, 0x1cd, 0x9, 0x4, 0x2, 0x2, 0x1cd, 0x1ce, 0x7, 0x44, 0x2, 0x2,
|
|
0x1ce, 0x1e1, 0x7, 0x45, 0x2, 0x2, 0x1cf, 0x1d0, 0x6, 0x1a, 0xb, 0x3,
|
|
0x1d0, 0x1d1, 0x5, 0x22, 0x12, 0x2, 0x1d1, 0x1d2, 0x8, 0x1a, 0x1, 0x2,
|
|
0x1d2, 0x1e0, 0x3, 0x2, 0x2, 0x2, 0x1d3, 0x1d4, 0x6, 0x1a, 0xc, 0x3,
|
|
0x1d4, 0x1d5, 0x5, 0x2a, 0x16, 0x2, 0x1d5, 0x1d6, 0x8, 0x1a, 0x1, 0x2,
|
|
0x1d6, 0x1e0, 0x3, 0x2, 0x2, 0x2, 0x1d7, 0x1e0, 0x5, 0x20, 0x11, 0x2,
|
|
0x1d8, 0x1d9, 0x6, 0x1a, 0xd, 0x3, 0x1d9, 0x1da, 0x7, 0x42, 0x2, 0x2,
|
|
0x1da, 0x1e0, 0x8, 0x1a, 0x1, 0x2, 0x1db, 0x1dc, 0x6, 0x1a, 0xe, 0x3,
|
|
0x1dc, 0x1dd, 0x5, 0x2c, 0x17, 0x2, 0x1dd, 0x1de, 0x8, 0x1a, 0x1, 0x2,
|
|
0x1de, 0x1e0, 0x3, 0x2, 0x2, 0x2, 0x1df, 0x1cf, 0x3, 0x2, 0x2, 0x2,
|
|
0x1df, 0x1d3, 0x3, 0x2, 0x2, 0x2, 0x1df, 0x1d7, 0x3, 0x2, 0x2, 0x2,
|
|
0x1df, 0x1d8, 0x3, 0x2, 0x2, 0x2, 0x1df, 0x1db, 0x3, 0x2, 0x2, 0x2,
|
|
0x1e0, 0x1e3, 0x3, 0x2, 0x2, 0x2, 0x1e1, 0x1df, 0x3, 0x2, 0x2, 0x2,
|
|
0x1e1, 0x1e2, 0x3, 0x2, 0x2, 0x2, 0x1e2, 0x1e6, 0x3, 0x2, 0x2, 0x2,
|
|
0x1e3, 0x1e1, 0x3, 0x2, 0x2, 0x2, 0x1e4, 0x1e7, 0x7, 0x4b, 0x2, 0x2,
|
|
0x1e5, 0x1e7, 0x5, 0x62, 0x32, 0x2, 0x1e6, 0x1e4, 0x3, 0x2, 0x2, 0x2,
|
|
0x1e6, 0x1e5, 0x3, 0x2, 0x2, 0x2, 0x1e7, 0x33, 0x3, 0x2, 0x2, 0x2, 0x1e8,
|
|
0x1e9, 0x7, 0x3a, 0x2, 0x2, 0x1e9, 0x1ea, 0x5, 0x54, 0x2b, 0x2, 0x1ea,
|
|
0x1ec, 0x7, 0x48, 0x2, 0x2, 0x1eb, 0x1ed, 0x5, 0x36, 0x1c, 0x2, 0x1ec,
|
|
0x1eb, 0x3, 0x2, 0x2, 0x2, 0x1ed, 0x1ee, 0x3, 0x2, 0x2, 0x2, 0x1ee,
|
|
0x1ec, 0x3, 0x2, 0x2, 0x2, 0x1ee, 0x1ef, 0x3, 0x2, 0x2, 0x2, 0x1ef,
|
|
0x1f0, 0x3, 0x2, 0x2, 0x2, 0x1f0, 0x1f1, 0x7, 0x49, 0x2, 0x2, 0x1f1,
|
|
0x35, 0x3, 0x2, 0x2, 0x2, 0x1f2, 0x1f3, 0x5, 0x42, 0x22, 0x2, 0x1f3,
|
|
0x1f4, 0x5, 0x54, 0x2b, 0x2, 0x1f4, 0x1f5, 0x7, 0x4b, 0x2, 0x2, 0x1f5,
|
|
0x37, 0x3, 0x2, 0x2, 0x2, 0x1f6, 0x1f7, 0x7, 0x17, 0x2, 0x2, 0x1f7,
|
|
0x1f8, 0x5, 0x54, 0x2b, 0x2, 0x1f8, 0x1f9, 0x7, 0x48, 0x2, 0x2, 0x1f9,
|
|
0x1fe, 0x5, 0x54, 0x2b, 0x2, 0x1fa, 0x1fb, 0x7, 0x5b, 0x2, 0x2, 0x1fb,
|
|
0x1fd, 0x5, 0x54, 0x2b, 0x2, 0x1fc, 0x1fa, 0x3, 0x2, 0x2, 0x2, 0x1fd,
|
|
0x200, 0x3, 0x2, 0x2, 0x2, 0x1fe, 0x1fc, 0x3, 0x2, 0x2, 0x2, 0x1fe,
|
|
0x1ff, 0x3, 0x2, 0x2, 0x2, 0x1ff, 0x201, 0x3, 0x2, 0x2, 0x2, 0x200,
|
|
0x1fe, 0x3, 0x2, 0x2, 0x2, 0x201, 0x202, 0x7, 0x49, 0x2, 0x2, 0x202,
|
|
0x39, 0x3, 0x2, 0x2, 0x2, 0x203, 0x219, 0x5, 0x42, 0x22, 0x2, 0x204,
|
|
0x205, 0x6, 0x1e, 0xf, 0x3, 0x205, 0x206, 0x7, 0x32, 0x2, 0x2, 0x206,
|
|
0x218, 0x8, 0x1e, 0x1, 0x2, 0x207, 0x208, 0x6, 0x1e, 0x10, 0x3, 0x208,
|
|
0x209, 0x7, 0x31, 0x2, 0x2, 0x209, 0x218, 0x8, 0x1e, 0x1, 0x2, 0x20a,
|
|
0x20b, 0x6, 0x1e, 0x11, 0x3, 0x20b, 0x20c, 0x7, 0x27, 0x2, 0x2, 0x20c,
|
|
0x218, 0x8, 0x1e, 0x1, 0x2, 0x20d, 0x20e, 0x6, 0x1e, 0x12, 0x3, 0x20e,
|
|
0x20f, 0x7, 0xf, 0x2, 0x2, 0x20f, 0x218, 0x8, 0x1e, 0x1, 0x2, 0x210,
|
|
0x211, 0x6, 0x1e, 0x13, 0x3, 0x211, 0x212, 0x5, 0x2c, 0x17, 0x2, 0x212,
|
|
0x213, 0x8, 0x1e, 0x1, 0x2, 0x213, 0x218, 0x3, 0x2, 0x2, 0x2, 0x214,
|
|
0x215, 0x6, 0x1e, 0x14, 0x3, 0x215, 0x216, 0x7, 0x23, 0x2, 0x2, 0x216,
|
|
0x218, 0x8, 0x1e, 0x1, 0x2, 0x217, 0x204, 0x3, 0x2, 0x2, 0x2, 0x217,
|
|
0x207, 0x3, 0x2, 0x2, 0x2, 0x217, 0x20a, 0x3, 0x2, 0x2, 0x2, 0x217,
|
|
0x20d, 0x3, 0x2, 0x2, 0x2, 0x217, 0x210, 0x3, 0x2, 0x2, 0x2, 0x217,
|
|
0x214, 0x3, 0x2, 0x2, 0x2, 0x218, 0x21b, 0x3, 0x2, 0x2, 0x2, 0x219,
|
|
0x217, 0x3, 0x2, 0x2, 0x2, 0x219, 0x21a, 0x3, 0x2, 0x2, 0x2, 0x21a,
|
|
0x21c, 0x3, 0x2, 0x2, 0x2, 0x21b, 0x219, 0x3, 0x2, 0x2, 0x2, 0x21c,
|
|
0x21f, 0x5, 0x54, 0x2b, 0x2, 0x21d, 0x21e, 0x7, 0x4f, 0x2, 0x2, 0x21e,
|
|
0x220, 0x5, 0x4c, 0x27, 0x2, 0x21f, 0x21d, 0x3, 0x2, 0x2, 0x2, 0x21f,
|
|
0x220, 0x3, 0x2, 0x2, 0x2, 0x220, 0x221, 0x3, 0x2, 0x2, 0x2, 0x221,
|
|
0x222, 0x7, 0x4b, 0x2, 0x2, 0x222, 0x3b, 0x3, 0x2, 0x2, 0x2, 0x223,
|
|
0x225, 0x5, 0x42, 0x22, 0x2, 0x224, 0x226, 0x7, 0x25, 0x2, 0x2, 0x225,
|
|
0x224, 0x3, 0x2, 0x2, 0x2, 0x225, 0x226, 0x3, 0x2, 0x2, 0x2, 0x226,
|
|
0x228, 0x3, 0x2, 0x2, 0x2, 0x227, 0x229, 0x5, 0x54, 0x2b, 0x2, 0x228,
|
|
0x227, 0x3, 0x2, 0x2, 0x2, 0x228, 0x229, 0x3, 0x2, 0x2, 0x2, 0x229,
|
|
0x3d, 0x3, 0x2, 0x2, 0x2, 0x22a, 0x22b, 0x7, 0x18, 0x2, 0x2, 0x22b,
|
|
0x22c, 0x5, 0x54, 0x2b, 0x2, 0x22c, 0x235, 0x7, 0x44, 0x2, 0x2, 0x22d,
|
|
0x232, 0x5, 0x3c, 0x1f, 0x2, 0x22e, 0x22f, 0x7, 0x5b, 0x2, 0x2, 0x22f,
|
|
0x231, 0x5, 0x3c, 0x1f, 0x2, 0x230, 0x22e, 0x3, 0x2, 0x2, 0x2, 0x231,
|
|
0x234, 0x3, 0x2, 0x2, 0x2, 0x232, 0x230, 0x3, 0x2, 0x2, 0x2, 0x232,
|
|
0x233, 0x3, 0x2, 0x2, 0x2, 0x233, 0x236, 0x3, 0x2, 0x2, 0x2, 0x234,
|
|
0x232, 0x3, 0x2, 0x2, 0x2, 0x235, 0x22d, 0x3, 0x2, 0x2, 0x2, 0x235,
|
|
0x236, 0x3, 0x2, 0x2, 0x2, 0x236, 0x237, 0x3, 0x2, 0x2, 0x2, 0x237,
|
|
0x239, 0x7, 0x45, 0x2, 0x2, 0x238, 0x23a, 0x7, 0x6, 0x2, 0x2, 0x239,
|
|
0x238, 0x3, 0x2, 0x2, 0x2, 0x239, 0x23a, 0x3, 0x2, 0x2, 0x2, 0x23a,
|
|
0x23b, 0x3, 0x2, 0x2, 0x2, 0x23b, 0x23c, 0x7, 0x4b, 0x2, 0x2, 0x23c,
|
|
0x3f, 0x3, 0x2, 0x2, 0x2, 0x23d, 0x23e, 0x7, 0x40, 0x2, 0x2, 0x23e,
|
|
0x23f, 0x5, 0x1e, 0x10, 0x2, 0x23f, 0x242, 0x7, 0x1f, 0x2, 0x2, 0x240,
|
|
0x243, 0x7, 0x66, 0x2, 0x2, 0x241, 0x243, 0x5, 0x42, 0x22, 0x2, 0x242,
|
|
0x240, 0x3, 0x2, 0x2, 0x2, 0x242, 0x241, 0x3, 0x2, 0x2, 0x2, 0x243,
|
|
0x244, 0x3, 0x2, 0x2, 0x2, 0x244, 0x245, 0x7, 0x4b, 0x2, 0x2, 0x245,
|
|
0x41, 0x3, 0x2, 0x2, 0x2, 0x246, 0x247, 0x8, 0x22, 0x1, 0x2, 0x247,
|
|
0x24c, 0x5, 0x44, 0x23, 0x2, 0x248, 0x24c, 0x5, 0x46, 0x24, 0x2, 0x249,
|
|
0x24c, 0x5, 0x86, 0x44, 0x2, 0x24a, 0x24c, 0x5, 0x1e, 0x10, 0x2, 0x24b,
|
|
0x246, 0x3, 0x2, 0x2, 0x2, 0x24b, 0x248, 0x3, 0x2, 0x2, 0x2, 0x24b,
|
|
0x249, 0x3, 0x2, 0x2, 0x2, 0x24b, 0x24a, 0x3, 0x2, 0x2, 0x2, 0x24c,
|
|
0x255, 0x3, 0x2, 0x2, 0x2, 0x24d, 0x24e, 0xc, 0x3, 0x2, 0x2, 0x24e,
|
|
0x250, 0x7, 0x46, 0x2, 0x2, 0x24f, 0x251, 0x5, 0x4c, 0x27, 0x2, 0x250,
|
|
0x24f, 0x3, 0x2, 0x2, 0x2, 0x250, 0x251, 0x3, 0x2, 0x2, 0x2, 0x251,
|
|
0x252, 0x3, 0x2, 0x2, 0x2, 0x252, 0x254, 0x7, 0x47, 0x2, 0x2, 0x253,
|
|
0x24d, 0x3, 0x2, 0x2, 0x2, 0x254, 0x257, 0x3, 0x2, 0x2, 0x2, 0x255,
|
|
0x253, 0x3, 0x2, 0x2, 0x2, 0x255, 0x256, 0x3, 0x2, 0x2, 0x2, 0x256,
|
|
0x43, 0x3, 0x2, 0x2, 0x2, 0x257, 0x255, 0x3, 0x2, 0x2, 0x2, 0x258, 0x265,
|
|
0x7, 0x7, 0x2, 0x2, 0x259, 0x25a, 0x6, 0x23, 0x16, 0x3, 0x25a, 0x25b,
|
|
0x7, 0x7, 0x2, 0x2, 0x25b, 0x265, 0x7, 0x30, 0x2, 0x2, 0x25c, 0x265,
|
|
0x7, 0xa, 0x2, 0x2, 0x25d, 0x265, 0x7, 0x39, 0x2, 0x2, 0x25e, 0x265,
|
|
0x7, 0xc, 0x2, 0x2, 0x25f, 0x265, 0x7, 0x37, 0x2, 0x2, 0x260, 0x265,
|
|
0x7, 0x3f, 0x2, 0x2, 0x261, 0x265, 0x7, 0x1e, 0x2, 0x2, 0x262, 0x265,
|
|
0x7, 0x1c, 0x2, 0x2, 0x263, 0x265, 0x7, 0x3e, 0x2, 0x2, 0x264, 0x258,
|
|
0x3, 0x2, 0x2, 0x2, 0x264, 0x259, 0x3, 0x2, 0x2, 0x2, 0x264, 0x25c,
|
|
0x3, 0x2, 0x2, 0x2, 0x264, 0x25d, 0x3, 0x2, 0x2, 0x2, 0x264, 0x25e,
|
|
0x3, 0x2, 0x2, 0x2, 0x264, 0x25f, 0x3, 0x2, 0x2, 0x2, 0x264, 0x260,
|
|
0x3, 0x2, 0x2, 0x2, 0x264, 0x261, 0x3, 0x2, 0x2, 0x2, 0x264, 0x262,
|
|
0x3, 0x2, 0x2, 0x2, 0x264, 0x263, 0x3, 0x2, 0x2, 0x2, 0x265, 0x45, 0x3,
|
|
0x2, 0x2, 0x2, 0x266, 0x267, 0x7, 0x20, 0x2, 0x2, 0x267, 0x269, 0x7,
|
|
0x44, 0x2, 0x2, 0x268, 0x26a, 0x5, 0x24, 0x13, 0x2, 0x269, 0x268, 0x3,
|
|
0x2, 0x2, 0x2, 0x269, 0x26a, 0x3, 0x2, 0x2, 0x2, 0x26a, 0x26b, 0x3,
|
|
0x2, 0x2, 0x2, 0x26b, 0x276, 0x7, 0x45, 0x2, 0x2, 0x26c, 0x26d, 0x6,
|
|
0x24, 0x17, 0x3, 0x26d, 0x26e, 0x5, 0x22, 0x12, 0x2, 0x26e, 0x26f, 0x8,
|
|
0x24, 0x1, 0x2, 0x26f, 0x275, 0x3, 0x2, 0x2, 0x2, 0x270, 0x271, 0x6,
|
|
0x24, 0x18, 0x3, 0x271, 0x272, 0x5, 0x2a, 0x16, 0x2, 0x272, 0x273, 0x8,
|
|
0x24, 0x1, 0x2, 0x273, 0x275, 0x3, 0x2, 0x2, 0x2, 0x274, 0x26c, 0x3,
|
|
0x2, 0x2, 0x2, 0x274, 0x270, 0x3, 0x2, 0x2, 0x2, 0x275, 0x278, 0x3,
|
|
0x2, 0x2, 0x2, 0x276, 0x274, 0x3, 0x2, 0x2, 0x2, 0x276, 0x277, 0x3,
|
|
0x2, 0x2, 0x2, 0x277, 0x27e, 0x3, 0x2, 0x2, 0x2, 0x278, 0x276, 0x3,
|
|
0x2, 0x2, 0x2, 0x279, 0x27a, 0x7, 0x36, 0x2, 0x2, 0x27a, 0x27b, 0x7,
|
|
0x44, 0x2, 0x2, 0x27b, 0x27c, 0x5, 0x24, 0x13, 0x2, 0x27c, 0x27d, 0x7,
|
|
0x45, 0x2, 0x2, 0x27d, 0x27f, 0x3, 0x2, 0x2, 0x2, 0x27e, 0x279, 0x3,
|
|
0x2, 0x2, 0x2, 0x27e, 0x27f, 0x3, 0x2, 0x2, 0x2, 0x27f, 0x47, 0x3, 0x2,
|
|
0x2, 0x2, 0x280, 0x282, 0x5, 0x42, 0x22, 0x2, 0x281, 0x283, 0x5, 0x4a,
|
|
0x26, 0x2, 0x282, 0x281, 0x3, 0x2, 0x2, 0x2, 0x282, 0x283, 0x3, 0x2,
|
|
0x2, 0x2, 0x283, 0x284, 0x3, 0x2, 0x2, 0x2, 0x284, 0x285, 0x5, 0x54,
|
|
0x2b, 0x2, 0x285, 0x49, 0x3, 0x2, 0x2, 0x2, 0x286, 0x287, 0x9, 0x5,
|
|
0x2, 0x2, 0x287, 0x4b, 0x3, 0x2, 0x2, 0x2, 0x288, 0x289, 0x8, 0x27,
|
|
0x1, 0x2, 0x289, 0x28a, 0x7, 0x30, 0x2, 0x2, 0x28a, 0x29d, 0x5, 0x1c,
|
|
0xf, 0x2, 0x28b, 0x28c, 0x7, 0x3d, 0x2, 0x2, 0x28c, 0x28d, 0x7, 0x44,
|
|
0x2, 0x2, 0x28d, 0x28e, 0x5, 0x42, 0x22, 0x2, 0x28e, 0x28f, 0x7, 0x45,
|
|
0x2, 0x2, 0x28f, 0x29d, 0x3, 0x2, 0x2, 0x2, 0x290, 0x291, 0x9, 0x6,
|
|
0x2, 0x2, 0x291, 0x29d, 0x5, 0x4c, 0x27, 0x15, 0x292, 0x293, 0x7, 0x2d,
|
|
0x2, 0x2, 0x293, 0x29d, 0x5, 0x42, 0x22, 0x2, 0x294, 0x29d, 0x5, 0x50,
|
|
0x29, 0x2, 0x295, 0x29d, 0x5, 0x52, 0x2a, 0x2, 0x296, 0x29b, 0x5, 0x54,
|
|
0x2b, 0x2, 0x297, 0x29b, 0x5, 0x56, 0x2c, 0x2, 0x298, 0x29b, 0x5, 0x44,
|
|
0x23, 0x2, 0x299, 0x29b, 0x5, 0x1e, 0x10, 0x2, 0x29a, 0x296, 0x3, 0x2,
|
|
0x2, 0x2, 0x29a, 0x297, 0x3, 0x2, 0x2, 0x2, 0x29a, 0x298, 0x3, 0x2,
|
|
0x2, 0x2, 0x29a, 0x299, 0x3, 0x2, 0x2, 0x2, 0x29b, 0x29d, 0x3, 0x2,
|
|
0x2, 0x2, 0x29c, 0x288, 0x3, 0x2, 0x2, 0x2, 0x29c, 0x28b, 0x3, 0x2,
|
|
0x2, 0x2, 0x29c, 0x290, 0x3, 0x2, 0x2, 0x2, 0x29c, 0x292, 0x3, 0x2,
|
|
0x2, 0x2, 0x29c, 0x294, 0x3, 0x2, 0x2, 0x2, 0x29c, 0x295, 0x3, 0x2,
|
|
0x2, 0x2, 0x29c, 0x29a, 0x3, 0x2, 0x2, 0x2, 0x29d, 0x2f2, 0x3, 0x2,
|
|
0x2, 0x2, 0x29e, 0x29f, 0xc, 0x13, 0x2, 0x2, 0x29f, 0x2a0, 0x7, 0x69,
|
|
0x2, 0x2, 0x2a0, 0x2f1, 0x5, 0x4c, 0x27, 0x13, 0x2a1, 0x2a2, 0xc, 0x12,
|
|
0x2, 0x2, 0x2a2, 0x2a3, 0x9, 0x7, 0x2, 0x2, 0x2a3, 0x2f1, 0x5, 0x4c,
|
|
0x27, 0x13, 0x2a4, 0x2a5, 0xc, 0x11, 0x2, 0x2, 0x2a5, 0x2a6, 0x9, 0x8,
|
|
0x2, 0x2, 0x2a6, 0x2f1, 0x5, 0x4c, 0x27, 0x12, 0x2a7, 0x2a8, 0xc, 0x10,
|
|
0x2, 0x2, 0x2a8, 0x2a9, 0x9, 0x9, 0x2, 0x2, 0x2a9, 0x2f1, 0x5, 0x4c,
|
|
0x27, 0x11, 0x2aa, 0x2ab, 0xc, 0xf, 0x2, 0x2, 0x2ab, 0x2ac, 0x7, 0x60,
|
|
0x2, 0x2, 0x2ac, 0x2f1, 0x5, 0x4c, 0x27, 0x10, 0x2ad, 0x2ae, 0xc, 0xe,
|
|
0x2, 0x2, 0x2ae, 0x2af, 0x7, 0x5f, 0x2, 0x2, 0x2af, 0x2f1, 0x5, 0x4c,
|
|
0x27, 0xf, 0x2b0, 0x2b1, 0xc, 0xd, 0x2, 0x2, 0x2b1, 0x2b2, 0x7, 0x5e,
|
|
0x2, 0x2, 0x2b2, 0x2f1, 0x5, 0x4c, 0x27, 0xe, 0x2b3, 0x2b4, 0xc, 0xc,
|
|
0x2, 0x2, 0x2b4, 0x2b5, 0x9, 0xa, 0x2, 0x2, 0x2b5, 0x2f1, 0x5, 0x4c,
|
|
0x27, 0xd, 0x2b6, 0x2b7, 0xc, 0xb, 0x2, 0x2, 0x2b7, 0x2b8, 0x9, 0xb,
|
|
0x2, 0x2, 0x2b8, 0x2f1, 0x5, 0x4c, 0x27, 0xc, 0x2b9, 0x2ba, 0xc, 0xa,
|
|
0x2, 0x2, 0x2ba, 0x2bb, 0x7, 0x5d, 0x2, 0x2, 0x2bb, 0x2f1, 0x5, 0x4c,
|
|
0x27, 0xb, 0x2bc, 0x2bd, 0xc, 0x9, 0x2, 0x2, 0x2bd, 0x2be, 0x7, 0x5c,
|
|
0x2, 0x2, 0x2be, 0x2f1, 0x5, 0x4c, 0x27, 0xa, 0x2bf, 0x2c0, 0xc, 0x8,
|
|
0x2, 0x2, 0x2c0, 0x2c1, 0x7, 0x4d, 0x2, 0x2, 0x2c1, 0x2c2, 0x5, 0x4c,
|
|
0x27, 0x2, 0x2c2, 0x2c3, 0x7, 0x4a, 0x2, 0x2, 0x2c3, 0x2c4, 0x5, 0x4c,
|
|
0x27, 0x8, 0x2c4, 0x2f1, 0x3, 0x2, 0x2, 0x2, 0x2c5, 0x2c6, 0xc, 0x7,
|
|
0x2, 0x2, 0x2c6, 0x2c7, 0x5, 0x4e, 0x28, 0x2, 0x2c7, 0x2c8, 0x5, 0x4c,
|
|
0x27, 0x7, 0x2c8, 0x2f1, 0x3, 0x2, 0x2, 0x2, 0x2c9, 0x2ca, 0xc, 0x1c,
|
|
0x2, 0x2, 0x2ca, 0x2cc, 0x7, 0x46, 0x2, 0x2, 0x2cb, 0x2cd, 0x5, 0x4c,
|
|
0x27, 0x2, 0x2cc, 0x2cb, 0x3, 0x2, 0x2, 0x2, 0x2cc, 0x2cd, 0x3, 0x2,
|
|
0x2, 0x2, 0x2cd, 0x2ce, 0x3, 0x2, 0x2, 0x2, 0x2ce, 0x2f1, 0x7, 0x47,
|
|
0x2, 0x2, 0x2cf, 0x2d0, 0xc, 0x1b, 0x2, 0x2, 0x2d0, 0x2d2, 0x7, 0x46,
|
|
0x2, 0x2, 0x2d1, 0x2d3, 0x5, 0x4c, 0x27, 0x2, 0x2d2, 0x2d1, 0x3, 0x2,
|
|
0x2, 0x2, 0x2d2, 0x2d3, 0x3, 0x2, 0x2, 0x2, 0x2d3, 0x2d4, 0x3, 0x2,
|
|
0x2, 0x2, 0x2d4, 0x2d6, 0x7, 0x4a, 0x2, 0x2, 0x2d5, 0x2d7, 0x5, 0x4c,
|
|
0x27, 0x2, 0x2d6, 0x2d5, 0x3, 0x2, 0x2, 0x2, 0x2d6, 0x2d7, 0x3, 0x2,
|
|
0x2, 0x2, 0x2d7, 0x2d8, 0x3, 0x2, 0x2, 0x2, 0x2d8, 0x2f1, 0x7, 0x47,
|
|
0x2, 0x2, 0x2d9, 0x2da, 0xc, 0x1a, 0x2, 0x2, 0x2da, 0x2dd, 0x7, 0x4c,
|
|
0x2, 0x2, 0x2db, 0x2de, 0x5, 0x54, 0x2b, 0x2, 0x2dc, 0x2de, 0x7, 0x7,
|
|
0x2, 0x2, 0x2dd, 0x2db, 0x3, 0x2, 0x2, 0x2, 0x2dd, 0x2dc, 0x3, 0x2,
|
|
0x2, 0x2, 0x2de, 0x2f1, 0x3, 0x2, 0x2, 0x2, 0x2df, 0x2e0, 0xc, 0x19,
|
|
0x2, 0x2, 0x2e0, 0x2e9, 0x7, 0x48, 0x2, 0x2, 0x2e1, 0x2e6, 0x5, 0x1a,
|
|
0xe, 0x2, 0x2e2, 0x2e3, 0x7, 0x5b, 0x2, 0x2, 0x2e3, 0x2e5, 0x5, 0x1a,
|
|
0xe, 0x2, 0x2e4, 0x2e2, 0x3, 0x2, 0x2, 0x2, 0x2e5, 0x2e8, 0x3, 0x2,
|
|
0x2, 0x2, 0x2e6, 0x2e4, 0x3, 0x2, 0x2, 0x2, 0x2e6, 0x2e7, 0x3, 0x2,
|
|
0x2, 0x2, 0x2e7, 0x2ea, 0x3, 0x2, 0x2, 0x2, 0x2e8, 0x2e6, 0x3, 0x2,
|
|
0x2, 0x2, 0x2e9, 0x2e1, 0x3, 0x2, 0x2, 0x2, 0x2e9, 0x2ea, 0x3, 0x2,
|
|
0x2, 0x2, 0x2ea, 0x2eb, 0x3, 0x2, 0x2, 0x2, 0x2eb, 0x2f1, 0x7, 0x49,
|
|
0x2, 0x2, 0x2ec, 0x2ed, 0xc, 0x18, 0x2, 0x2, 0x2ed, 0x2f1, 0x5, 0x1c,
|
|
0xf, 0x2, 0x2ee, 0x2ef, 0xc, 0x14, 0x2, 0x2, 0x2ef, 0x2f1, 0x9, 0xc,
|
|
0x2, 0x2, 0x2f0, 0x29e, 0x3, 0x2, 0x2, 0x2, 0x2f0, 0x2a1, 0x3, 0x2,
|
|
0x2, 0x2, 0x2f0, 0x2a4, 0x3, 0x2, 0x2, 0x2, 0x2f0, 0x2a7, 0x3, 0x2,
|
|
0x2, 0x2, 0x2f0, 0x2aa, 0x3, 0x2, 0x2, 0x2, 0x2f0, 0x2ad, 0x3, 0x2,
|
|
0x2, 0x2, 0x2f0, 0x2b0, 0x3, 0x2, 0x2, 0x2, 0x2f0, 0x2b3, 0x3, 0x2,
|
|
0x2, 0x2, 0x2f0, 0x2b6, 0x3, 0x2, 0x2, 0x2, 0x2f0, 0x2b9, 0x3, 0x2,
|
|
0x2, 0x2, 0x2f0, 0x2bc, 0x3, 0x2, 0x2, 0x2, 0x2f0, 0x2bf, 0x3, 0x2,
|
|
0x2, 0x2, 0x2f0, 0x2c5, 0x3, 0x2, 0x2, 0x2, 0x2f0, 0x2c9, 0x3, 0x2,
|
|
0x2, 0x2, 0x2f0, 0x2cf, 0x3, 0x2, 0x2, 0x2, 0x2f0, 0x2d9, 0x3, 0x2,
|
|
0x2, 0x2, 0x2f0, 0x2df, 0x3, 0x2, 0x2, 0x2, 0x2f0, 0x2ec, 0x3, 0x2,
|
|
0x2, 0x2, 0x2f0, 0x2ee, 0x3, 0x2, 0x2, 0x2, 0x2f1, 0x2f4, 0x3, 0x2,
|
|
0x2, 0x2, 0x2f2, 0x2f0, 0x3, 0x2, 0x2, 0x2, 0x2f2, 0x2f3, 0x3, 0x2,
|
|
0x2, 0x2, 0x2f3, 0x4d, 0x3, 0x2, 0x2, 0x2, 0x2f4, 0x2f2, 0x3, 0x2, 0x2,
|
|
0x2, 0x2f5, 0x2f6, 0x9, 0xd, 0x2, 0x2, 0x2f6, 0x4f, 0x3, 0x2, 0x2, 0x2,
|
|
0x2f7, 0x2f9, 0x7, 0x44, 0x2, 0x2, 0x2f8, 0x2fa, 0x5, 0x4c, 0x27, 0x2,
|
|
0x2f9, 0x2f8, 0x3, 0x2, 0x2, 0x2, 0x2f9, 0x2fa, 0x3, 0x2, 0x2, 0x2,
|
|
0x2fa, 0x301, 0x3, 0x2, 0x2, 0x2, 0x2fb, 0x2fd, 0x7, 0x5b, 0x2, 0x2,
|
|
0x2fc, 0x2fe, 0x5, 0x4c, 0x27, 0x2, 0x2fd, 0x2fc, 0x3, 0x2, 0x2, 0x2,
|
|
0x2fd, 0x2fe, 0x3, 0x2, 0x2, 0x2, 0x2fe, 0x300, 0x3, 0x2, 0x2, 0x2,
|
|
0x2ff, 0x2fb, 0x3, 0x2, 0x2, 0x2, 0x300, 0x303, 0x3, 0x2, 0x2, 0x2,
|
|
0x301, 0x2ff, 0x3, 0x2, 0x2, 0x2, 0x301, 0x302, 0x3, 0x2, 0x2, 0x2,
|
|
0x302, 0x304, 0x3, 0x2, 0x2, 0x2, 0x303, 0x301, 0x3, 0x2, 0x2, 0x2,
|
|
0x304, 0x305, 0x7, 0x45, 0x2, 0x2, 0x305, 0x51, 0x3, 0x2, 0x2, 0x2,
|
|
0x306, 0x307, 0x7, 0x46, 0x2, 0x2, 0x307, 0x30c, 0x5, 0x4c, 0x27, 0x2,
|
|
0x308, 0x309, 0x7, 0x5b, 0x2, 0x2, 0x309, 0x30b, 0x5, 0x4c, 0x27, 0x2,
|
|
0x30a, 0x308, 0x3, 0x2, 0x2, 0x2, 0x30b, 0x30e, 0x3, 0x2, 0x2, 0x2,
|
|
0x30c, 0x30a, 0x3, 0x2, 0x2, 0x2, 0x30c, 0x30d, 0x3, 0x2, 0x2, 0x2,
|
|
0x30d, 0x30f, 0x3, 0x2, 0x2, 0x2, 0x30e, 0x30c, 0x3, 0x2, 0x2, 0x2,
|
|
0x30f, 0x310, 0x7, 0x47, 0x2, 0x2, 0x310, 0x53, 0x3, 0x2, 0x2, 0x2,
|
|
0x311, 0x312, 0x9, 0xe, 0x2, 0x2, 0x312, 0x55, 0x3, 0x2, 0x2, 0x2, 0x313,
|
|
0x319, 0x5, 0x5a, 0x2e, 0x2, 0x314, 0x319, 0x5, 0x60, 0x31, 0x2, 0x315,
|
|
0x319, 0x5, 0x58, 0x2d, 0x2, 0x316, 0x319, 0x5, 0x5c, 0x2f, 0x2, 0x317,
|
|
0x319, 0x5, 0x5e, 0x30, 0x2, 0x318, 0x313, 0x3, 0x2, 0x2, 0x2, 0x318,
|
|
0x314, 0x3, 0x2, 0x2, 0x2, 0x318, 0x315, 0x3, 0x2, 0x2, 0x2, 0x318,
|
|
0x316, 0x3, 0x2, 0x2, 0x2, 0x318, 0x317, 0x3, 0x2, 0x2, 0x2, 0x319,
|
|
0x57, 0x3, 0x2, 0x2, 0x2, 0x31a, 0x31b, 0x9, 0xf, 0x2, 0x2, 0x31b, 0x59,
|
|
0x3, 0x2, 0x2, 0x2, 0x31c, 0x31e, 0x7, 0x74, 0x2, 0x2, 0x31d, 0x31c,
|
|
0x3, 0x2, 0x2, 0x2, 0x31e, 0x31f, 0x3, 0x2, 0x2, 0x2, 0x31f, 0x31d,
|
|
0x3, 0x2, 0x2, 0x2, 0x31f, 0x320, 0x3, 0x2, 0x2, 0x2, 0x320, 0x5b, 0x3,
|
|
0x2, 0x2, 0x2, 0x321, 0x323, 0x7, 0x77, 0x2, 0x2, 0x322, 0x321, 0x3,
|
|
0x2, 0x2, 0x2, 0x323, 0x324, 0x3, 0x2, 0x2, 0x2, 0x324, 0x322, 0x3,
|
|
0x2, 0x2, 0x2, 0x324, 0x325, 0x3, 0x2, 0x2, 0x2, 0x325, 0x5d, 0x3, 0x2,
|
|
0x2, 0x2, 0x326, 0x328, 0x7, 0x76, 0x2, 0x2, 0x327, 0x326, 0x3, 0x2,
|
|
0x2, 0x2, 0x328, 0x329, 0x3, 0x2, 0x2, 0x2, 0x329, 0x327, 0x3, 0x2,
|
|
0x2, 0x2, 0x329, 0x32a, 0x3, 0x2, 0x2, 0x2, 0x32a, 0x5f, 0x3, 0x2, 0x2,
|
|
0x2, 0x32b, 0x32d, 0x9, 0x10, 0x2, 0x2, 0x32c, 0x32e, 0x7, 0x2e, 0x2,
|
|
0x2, 0x32d, 0x32c, 0x3, 0x2, 0x2, 0x2, 0x32d, 0x32e, 0x3, 0x2, 0x2,
|
|
0x2, 0x32e, 0x61, 0x3, 0x2, 0x2, 0x2, 0x32f, 0x333, 0x7, 0x48, 0x2,
|
|
0x2, 0x330, 0x332, 0x5, 0x64, 0x33, 0x2, 0x331, 0x330, 0x3, 0x2, 0x2,
|
|
0x2, 0x332, 0x335, 0x3, 0x2, 0x2, 0x2, 0x333, 0x331, 0x3, 0x2, 0x2,
|
|
0x2, 0x333, 0x334, 0x3, 0x2, 0x2, 0x2, 0x334, 0x336, 0x3, 0x2, 0x2,
|
|
0x2, 0x335, 0x333, 0x3, 0x2, 0x2, 0x2, 0x336, 0x337, 0x7, 0x49, 0x2,
|
|
0x2, 0x337, 0x63, 0x3, 0x2, 0x2, 0x2, 0x338, 0x345, 0x5, 0x62, 0x32,
|
|
0x2, 0x339, 0x345, 0x5, 0x66, 0x34, 0x2, 0x33a, 0x345, 0x5, 0x68, 0x35,
|
|
0x2, 0x33b, 0x345, 0x5, 0x6a, 0x36, 0x2, 0x33c, 0x345, 0x5, 0x6c, 0x37,
|
|
0x2, 0x33d, 0x345, 0x5, 0x6e, 0x38, 0x2, 0x33e, 0x345, 0x5, 0x70, 0x39,
|
|
0x2, 0x33f, 0x345, 0x5, 0x72, 0x3a, 0x2, 0x340, 0x345, 0x5, 0x74, 0x3b,
|
|
0x2, 0x341, 0x345, 0x5, 0x78, 0x3d, 0x2, 0x342, 0x345, 0x5, 0x7a, 0x3e,
|
|
0x2, 0x343, 0x345, 0x5, 0x7c, 0x3f, 0x2, 0x344, 0x338, 0x3, 0x2, 0x2,
|
|
0x2, 0x344, 0x339, 0x3, 0x2, 0x2, 0x2, 0x344, 0x33a, 0x3, 0x2, 0x2,
|
|
0x2, 0x344, 0x33b, 0x3, 0x2, 0x2, 0x2, 0x344, 0x33c, 0x3, 0x2, 0x2,
|
|
0x2, 0x344, 0x33d, 0x3, 0x2, 0x2, 0x2, 0x344, 0x33e, 0x3, 0x2, 0x2,
|
|
0x2, 0x344, 0x33f, 0x3, 0x2, 0x2, 0x2, 0x344, 0x340, 0x3, 0x2, 0x2,
|
|
0x2, 0x344, 0x341, 0x3, 0x2, 0x2, 0x2, 0x344, 0x342, 0x3, 0x2, 0x2,
|
|
0x2, 0x344, 0x343, 0x3, 0x2, 0x2, 0x2, 0x345, 0x65, 0x3, 0x2, 0x2, 0x2,
|
|
0x346, 0x349, 0x5, 0x82, 0x42, 0x2, 0x347, 0x349, 0x5, 0x84, 0x43, 0x2,
|
|
0x348, 0x346, 0x3, 0x2, 0x2, 0x2, 0x348, 0x347, 0x3, 0x2, 0x2, 0x2,
|
|
0x349, 0x67, 0x3, 0x2, 0x2, 0x2, 0x34a, 0x34b, 0x7, 0x22, 0x2, 0x2,
|
|
0x34b, 0x34c, 0x7, 0x44, 0x2, 0x2, 0x34c, 0x34d, 0x5, 0x4c, 0x27, 0x2,
|
|
0x34d, 0x34e, 0x7, 0x45, 0x2, 0x2, 0x34e, 0x351, 0x5, 0x64, 0x33, 0x2,
|
|
0x34f, 0x350, 0x7, 0x15, 0x2, 0x2, 0x350, 0x352, 0x5, 0x64, 0x33, 0x2,
|
|
0x351, 0x34f, 0x3, 0x2, 0x2, 0x2, 0x351, 0x352, 0x3, 0x2, 0x2, 0x2,
|
|
0x352, 0x69, 0x3, 0x2, 0x2, 0x2, 0x353, 0x354, 0x7, 0x1f, 0x2, 0x2,
|
|
0x354, 0x357, 0x7, 0x44, 0x2, 0x2, 0x355, 0x358, 0x5, 0x66, 0x34, 0x2,
|
|
0x356, 0x358, 0x7, 0x4b, 0x2, 0x2, 0x357, 0x355, 0x3, 0x2, 0x2, 0x2,
|
|
0x357, 0x356, 0x3, 0x2, 0x2, 0x2, 0x358, 0x35b, 0x3, 0x2, 0x2, 0x2,
|
|
0x359, 0x35c, 0x5, 0x84, 0x43, 0x2, 0x35a, 0x35c, 0x7, 0x4b, 0x2, 0x2,
|
|
0x35b, 0x359, 0x3, 0x2, 0x2, 0x2, 0x35b, 0x35a, 0x3, 0x2, 0x2, 0x2,
|
|
0x35c, 0x35e, 0x3, 0x2, 0x2, 0x2, 0x35d, 0x35f, 0x5, 0x4c, 0x27, 0x2,
|
|
0x35e, 0x35d, 0x3, 0x2, 0x2, 0x2, 0x35e, 0x35f, 0x3, 0x2, 0x2, 0x2,
|
|
0x35f, 0x360, 0x3, 0x2, 0x2, 0x2, 0x360, 0x361, 0x7, 0x45, 0x2, 0x2,
|
|
0x361, 0x362, 0x5, 0x64, 0x33, 0x2, 0x362, 0x6b, 0x3, 0x2, 0x2, 0x2,
|
|
0x363, 0x364, 0x7, 0x43, 0x2, 0x2, 0x364, 0x365, 0x7, 0x44, 0x2, 0x2,
|
|
0x365, 0x366, 0x5, 0x4c, 0x27, 0x2, 0x366, 0x367, 0x7, 0x45, 0x2, 0x2,
|
|
0x367, 0x368, 0x5, 0x64, 0x33, 0x2, 0x368, 0x6d, 0x3, 0x2, 0x2, 0x2,
|
|
0x369, 0x36a, 0x7, 0x14, 0x2, 0x2, 0x36a, 0x36b, 0x5, 0x64, 0x33, 0x2,
|
|
0x36b, 0x36c, 0x7, 0x43, 0x2, 0x2, 0x36c, 0x36d, 0x7, 0x44, 0x2, 0x2,
|
|
0x36d, 0x36e, 0x5, 0x4c, 0x27, 0x2, 0x36e, 0x36f, 0x7, 0x45, 0x2, 0x2,
|
|
0x36f, 0x370, 0x7, 0x4b, 0x2, 0x2, 0x370, 0x6f, 0x3, 0x2, 0x2, 0x2,
|
|
0x371, 0x372, 0x7, 0x11, 0x2, 0x2, 0x372, 0x373, 0x7, 0x4b, 0x2, 0x2,
|
|
0x373, 0x71, 0x3, 0x2, 0x2, 0x2, 0x374, 0x375, 0x7, 0xb, 0x2, 0x2, 0x375,
|
|
0x376, 0x7, 0x4b, 0x2, 0x2, 0x376, 0x73, 0x3, 0x2, 0x2, 0x2, 0x377,
|
|
0x378, 0x7, 0x3c, 0x2, 0x2, 0x378, 0x37e, 0x5, 0x4c, 0x27, 0x2, 0x379,
|
|
0x37a, 0x7, 0x36, 0x2, 0x2, 0x37a, 0x37b, 0x7, 0x44, 0x2, 0x2, 0x37b,
|
|
0x37c, 0x5, 0x24, 0x13, 0x2, 0x37c, 0x37d, 0x7, 0x45, 0x2, 0x2, 0x37d,
|
|
0x37f, 0x3, 0x2, 0x2, 0x2, 0x37e, 0x379, 0x3, 0x2, 0x2, 0x2, 0x37e,
|
|
0x37f, 0x3, 0x2, 0x2, 0x2, 0x37f, 0x380, 0x3, 0x2, 0x2, 0x2, 0x380,
|
|
0x382, 0x5, 0x62, 0x32, 0x2, 0x381, 0x383, 0x5, 0x76, 0x3c, 0x2, 0x382,
|
|
0x381, 0x3, 0x2, 0x2, 0x2, 0x383, 0x384, 0x3, 0x2, 0x2, 0x2, 0x384,
|
|
0x382, 0x3, 0x2, 0x2, 0x2, 0x384, 0x385, 0x3, 0x2, 0x2, 0x2, 0x385,
|
|
0x75, 0x3, 0x2, 0x2, 0x2, 0x386, 0x38e, 0x7, 0xe, 0x2, 0x2, 0x387, 0x389,
|
|
0x5, 0x54, 0x2b, 0x2, 0x388, 0x387, 0x3, 0x2, 0x2, 0x2, 0x388, 0x389,
|
|
0x3, 0x2, 0x2, 0x2, 0x389, 0x38a, 0x3, 0x2, 0x2, 0x2, 0x38a, 0x38b,
|
|
0x7, 0x44, 0x2, 0x2, 0x38b, 0x38c, 0x5, 0x24, 0x13, 0x2, 0x38c, 0x38d,
|
|
0x7, 0x45, 0x2, 0x2, 0x38d, 0x38f, 0x3, 0x2, 0x2, 0x2, 0x38e, 0x388,
|
|
0x3, 0x2, 0x2, 0x2, 0x38e, 0x38f, 0x3, 0x2, 0x2, 0x2, 0x38f, 0x390,
|
|
0x3, 0x2, 0x2, 0x2, 0x390, 0x391, 0x5, 0x62, 0x32, 0x2, 0x391, 0x77,
|
|
0x3, 0x2, 0x2, 0x2, 0x392, 0x394, 0x7, 0x35, 0x2, 0x2, 0x393, 0x395,
|
|
0x5, 0x4c, 0x27, 0x2, 0x394, 0x393, 0x3, 0x2, 0x2, 0x2, 0x394, 0x395,
|
|
0x3, 0x2, 0x2, 0x2, 0x395, 0x396, 0x3, 0x2, 0x2, 0x2, 0x396, 0x397,
|
|
0x7, 0x4b, 0x2, 0x2, 0x397, 0x79, 0x3, 0x2, 0x2, 0x2, 0x398, 0x399,
|
|
0x7, 0x16, 0x2, 0x2, 0x399, 0x39a, 0x5, 0x4c, 0x27, 0x2, 0x39a, 0x39b,
|
|
0x5, 0x1c, 0xf, 0x2, 0x39b, 0x39c, 0x7, 0x4b, 0x2, 0x2, 0x39c, 0x7b,
|
|
0x3, 0x2, 0x2, 0x2, 0x39d, 0x39f, 0x7, 0x9, 0x2, 0x2, 0x39e, 0x3a0,
|
|
0x7, 0x7e, 0x2, 0x2, 0x39f, 0x39e, 0x3, 0x2, 0x2, 0x2, 0x39f, 0x3a0,
|
|
0x3, 0x2, 0x2, 0x2, 0x3a0, 0x3a1, 0x3, 0x2, 0x2, 0x2, 0x3a1, 0x3a5,
|
|
0x7, 0x7f, 0x2, 0x2, 0x3a2, 0x3a4, 0x5, 0x8a, 0x46, 0x2, 0x3a3, 0x3a2,
|
|
0x3, 0x2, 0x2, 0x2, 0x3a4, 0x3a7, 0x3, 0x2, 0x2, 0x2, 0x3a5, 0x3a3,
|
|
0x3, 0x2, 0x2, 0x2, 0x3a5, 0x3a6, 0x3, 0x2, 0x2, 0x2, 0x3a6, 0x3a8,
|
|
0x3, 0x2, 0x2, 0x2, 0x3a7, 0x3a5, 0x3, 0x2, 0x2, 0x2, 0x3a8, 0x3a9,
|
|
0x7, 0x91, 0x2, 0x2, 0x3a9, 0x7d, 0x3, 0x2, 0x2, 0x2, 0x3aa, 0x3af,
|
|
0x5, 0x48, 0x25, 0x2, 0x3ab, 0x3ac, 0x7, 0x5b, 0x2, 0x2, 0x3ac, 0x3ae,
|
|
0x5, 0x48, 0x25, 0x2, 0x3ad, 0x3ab, 0x3, 0x2, 0x2, 0x2, 0x3ae, 0x3b1,
|
|
0x3, 0x2, 0x2, 0x2, 0x3af, 0x3ad, 0x3, 0x2, 0x2, 0x2, 0x3af, 0x3b0,
|
|
0x3, 0x2, 0x2, 0x2, 0x3b0, 0x7f, 0x3, 0x2, 0x2, 0x2, 0x3b1, 0x3af, 0x3,
|
|
0x2, 0x2, 0x2, 0x3b2, 0x3b6, 0x7, 0x44, 0x2, 0x2, 0x3b3, 0x3b5, 0x7,
|
|
0x5b, 0x2, 0x2, 0x3b4, 0x3b3, 0x3, 0x2, 0x2, 0x2, 0x3b5, 0x3b8, 0x3,
|
|
0x2, 0x2, 0x2, 0x3b6, 0x3b4, 0x3, 0x2, 0x2, 0x2, 0x3b6, 0x3b7, 0x3,
|
|
0x2, 0x2, 0x2, 0x3b7, 0x3b9, 0x3, 0x2, 0x2, 0x2, 0x3b8, 0x3b6, 0x3,
|
|
0x2, 0x2, 0x2, 0x3b9, 0x3ba, 0x5, 0x48, 0x25, 0x2, 0x3ba, 0x3c1, 0x3,
|
|
0x2, 0x2, 0x2, 0x3bb, 0x3bd, 0x7, 0x5b, 0x2, 0x2, 0x3bc, 0x3be, 0x5,
|
|
0x48, 0x25, 0x2, 0x3bd, 0x3bc, 0x3, 0x2, 0x2, 0x2, 0x3bd, 0x3be, 0x3,
|
|
0x2, 0x2, 0x2, 0x3be, 0x3c0, 0x3, 0x2, 0x2, 0x2, 0x3bf, 0x3bb, 0x3,
|
|
0x2, 0x2, 0x2, 0x3c0, 0x3c3, 0x3, 0x2, 0x2, 0x2, 0x3c1, 0x3bf, 0x3,
|
|
0x2, 0x2, 0x2, 0x3c1, 0x3c2, 0x3, 0x2, 0x2, 0x2, 0x3c2, 0x3c4, 0x3,
|
|
0x2, 0x2, 0x2, 0x3c3, 0x3c1, 0x3, 0x2, 0x2, 0x2, 0x3c4, 0x3c5, 0x7,
|
|
0x45, 0x2, 0x2, 0x3c5, 0x81, 0x3, 0x2, 0x2, 0x2, 0x3c6, 0x3c9, 0x5,
|
|
0x48, 0x25, 0x2, 0x3c7, 0x3c8, 0x7, 0x4f, 0x2, 0x2, 0x3c8, 0x3ca, 0x5,
|
|
0x4c, 0x27, 0x2, 0x3c9, 0x3c7, 0x3, 0x2, 0x2, 0x2, 0x3c9, 0x3ca, 0x3,
|
|
0x2, 0x2, 0x2, 0x3ca, 0x3d0, 0x3, 0x2, 0x2, 0x2, 0x3cb, 0x3cc, 0x5,
|
|
0x80, 0x41, 0x2, 0x3cc, 0x3cd, 0x7, 0x4f, 0x2, 0x2, 0x3cd, 0x3ce, 0x5,
|
|
0x4c, 0x27, 0x2, 0x3ce, 0x3d0, 0x3, 0x2, 0x2, 0x2, 0x3cf, 0x3c6, 0x3,
|
|
0x2, 0x2, 0x2, 0x3cf, 0x3cb, 0x3, 0x2, 0x2, 0x2, 0x3d0, 0x3d1, 0x3,
|
|
0x2, 0x2, 0x2, 0x3d1, 0x3d2, 0x7, 0x4b, 0x2, 0x2, 0x3d2, 0x83, 0x3,
|
|
0x2, 0x2, 0x2, 0x3d3, 0x3d4, 0x5, 0x4c, 0x27, 0x2, 0x3d4, 0x3d5, 0x7,
|
|
0x4b, 0x2, 0x2, 0x3d5, 0x85, 0x3, 0x2, 0x2, 0x2, 0x3d6, 0x3d7, 0x7,
|
|
0x2a, 0x2, 0x2, 0x3d7, 0x3d8, 0x7, 0x44, 0x2, 0x2, 0x3d8, 0x3d9, 0x5,
|
|
0x88, 0x45, 0x2, 0x3d9, 0x3da, 0x7, 0x4e, 0x2, 0x2, 0x3da, 0x3db, 0x5,
|
|
0x42, 0x22, 0x2, 0x3db, 0x3dc, 0x7, 0x45, 0x2, 0x2, 0x3dc, 0x87, 0x3,
|
|
0x2, 0x2, 0x2, 0x3dd, 0x3e0, 0x5, 0x44, 0x23, 0x2, 0x3de, 0x3e0, 0x5,
|
|
0x1e, 0x10, 0x2, 0x3df, 0x3dd, 0x3, 0x2, 0x2, 0x2, 0x3df, 0x3de, 0x3,
|
|
0x2, 0x2, 0x2, 0x3e0, 0x89, 0x3, 0x2, 0x2, 0x2, 0x3e1, 0x3ed, 0x5, 0x8c,
|
|
0x47, 0x2, 0x3e2, 0x3ed, 0x5, 0x8e, 0x48, 0x2, 0x3e3, 0x3ed, 0x5, 0x90,
|
|
0x49, 0x2, 0x3e4, 0x3ed, 0x5, 0x9e, 0x50, 0x2, 0x3e5, 0x3ed, 0x5, 0x92,
|
|
0x4a, 0x2, 0x3e6, 0x3ed, 0x5, 0x94, 0x4b, 0x2, 0x3e7, 0x3ed, 0x5, 0x98,
|
|
0x4d, 0x2, 0x3e8, 0x3ed, 0x7, 0x8b, 0x2, 0x2, 0x3e9, 0x3ed, 0x7, 0x83,
|
|
0x2, 0x2, 0x3ea, 0x3ed, 0x7, 0x85, 0x2, 0x2, 0x3eb, 0x3ed, 0x5, 0x9a,
|
|
0x4e, 0x2, 0x3ec, 0x3e1, 0x3, 0x2, 0x2, 0x2, 0x3ec, 0x3e2, 0x3, 0x2,
|
|
0x2, 0x2, 0x3ec, 0x3e3, 0x3, 0x2, 0x2, 0x2, 0x3ec, 0x3e4, 0x3, 0x2,
|
|
0x2, 0x2, 0x3ec, 0x3e5, 0x3, 0x2, 0x2, 0x2, 0x3ec, 0x3e6, 0x3, 0x2,
|
|
0x2, 0x2, 0x3ec, 0x3e7, 0x3, 0x2, 0x2, 0x2, 0x3ec, 0x3e8, 0x3, 0x2,
|
|
0x2, 0x2, 0x3ec, 0x3e9, 0x3, 0x2, 0x2, 0x2, 0x3ec, 0x3ea, 0x3, 0x2,
|
|
0x2, 0x2, 0x3ec, 0x3eb, 0x3, 0x2, 0x2, 0x2, 0x3ed, 0x8b, 0x3, 0x2, 0x2,
|
|
0x2, 0x3ee, 0x3f2, 0x7, 0x90, 0x2, 0x2, 0x3ef, 0x3f1, 0x5, 0x8a, 0x46,
|
|
0x2, 0x3f0, 0x3ef, 0x3, 0x2, 0x2, 0x2, 0x3f1, 0x3f4, 0x3, 0x2, 0x2,
|
|
0x2, 0x3f2, 0x3f0, 0x3, 0x2, 0x2, 0x2, 0x3f2, 0x3f3, 0x3, 0x2, 0x2,
|
|
0x2, 0x3f3, 0x3f5, 0x3, 0x2, 0x2, 0x2, 0x3f4, 0x3f2, 0x3, 0x2, 0x2,
|
|
0x2, 0x3f5, 0x3f6, 0x7, 0x91, 0x2, 0x2, 0x3f6, 0x8d, 0x3, 0x2, 0x2,
|
|
0x2, 0x3f7, 0x3f8, 0x7, 0x8c, 0x2, 0x2, 0x3f8, 0x3fb, 0x7, 0x98, 0x2,
|
|
0x2, 0x3f9, 0x3fa, 0x7, 0x94, 0x2, 0x2, 0x3fa, 0x3fc, 0x5, 0xa4, 0x53,
|
|
0x2, 0x3fb, 0x3f9, 0x3, 0x2, 0x2, 0x2, 0x3fb, 0x3fc, 0x3, 0x2, 0x2,
|
|
0x2, 0x3fc, 0x40b, 0x3, 0x2, 0x2, 0x2, 0x3fd, 0x3fe, 0x7, 0x8c, 0x2,
|
|
0x2, 0x3fe, 0x403, 0x7, 0x98, 0x2, 0x2, 0x3ff, 0x400, 0x7, 0x96, 0x2,
|
|
0x2, 0x400, 0x402, 0x7, 0x98, 0x2, 0x2, 0x401, 0x3ff, 0x3, 0x2, 0x2,
|
|
0x2, 0x402, 0x405, 0x3, 0x2, 0x2, 0x2, 0x403, 0x401, 0x3, 0x2, 0x2,
|
|
0x2, 0x403, 0x404, 0x3, 0x2, 0x2, 0x2, 0x404, 0x408, 0x3, 0x2, 0x2,
|
|
0x2, 0x405, 0x403, 0x3, 0x2, 0x2, 0x2, 0x406, 0x407, 0x7, 0x94, 0x2,
|
|
0x2, 0x407, 0x409, 0x5, 0x9e, 0x50, 0x2, 0x408, 0x406, 0x3, 0x2, 0x2,
|
|
0x2, 0x408, 0x409, 0x3, 0x2, 0x2, 0x2, 0x409, 0x40b, 0x3, 0x2, 0x2,
|
|
0x2, 0x40a, 0x3f7, 0x3, 0x2, 0x2, 0x2, 0x40a, 0x3fd, 0x3, 0x2, 0x2,
|
|
0x2, 0x40b, 0x8f, 0x3, 0x2, 0x2, 0x2, 0x40c, 0x40d, 0x5, 0x9c, 0x4f,
|
|
0x2, 0x40d, 0x40e, 0x7, 0x94, 0x2, 0x2, 0x40e, 0x40f, 0x5, 0xa4, 0x53,
|
|
0x2, 0x40f, 0x41b, 0x3, 0x2, 0x2, 0x2, 0x410, 0x413, 0x5, 0x9c, 0x4f,
|
|
0x2, 0x411, 0x412, 0x7, 0x96, 0x2, 0x2, 0x412, 0x414, 0x5, 0x9c, 0x4f,
|
|
0x2, 0x413, 0x411, 0x3, 0x2, 0x2, 0x2, 0x414, 0x415, 0x3, 0x2, 0x2,
|
|
0x2, 0x415, 0x413, 0x3, 0x2, 0x2, 0x2, 0x415, 0x416, 0x3, 0x2, 0x2,
|
|
0x2, 0x416, 0x417, 0x3, 0x2, 0x2, 0x2, 0x417, 0x418, 0x7, 0x94, 0x2,
|
|
0x2, 0x418, 0x419, 0x5, 0x9e, 0x50, 0x2, 0x419, 0x41b, 0x3, 0x2, 0x2,
|
|
0x2, 0x41a, 0x40c, 0x3, 0x2, 0x2, 0x2, 0x41a, 0x410, 0x3, 0x2, 0x2,
|
|
0x2, 0x41b, 0x91, 0x3, 0x2, 0x2, 0x2, 0x41c, 0x41d, 0x7, 0x8a, 0x2,
|
|
0x2, 0x41d, 0x41e, 0x5, 0xa4, 0x53, 0x2, 0x41e, 0x41f, 0x5, 0x8c, 0x47,
|
|
0x2, 0x41f, 0x93, 0x3, 0x2, 0x2, 0x2, 0x420, 0x421, 0x7, 0x88, 0x2,
|
|
0x2, 0x421, 0x422, 0x5, 0x8c, 0x47, 0x2, 0x422, 0x423, 0x5, 0xa4, 0x53,
|
|
0x2, 0x423, 0x424, 0x5, 0x8c, 0x47, 0x2, 0x424, 0x425, 0x5, 0x8c, 0x47,
|
|
0x2, 0x425, 0x95, 0x3, 0x2, 0x2, 0x2, 0x426, 0x427, 0x7, 0x84, 0x2,
|
|
0x2, 0x427, 0x428, 0x5, 0xa2, 0x52, 0x2, 0x428, 0x429, 0x5, 0x8c, 0x47,
|
|
0x2, 0x429, 0x97, 0x3, 0x2, 0x2, 0x2, 0x42a, 0x42b, 0x7, 0x8d, 0x2,
|
|
0x2, 0x42b, 0x437, 0x5, 0xa4, 0x53, 0x2, 0x42c, 0x42e, 0x5, 0x96, 0x4c,
|
|
0x2, 0x42d, 0x42c, 0x3, 0x2, 0x2, 0x2, 0x42e, 0x42f, 0x3, 0x2, 0x2,
|
|
0x2, 0x42f, 0x42d, 0x3, 0x2, 0x2, 0x2, 0x42f, 0x430, 0x3, 0x2, 0x2,
|
|
0x2, 0x430, 0x433, 0x3, 0x2, 0x2, 0x2, 0x431, 0x432, 0x7, 0x86, 0x2,
|
|
0x2, 0x432, 0x434, 0x5, 0x8c, 0x47, 0x2, 0x433, 0x431, 0x3, 0x2, 0x2,
|
|
0x2, 0x433, 0x434, 0x3, 0x2, 0x2, 0x2, 0x434, 0x438, 0x3, 0x2, 0x2,
|
|
0x2, 0x435, 0x436, 0x7, 0x86, 0x2, 0x2, 0x436, 0x438, 0x5, 0x8c, 0x47,
|
|
0x2, 0x437, 0x42d, 0x3, 0x2, 0x2, 0x2, 0x437, 0x435, 0x3, 0x2, 0x2,
|
|
0x2, 0x438, 0x99, 0x3, 0x2, 0x2, 0x2, 0x439, 0x43a, 0x7, 0x89, 0x2,
|
|
0x2, 0x43a, 0x43b, 0x7, 0x98, 0x2, 0x2, 0x43b, 0x444, 0x7, 0x92, 0x2,
|
|
0x2, 0x43c, 0x441, 0x7, 0x98, 0x2, 0x2, 0x43d, 0x43e, 0x7, 0x96, 0x2,
|
|
0x2, 0x43e, 0x440, 0x7, 0x98, 0x2, 0x2, 0x43f, 0x43d, 0x3, 0x2, 0x2,
|
|
0x2, 0x440, 0x443, 0x3, 0x2, 0x2, 0x2, 0x441, 0x43f, 0x3, 0x2, 0x2,
|
|
0x2, 0x441, 0x442, 0x3, 0x2, 0x2, 0x2, 0x442, 0x445, 0x3, 0x2, 0x2,
|
|
0x2, 0x443, 0x441, 0x3, 0x2, 0x2, 0x2, 0x444, 0x43c, 0x3, 0x2, 0x2,
|
|
0x2, 0x444, 0x445, 0x3, 0x2, 0x2, 0x2, 0x445, 0x446, 0x3, 0x2, 0x2,
|
|
0x2, 0x446, 0x450, 0x7, 0x93, 0x2, 0x2, 0x447, 0x448, 0x7, 0x97, 0x2,
|
|
0x2, 0x448, 0x44d, 0x7, 0x98, 0x2, 0x2, 0x449, 0x44a, 0x7, 0x96, 0x2,
|
|
0x2, 0x44a, 0x44c, 0x7, 0x98, 0x2, 0x2, 0x44b, 0x449, 0x3, 0x2, 0x2,
|
|
0x2, 0x44c, 0x44f, 0x3, 0x2, 0x2, 0x2, 0x44d, 0x44b, 0x3, 0x2, 0x2,
|
|
0x2, 0x44d, 0x44e, 0x3, 0x2, 0x2, 0x2, 0x44e, 0x451, 0x3, 0x2, 0x2,
|
|
0x2, 0x44f, 0x44d, 0x3, 0x2, 0x2, 0x2, 0x450, 0x447, 0x3, 0x2, 0x2,
|
|
0x2, 0x450, 0x451, 0x3, 0x2, 0x2, 0x2, 0x451, 0x452, 0x3, 0x2, 0x2,
|
|
0x2, 0x452, 0x453, 0x5, 0x8c, 0x47, 0x2, 0x453, 0x9b, 0x3, 0x2, 0x2,
|
|
0x2, 0x454, 0x459, 0x7, 0x98, 0x2, 0x2, 0x455, 0x456, 0x7, 0x95, 0x2,
|
|
0x2, 0x456, 0x458, 0x7, 0x98, 0x2, 0x2, 0x457, 0x455, 0x3, 0x2, 0x2,
|
|
0x2, 0x458, 0x45b, 0x3, 0x2, 0x2, 0x2, 0x459, 0x457, 0x3, 0x2, 0x2,
|
|
0x2, 0x459, 0x45a, 0x3, 0x2, 0x2, 0x2, 0x45a, 0x9d, 0x3, 0x2, 0x2, 0x2,
|
|
0x45b, 0x459, 0x3, 0x2, 0x2, 0x2, 0x45c, 0x45d, 0x9, 0x11, 0x2, 0x2,
|
|
0x45d, 0x466, 0x7, 0x92, 0x2, 0x2, 0x45e, 0x463, 0x5, 0xa4, 0x53, 0x2,
|
|
0x45f, 0x460, 0x7, 0x96, 0x2, 0x2, 0x460, 0x462, 0x5, 0xa4, 0x53, 0x2,
|
|
0x461, 0x45f, 0x3, 0x2, 0x2, 0x2, 0x462, 0x465, 0x3, 0x2, 0x2, 0x2,
|
|
0x463, 0x461, 0x3, 0x2, 0x2, 0x2, 0x463, 0x464, 0x3, 0x2, 0x2, 0x2,
|
|
0x464, 0x467, 0x3, 0x2, 0x2, 0x2, 0x465, 0x463, 0x3, 0x2, 0x2, 0x2,
|
|
0x466, 0x45e, 0x3, 0x2, 0x2, 0x2, 0x466, 0x467, 0x3, 0x2, 0x2, 0x2,
|
|
0x467, 0x468, 0x3, 0x2, 0x2, 0x2, 0x468, 0x469, 0x7, 0x93, 0x2, 0x2,
|
|
0x469, 0x9f, 0x3, 0x2, 0x2, 0x2, 0x46a, 0x46b, 0x9, 0x12, 0x2, 0x2,
|
|
0x46b, 0xa1, 0x3, 0x2, 0x2, 0x2, 0x46c, 0x471, 0x7, 0x9a, 0x2, 0x2,
|
|
0x46d, 0x471, 0x7, 0x9b, 0x2, 0x2, 0x46e, 0x471, 0x7, 0x99, 0x2, 0x2,
|
|
0x46f, 0x471, 0x5, 0xa0, 0x51, 0x2, 0x470, 0x46c, 0x3, 0x2, 0x2, 0x2,
|
|
0x470, 0x46d, 0x3, 0x2, 0x2, 0x2, 0x470, 0x46e, 0x3, 0x2, 0x2, 0x2,
|
|
0x470, 0x46f, 0x3, 0x2, 0x2, 0x2, 0x471, 0xa3, 0x3, 0x2, 0x2, 0x2, 0x472,
|
|
0x476, 0x5, 0x9c, 0x4f, 0x2, 0x473, 0x476, 0x5, 0x9e, 0x50, 0x2, 0x474,
|
|
0x476, 0x5, 0xa2, 0x52, 0x2, 0x475, 0x472, 0x3, 0x2, 0x2, 0x2, 0x475,
|
|
0x473, 0x3, 0x2, 0x2, 0x2, 0x475, 0x474, 0x3, 0x2, 0x2, 0x2, 0x476,
|
|
0xa5, 0x3, 0x2, 0x2, 0x2, 0x7f, 0xae, 0xb0, 0xb9, 0xc1, 0xcd, 0xd4,
|
|
0xde, 0xe4, 0xe9, 0xef, 0xf7, 0xfd, 0x108, 0x113, 0x118, 0x123, 0x12f,
|
|
0x132, 0x13a, 0x13d, 0x140, 0x149, 0x14e, 0x157, 0x15c, 0x15f, 0x164,
|
|
0x171, 0x173, 0x181, 0x186, 0x18c, 0x190, 0x1a3, 0x1a5, 0x1ad, 0x1b1,
|
|
0x1b7, 0x1ba, 0x1c3, 0x1c5, 0x1ca, 0x1df, 0x1e1, 0x1e6, 0x1ee, 0x1fe,
|
|
0x217, 0x219, 0x21f, 0x225, 0x228, 0x232, 0x235, 0x239, 0x242, 0x24b,
|
|
0x250, 0x255, 0x264, 0x269, 0x274, 0x276, 0x27e, 0x282, 0x29a, 0x29c,
|
|
0x2cc, 0x2d2, 0x2d6, 0x2dd, 0x2e6, 0x2e9, 0x2f0, 0x2f2, 0x2f9, 0x2fd,
|
|
0x301, 0x30c, 0x318, 0x31f, 0x324, 0x329, 0x32d, 0x333, 0x344, 0x348,
|
|
0x351, 0x357, 0x35b, 0x35e, 0x37e, 0x384, 0x388, 0x38e, 0x394, 0x39f,
|
|
0x3a5, 0x3af, 0x3b6, 0x3bd, 0x3c1, 0x3c9, 0x3cf, 0x3df, 0x3ec, 0x3f2,
|
|
0x3fb, 0x403, 0x408, 0x40a, 0x415, 0x41a, 0x42f, 0x433, 0x437, 0x441,
|
|
0x444, 0x44d, 0x450, 0x459, 0x463, 0x466, 0x470, 0x475,
|
|
};
|
|
|
|
atn::ATNDeserializer deserializer;
|
|
_atn = deserializer.deserialize(_serializedATN);
|
|
|
|
size_t count = _atn.getNumberOfDecisions();
|
|
_decisionToDFA.reserve(count);
|
|
for (size_t i = 0; i < count; i++) {
|
|
_decisionToDFA.emplace_back(_atn.getDecisionState(i), i);
|
|
}
|
|
}
|
|
|
|
SolidityParser::Initializer SolidityParser::_init;
|