set basic repo structure
This commit is contained in:
854
src/semantic/antlr-generated/MXParser.cpp
Normal file
854
src/semantic/antlr-generated/MXParser.cpp
Normal file
@ -0,0 +1,854 @@
|
||||
|
||||
// Generated from MXParser.g4 by ANTLR 4.13.2
|
||||
|
||||
|
||||
#include "MXParserVisitor.h"
|
||||
|
||||
#include "MXParser.h"
|
||||
|
||||
|
||||
using namespace antlrcpp;
|
||||
|
||||
using namespace antlr4;
|
||||
|
||||
namespace {
|
||||
|
||||
struct MXParserStaticData final {
|
||||
MXParserStaticData(std::vector<std::string> ruleNames,
|
||||
std::vector<std::string> literalNames,
|
||||
std::vector<std::string> symbolicNames)
|
||||
: ruleNames(std::move(ruleNames)), literalNames(std::move(literalNames)),
|
||||
symbolicNames(std::move(symbolicNames)),
|
||||
vocabulary(this->literalNames, this->symbolicNames) {}
|
||||
|
||||
MXParserStaticData(const MXParserStaticData&) = delete;
|
||||
MXParserStaticData(MXParserStaticData&&) = delete;
|
||||
MXParserStaticData& operator=(const MXParserStaticData&) = delete;
|
||||
MXParserStaticData& operator=(MXParserStaticData&&) = delete;
|
||||
|
||||
std::vector<antlr4::dfa::DFA> decisionToDFA;
|
||||
antlr4::atn::PredictionContextCache sharedContextCache;
|
||||
const std::vector<std::string> ruleNames;
|
||||
const std::vector<std::string> literalNames;
|
||||
const std::vector<std::string> symbolicNames;
|
||||
const antlr4::dfa::Vocabulary vocabulary;
|
||||
antlr4::atn::SerializedATNView serializedATN;
|
||||
std::unique_ptr<antlr4::atn::ATN> atn;
|
||||
};
|
||||
|
||||
::antlr4::internal::OnceFlag mxparserParserOnceFlag;
|
||||
#if ANTLR4_USE_THREAD_LOCAL_CACHE
|
||||
static thread_local
|
||||
#endif
|
||||
std::unique_ptr<MXParserStaticData> mxparserParserStaticData = nullptr;
|
||||
|
||||
void mxparserParserInitialize() {
|
||||
#if ANTLR4_USE_THREAD_LOCAL_CACHE
|
||||
if (mxparserParserStaticData != nullptr) {
|
||||
return;
|
||||
}
|
||||
#else
|
||||
assert(mxparserParserStaticData == nullptr);
|
||||
#endif
|
||||
auto staticData = std::make_unique<MXParserStaticData>(
|
||||
std::vector<std::string>{
|
||||
"mxprog", "function", "type", "block", "statement", "expression",
|
||||
"returnStmt", "ifStmt"
|
||||
},
|
||||
std::vector<std::string>{
|
||||
"", "'int'", "'void'", "'if'", "'else'", "'return'", "'+'", "'-'",
|
||||
"'*'", "'/'", "'='", "'('", "')'", "'{'", "'}'", "';'"
|
||||
},
|
||||
std::vector<std::string>{
|
||||
"", "INT", "VOID", "IF", "ELSE", "RETURN", "PLUS", "MINUS", "MULTIPLY",
|
||||
"DIVIDE", "ASSIGN", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "SEMICOLON",
|
||||
"ID", "INT_LITERAL", "WS", "COMMENT"
|
||||
}
|
||||
);
|
||||
static const int32_t serializedATNSegment[] = {
|
||||
4,1,19,81,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,6,2,7,
|
||||
7,7,1,0,5,0,18,8,0,10,0,12,0,21,9,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,
|
||||
2,1,2,1,3,1,3,5,3,35,8,3,10,3,12,3,38,9,3,1,3,1,3,1,4,1,4,1,4,1,4,1,4,
|
||||
3,4,47,8,4,1,5,1,5,1,5,1,5,1,5,1,5,1,5,3,5,56,8,5,1,5,1,5,1,5,5,5,61,
|
||||
8,5,10,5,12,5,64,9,5,1,6,1,6,3,6,68,8,6,1,6,1,6,1,7,1,7,1,7,1,7,1,7,1,
|
||||
7,1,7,3,7,79,8,7,1,7,0,1,10,8,0,2,4,6,8,10,12,14,0,2,1,0,1,2,1,0,6,9,
|
||||
81,0,19,1,0,0,0,2,24,1,0,0,0,4,30,1,0,0,0,6,32,1,0,0,0,8,46,1,0,0,0,10,
|
||||
55,1,0,0,0,12,65,1,0,0,0,14,71,1,0,0,0,16,18,3,2,1,0,17,16,1,0,0,0,18,
|
||||
21,1,0,0,0,19,17,1,0,0,0,19,20,1,0,0,0,20,22,1,0,0,0,21,19,1,0,0,0,22,
|
||||
23,5,0,0,1,23,1,1,0,0,0,24,25,3,4,2,0,25,26,5,16,0,0,26,27,5,11,0,0,27,
|
||||
28,5,12,0,0,28,29,3,6,3,0,29,3,1,0,0,0,30,31,7,0,0,0,31,5,1,0,0,0,32,
|
||||
36,5,13,0,0,33,35,3,8,4,0,34,33,1,0,0,0,35,38,1,0,0,0,36,34,1,0,0,0,36,
|
||||
37,1,0,0,0,37,39,1,0,0,0,38,36,1,0,0,0,39,40,5,14,0,0,40,7,1,0,0,0,41,
|
||||
42,3,10,5,0,42,43,5,15,0,0,43,47,1,0,0,0,44,47,3,12,6,0,45,47,3,14,7,
|
||||
0,46,41,1,0,0,0,46,44,1,0,0,0,46,45,1,0,0,0,47,9,1,0,0,0,48,49,6,5,-1,
|
||||
0,49,56,5,17,0,0,50,56,5,16,0,0,51,52,5,11,0,0,52,53,3,10,5,0,53,54,5,
|
||||
12,0,0,54,56,1,0,0,0,55,48,1,0,0,0,55,50,1,0,0,0,55,51,1,0,0,0,56,62,
|
||||
1,0,0,0,57,58,10,2,0,0,58,59,7,1,0,0,59,61,3,10,5,3,60,57,1,0,0,0,61,
|
||||
64,1,0,0,0,62,60,1,0,0,0,62,63,1,0,0,0,63,11,1,0,0,0,64,62,1,0,0,0,65,
|
||||
67,5,5,0,0,66,68,3,10,5,0,67,66,1,0,0,0,67,68,1,0,0,0,68,69,1,0,0,0,69,
|
||||
70,5,15,0,0,70,13,1,0,0,0,71,72,5,3,0,0,72,73,5,11,0,0,73,74,3,10,5,0,
|
||||
74,75,5,12,0,0,75,78,3,8,4,0,76,77,5,4,0,0,77,79,3,8,4,0,78,76,1,0,0,
|
||||
0,78,79,1,0,0,0,79,15,1,0,0,0,7,19,36,46,55,62,67,78
|
||||
};
|
||||
staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0]));
|
||||
|
||||
antlr4::atn::ATNDeserializer deserializer;
|
||||
staticData->atn = deserializer.deserialize(staticData->serializedATN);
|
||||
|
||||
const size_t count = staticData->atn->getNumberOfDecisions();
|
||||
staticData->decisionToDFA.reserve(count);
|
||||
for (size_t i = 0; i < count; i++) {
|
||||
staticData->decisionToDFA.emplace_back(staticData->atn->getDecisionState(i), i);
|
||||
}
|
||||
mxparserParserStaticData = std::move(staticData);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
MXParser::MXParser(TokenStream *input) : MXParser(input, antlr4::atn::ParserATNSimulatorOptions()) {}
|
||||
|
||||
MXParser::MXParser(TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options) : Parser(input) {
|
||||
MXParser::initialize();
|
||||
_interpreter = new atn::ParserATNSimulator(this, *mxparserParserStaticData->atn, mxparserParserStaticData->decisionToDFA, mxparserParserStaticData->sharedContextCache, options);
|
||||
}
|
||||
|
||||
MXParser::~MXParser() {
|
||||
delete _interpreter;
|
||||
}
|
||||
|
||||
const atn::ATN& MXParser::getATN() const {
|
||||
return *mxparserParserStaticData->atn;
|
||||
}
|
||||
|
||||
std::string MXParser::getGrammarFileName() const {
|
||||
return "MXParser.g4";
|
||||
}
|
||||
|
||||
const std::vector<std::string>& MXParser::getRuleNames() const {
|
||||
return mxparserParserStaticData->ruleNames;
|
||||
}
|
||||
|
||||
const dfa::Vocabulary& MXParser::getVocabulary() const {
|
||||
return mxparserParserStaticData->vocabulary;
|
||||
}
|
||||
|
||||
antlr4::atn::SerializedATNView MXParser::getSerializedATN() const {
|
||||
return mxparserParserStaticData->serializedATN;
|
||||
}
|
||||
|
||||
|
||||
//----------------- MxprogContext ------------------------------------------------------------------
|
||||
|
||||
MXParser::MxprogContext::MxprogContext(ParserRuleContext *parent, size_t invokingState)
|
||||
: ParserRuleContext(parent, invokingState) {
|
||||
}
|
||||
|
||||
tree::TerminalNode* MXParser::MxprogContext::EOF() {
|
||||
return getToken(MXParser::EOF, 0);
|
||||
}
|
||||
|
||||
std::vector<MXParser::FunctionContext *> MXParser::MxprogContext::function() {
|
||||
return getRuleContexts<MXParser::FunctionContext>();
|
||||
}
|
||||
|
||||
MXParser::FunctionContext* MXParser::MxprogContext::function(size_t i) {
|
||||
return getRuleContext<MXParser::FunctionContext>(i);
|
||||
}
|
||||
|
||||
|
||||
size_t MXParser::MxprogContext::getRuleIndex() const {
|
||||
return MXParser::RuleMxprog;
|
||||
}
|
||||
|
||||
|
||||
std::any MXParser::MxprogContext::accept(tree::ParseTreeVisitor *visitor) {
|
||||
if (auto parserVisitor = dynamic_cast<MXParserVisitor*>(visitor))
|
||||
return parserVisitor->visitMxprog(this);
|
||||
else
|
||||
return visitor->visitChildren(this);
|
||||
}
|
||||
|
||||
MXParser::MxprogContext* MXParser::mxprog() {
|
||||
MxprogContext *_localctx = _tracker.createInstance<MxprogContext>(_ctx, getState());
|
||||
enterRule(_localctx, 0, MXParser::RuleMxprog);
|
||||
size_t _la = 0;
|
||||
|
||||
#if __cplusplus > 201703L
|
||||
auto onExit = finally([=, this] {
|
||||
#else
|
||||
auto onExit = finally([=] {
|
||||
#endif
|
||||
exitRule();
|
||||
});
|
||||
try {
|
||||
enterOuterAlt(_localctx, 1);
|
||||
setState(19);
|
||||
_errHandler->sync(this);
|
||||
_la = _input->LA(1);
|
||||
while (_la == MXParser::INT
|
||||
|
||||
|| _la == MXParser::VOID) {
|
||||
setState(16);
|
||||
function();
|
||||
setState(21);
|
||||
_errHandler->sync(this);
|
||||
_la = _input->LA(1);
|
||||
}
|
||||
setState(22);
|
||||
match(MXParser::EOF);
|
||||
|
||||
}
|
||||
catch (RecognitionException &e) {
|
||||
_errHandler->reportError(this, e);
|
||||
_localctx->exception = std::current_exception();
|
||||
_errHandler->recover(this, _localctx->exception);
|
||||
}
|
||||
|
||||
return _localctx;
|
||||
}
|
||||
|
||||
//----------------- FunctionContext ------------------------------------------------------------------
|
||||
|
||||
MXParser::FunctionContext::FunctionContext(ParserRuleContext *parent, size_t invokingState)
|
||||
: ParserRuleContext(parent, invokingState) {
|
||||
}
|
||||
|
||||
MXParser::TypeContext* MXParser::FunctionContext::type() {
|
||||
return getRuleContext<MXParser::TypeContext>(0);
|
||||
}
|
||||
|
||||
tree::TerminalNode* MXParser::FunctionContext::ID() {
|
||||
return getToken(MXParser::ID, 0);
|
||||
}
|
||||
|
||||
tree::TerminalNode* MXParser::FunctionContext::LPAREN() {
|
||||
return getToken(MXParser::LPAREN, 0);
|
||||
}
|
||||
|
||||
tree::TerminalNode* MXParser::FunctionContext::RPAREN() {
|
||||
return getToken(MXParser::RPAREN, 0);
|
||||
}
|
||||
|
||||
MXParser::BlockContext* MXParser::FunctionContext::block() {
|
||||
return getRuleContext<MXParser::BlockContext>(0);
|
||||
}
|
||||
|
||||
|
||||
size_t MXParser::FunctionContext::getRuleIndex() const {
|
||||
return MXParser::RuleFunction;
|
||||
}
|
||||
|
||||
|
||||
std::any MXParser::FunctionContext::accept(tree::ParseTreeVisitor *visitor) {
|
||||
if (auto parserVisitor = dynamic_cast<MXParserVisitor*>(visitor))
|
||||
return parserVisitor->visitFunction(this);
|
||||
else
|
||||
return visitor->visitChildren(this);
|
||||
}
|
||||
|
||||
MXParser::FunctionContext* MXParser::function() {
|
||||
FunctionContext *_localctx = _tracker.createInstance<FunctionContext>(_ctx, getState());
|
||||
enterRule(_localctx, 2, MXParser::RuleFunction);
|
||||
|
||||
#if __cplusplus > 201703L
|
||||
auto onExit = finally([=, this] {
|
||||
#else
|
||||
auto onExit = finally([=] {
|
||||
#endif
|
||||
exitRule();
|
||||
});
|
||||
try {
|
||||
enterOuterAlt(_localctx, 1);
|
||||
setState(24);
|
||||
type();
|
||||
setState(25);
|
||||
match(MXParser::ID);
|
||||
setState(26);
|
||||
match(MXParser::LPAREN);
|
||||
setState(27);
|
||||
match(MXParser::RPAREN);
|
||||
setState(28);
|
||||
block();
|
||||
|
||||
}
|
||||
catch (RecognitionException &e) {
|
||||
_errHandler->reportError(this, e);
|
||||
_localctx->exception = std::current_exception();
|
||||
_errHandler->recover(this, _localctx->exception);
|
||||
}
|
||||
|
||||
return _localctx;
|
||||
}
|
||||
|
||||
//----------------- TypeContext ------------------------------------------------------------------
|
||||
|
||||
MXParser::TypeContext::TypeContext(ParserRuleContext *parent, size_t invokingState)
|
||||
: ParserRuleContext(parent, invokingState) {
|
||||
}
|
||||
|
||||
tree::TerminalNode* MXParser::TypeContext::INT() {
|
||||
return getToken(MXParser::INT, 0);
|
||||
}
|
||||
|
||||
tree::TerminalNode* MXParser::TypeContext::VOID() {
|
||||
return getToken(MXParser::VOID, 0);
|
||||
}
|
||||
|
||||
|
||||
size_t MXParser::TypeContext::getRuleIndex() const {
|
||||
return MXParser::RuleType;
|
||||
}
|
||||
|
||||
|
||||
std::any MXParser::TypeContext::accept(tree::ParseTreeVisitor *visitor) {
|
||||
if (auto parserVisitor = dynamic_cast<MXParserVisitor*>(visitor))
|
||||
return parserVisitor->visitType(this);
|
||||
else
|
||||
return visitor->visitChildren(this);
|
||||
}
|
||||
|
||||
MXParser::TypeContext* MXParser::type() {
|
||||
TypeContext *_localctx = _tracker.createInstance<TypeContext>(_ctx, getState());
|
||||
enterRule(_localctx, 4, MXParser::RuleType);
|
||||
size_t _la = 0;
|
||||
|
||||
#if __cplusplus > 201703L
|
||||
auto onExit = finally([=, this] {
|
||||
#else
|
||||
auto onExit = finally([=] {
|
||||
#endif
|
||||
exitRule();
|
||||
});
|
||||
try {
|
||||
enterOuterAlt(_localctx, 1);
|
||||
setState(30);
|
||||
_la = _input->LA(1);
|
||||
if (!(_la == MXParser::INT
|
||||
|
||||
|| _la == MXParser::VOID)) {
|
||||
_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;
|
||||
}
|
||||
|
||||
//----------------- BlockContext ------------------------------------------------------------------
|
||||
|
||||
MXParser::BlockContext::BlockContext(ParserRuleContext *parent, size_t invokingState)
|
||||
: ParserRuleContext(parent, invokingState) {
|
||||
}
|
||||
|
||||
tree::TerminalNode* MXParser::BlockContext::LBRACE() {
|
||||
return getToken(MXParser::LBRACE, 0);
|
||||
}
|
||||
|
||||
tree::TerminalNode* MXParser::BlockContext::RBRACE() {
|
||||
return getToken(MXParser::RBRACE, 0);
|
||||
}
|
||||
|
||||
std::vector<MXParser::StatementContext *> MXParser::BlockContext::statement() {
|
||||
return getRuleContexts<MXParser::StatementContext>();
|
||||
}
|
||||
|
||||
MXParser::StatementContext* MXParser::BlockContext::statement(size_t i) {
|
||||
return getRuleContext<MXParser::StatementContext>(i);
|
||||
}
|
||||
|
||||
|
||||
size_t MXParser::BlockContext::getRuleIndex() const {
|
||||
return MXParser::RuleBlock;
|
||||
}
|
||||
|
||||
|
||||
std::any MXParser::BlockContext::accept(tree::ParseTreeVisitor *visitor) {
|
||||
if (auto parserVisitor = dynamic_cast<MXParserVisitor*>(visitor))
|
||||
return parserVisitor->visitBlock(this);
|
||||
else
|
||||
return visitor->visitChildren(this);
|
||||
}
|
||||
|
||||
MXParser::BlockContext* MXParser::block() {
|
||||
BlockContext *_localctx = _tracker.createInstance<BlockContext>(_ctx, getState());
|
||||
enterRule(_localctx, 6, MXParser::RuleBlock);
|
||||
size_t _la = 0;
|
||||
|
||||
#if __cplusplus > 201703L
|
||||
auto onExit = finally([=, this] {
|
||||
#else
|
||||
auto onExit = finally([=] {
|
||||
#endif
|
||||
exitRule();
|
||||
});
|
||||
try {
|
||||
enterOuterAlt(_localctx, 1);
|
||||
setState(32);
|
||||
match(MXParser::LBRACE);
|
||||
setState(36);
|
||||
_errHandler->sync(this);
|
||||
_la = _input->LA(1);
|
||||
while ((((_la & ~ 0x3fULL) == 0) &&
|
||||
((1ULL << _la) & 198696) != 0)) {
|
||||
setState(33);
|
||||
statement();
|
||||
setState(38);
|
||||
_errHandler->sync(this);
|
||||
_la = _input->LA(1);
|
||||
}
|
||||
setState(39);
|
||||
match(MXParser::RBRACE);
|
||||
|
||||
}
|
||||
catch (RecognitionException &e) {
|
||||
_errHandler->reportError(this, e);
|
||||
_localctx->exception = std::current_exception();
|
||||
_errHandler->recover(this, _localctx->exception);
|
||||
}
|
||||
|
||||
return _localctx;
|
||||
}
|
||||
|
||||
//----------------- StatementContext ------------------------------------------------------------------
|
||||
|
||||
MXParser::StatementContext::StatementContext(ParserRuleContext *parent, size_t invokingState)
|
||||
: ParserRuleContext(parent, invokingState) {
|
||||
}
|
||||
|
||||
MXParser::ExpressionContext* MXParser::StatementContext::expression() {
|
||||
return getRuleContext<MXParser::ExpressionContext>(0);
|
||||
}
|
||||
|
||||
tree::TerminalNode* MXParser::StatementContext::SEMICOLON() {
|
||||
return getToken(MXParser::SEMICOLON, 0);
|
||||
}
|
||||
|
||||
MXParser::ReturnStmtContext* MXParser::StatementContext::returnStmt() {
|
||||
return getRuleContext<MXParser::ReturnStmtContext>(0);
|
||||
}
|
||||
|
||||
MXParser::IfStmtContext* MXParser::StatementContext::ifStmt() {
|
||||
return getRuleContext<MXParser::IfStmtContext>(0);
|
||||
}
|
||||
|
||||
|
||||
size_t MXParser::StatementContext::getRuleIndex() const {
|
||||
return MXParser::RuleStatement;
|
||||
}
|
||||
|
||||
|
||||
std::any MXParser::StatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
||||
if (auto parserVisitor = dynamic_cast<MXParserVisitor*>(visitor))
|
||||
return parserVisitor->visitStatement(this);
|
||||
else
|
||||
return visitor->visitChildren(this);
|
||||
}
|
||||
|
||||
MXParser::StatementContext* MXParser::statement() {
|
||||
StatementContext *_localctx = _tracker.createInstance<StatementContext>(_ctx, getState());
|
||||
enterRule(_localctx, 8, MXParser::RuleStatement);
|
||||
|
||||
#if __cplusplus > 201703L
|
||||
auto onExit = finally([=, this] {
|
||||
#else
|
||||
auto onExit = finally([=] {
|
||||
#endif
|
||||
exitRule();
|
||||
});
|
||||
try {
|
||||
setState(46);
|
||||
_errHandler->sync(this);
|
||||
switch (_input->LA(1)) {
|
||||
case MXParser::LPAREN:
|
||||
case MXParser::ID:
|
||||
case MXParser::INT_LITERAL: {
|
||||
enterOuterAlt(_localctx, 1);
|
||||
setState(41);
|
||||
expression(0);
|
||||
setState(42);
|
||||
match(MXParser::SEMICOLON);
|
||||
break;
|
||||
}
|
||||
|
||||
case MXParser::RETURN: {
|
||||
enterOuterAlt(_localctx, 2);
|
||||
setState(44);
|
||||
returnStmt();
|
||||
break;
|
||||
}
|
||||
|
||||
case MXParser::IF: {
|
||||
enterOuterAlt(_localctx, 3);
|
||||
setState(45);
|
||||
ifStmt();
|
||||
break;
|
||||
}
|
||||
|
||||
default:
|
||||
throw NoViableAltException(this);
|
||||
}
|
||||
|
||||
}
|
||||
catch (RecognitionException &e) {
|
||||
_errHandler->reportError(this, e);
|
||||
_localctx->exception = std::current_exception();
|
||||
_errHandler->recover(this, _localctx->exception);
|
||||
}
|
||||
|
||||
return _localctx;
|
||||
}
|
||||
|
||||
//----------------- ExpressionContext ------------------------------------------------------------------
|
||||
|
||||
MXParser::ExpressionContext::ExpressionContext(ParserRuleContext *parent, size_t invokingState)
|
||||
: ParserRuleContext(parent, invokingState) {
|
||||
}
|
||||
|
||||
tree::TerminalNode* MXParser::ExpressionContext::INT_LITERAL() {
|
||||
return getToken(MXParser::INT_LITERAL, 0);
|
||||
}
|
||||
|
||||
tree::TerminalNode* MXParser::ExpressionContext::ID() {
|
||||
return getToken(MXParser::ID, 0);
|
||||
}
|
||||
|
||||
tree::TerminalNode* MXParser::ExpressionContext::LPAREN() {
|
||||
return getToken(MXParser::LPAREN, 0);
|
||||
}
|
||||
|
||||
std::vector<MXParser::ExpressionContext *> MXParser::ExpressionContext::expression() {
|
||||
return getRuleContexts<MXParser::ExpressionContext>();
|
||||
}
|
||||
|
||||
MXParser::ExpressionContext* MXParser::ExpressionContext::expression(size_t i) {
|
||||
return getRuleContext<MXParser::ExpressionContext>(i);
|
||||
}
|
||||
|
||||
tree::TerminalNode* MXParser::ExpressionContext::RPAREN() {
|
||||
return getToken(MXParser::RPAREN, 0);
|
||||
}
|
||||
|
||||
tree::TerminalNode* MXParser::ExpressionContext::PLUS() {
|
||||
return getToken(MXParser::PLUS, 0);
|
||||
}
|
||||
|
||||
tree::TerminalNode* MXParser::ExpressionContext::MINUS() {
|
||||
return getToken(MXParser::MINUS, 0);
|
||||
}
|
||||
|
||||
tree::TerminalNode* MXParser::ExpressionContext::MULTIPLY() {
|
||||
return getToken(MXParser::MULTIPLY, 0);
|
||||
}
|
||||
|
||||
tree::TerminalNode* MXParser::ExpressionContext::DIVIDE() {
|
||||
return getToken(MXParser::DIVIDE, 0);
|
||||
}
|
||||
|
||||
|
||||
size_t MXParser::ExpressionContext::getRuleIndex() const {
|
||||
return MXParser::RuleExpression;
|
||||
}
|
||||
|
||||
|
||||
std::any MXParser::ExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
|
||||
if (auto parserVisitor = dynamic_cast<MXParserVisitor*>(visitor))
|
||||
return parserVisitor->visitExpression(this);
|
||||
else
|
||||
return visitor->visitChildren(this);
|
||||
}
|
||||
|
||||
|
||||
MXParser::ExpressionContext* MXParser::expression() {
|
||||
return expression(0);
|
||||
}
|
||||
|
||||
MXParser::ExpressionContext* MXParser::expression(int precedence) {
|
||||
ParserRuleContext *parentContext = _ctx;
|
||||
size_t parentState = getState();
|
||||
MXParser::ExpressionContext *_localctx = _tracker.createInstance<ExpressionContext>(_ctx, parentState);
|
||||
MXParser::ExpressionContext *previousContext = _localctx;
|
||||
(void)previousContext; // Silence compiler, in case the context is not used by generated code.
|
||||
size_t startState = 10;
|
||||
enterRecursionRule(_localctx, 10, MXParser::RuleExpression, precedence);
|
||||
|
||||
size_t _la = 0;
|
||||
|
||||
#if __cplusplus > 201703L
|
||||
auto onExit = finally([=, this] {
|
||||
#else
|
||||
auto onExit = finally([=] {
|
||||
#endif
|
||||
unrollRecursionContexts(parentContext);
|
||||
});
|
||||
try {
|
||||
size_t alt;
|
||||
enterOuterAlt(_localctx, 1);
|
||||
setState(55);
|
||||
_errHandler->sync(this);
|
||||
switch (_input->LA(1)) {
|
||||
case MXParser::INT_LITERAL: {
|
||||
setState(49);
|
||||
match(MXParser::INT_LITERAL);
|
||||
break;
|
||||
}
|
||||
|
||||
case MXParser::ID: {
|
||||
setState(50);
|
||||
match(MXParser::ID);
|
||||
break;
|
||||
}
|
||||
|
||||
case MXParser::LPAREN: {
|
||||
setState(51);
|
||||
match(MXParser::LPAREN);
|
||||
setState(52);
|
||||
expression(0);
|
||||
setState(53);
|
||||
match(MXParser::RPAREN);
|
||||
break;
|
||||
}
|
||||
|
||||
default:
|
||||
throw NoViableAltException(this);
|
||||
}
|
||||
_ctx->stop = _input->LT(-1);
|
||||
setState(62);
|
||||
_errHandler->sync(this);
|
||||
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 4, _ctx);
|
||||
while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
|
||||
if (alt == 1) {
|
||||
if (!_parseListeners.empty())
|
||||
triggerExitRuleEvent();
|
||||
previousContext = _localctx;
|
||||
_localctx = _tracker.createInstance<ExpressionContext>(parentContext, parentState);
|
||||
pushNewRecursionContext(_localctx, startState, RuleExpression);
|
||||
setState(57);
|
||||
|
||||
if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
|
||||
setState(58);
|
||||
_la = _input->LA(1);
|
||||
if (!((((_la & ~ 0x3fULL) == 0) &&
|
||||
((1ULL << _la) & 960) != 0))) {
|
||||
_errHandler->recoverInline(this);
|
||||
}
|
||||
else {
|
||||
_errHandler->reportMatch(this);
|
||||
consume();
|
||||
}
|
||||
setState(59);
|
||||
expression(3);
|
||||
}
|
||||
setState(64);
|
||||
_errHandler->sync(this);
|
||||
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 4, _ctx);
|
||||
}
|
||||
}
|
||||
catch (RecognitionException &e) {
|
||||
_errHandler->reportError(this, e);
|
||||
_localctx->exception = std::current_exception();
|
||||
_errHandler->recover(this, _localctx->exception);
|
||||
}
|
||||
return _localctx;
|
||||
}
|
||||
|
||||
//----------------- ReturnStmtContext ------------------------------------------------------------------
|
||||
|
||||
MXParser::ReturnStmtContext::ReturnStmtContext(ParserRuleContext *parent, size_t invokingState)
|
||||
: ParserRuleContext(parent, invokingState) {
|
||||
}
|
||||
|
||||
tree::TerminalNode* MXParser::ReturnStmtContext::RETURN() {
|
||||
return getToken(MXParser::RETURN, 0);
|
||||
}
|
||||
|
||||
tree::TerminalNode* MXParser::ReturnStmtContext::SEMICOLON() {
|
||||
return getToken(MXParser::SEMICOLON, 0);
|
||||
}
|
||||
|
||||
MXParser::ExpressionContext* MXParser::ReturnStmtContext::expression() {
|
||||
return getRuleContext<MXParser::ExpressionContext>(0);
|
||||
}
|
||||
|
||||
|
||||
size_t MXParser::ReturnStmtContext::getRuleIndex() const {
|
||||
return MXParser::RuleReturnStmt;
|
||||
}
|
||||
|
||||
|
||||
std::any MXParser::ReturnStmtContext::accept(tree::ParseTreeVisitor *visitor) {
|
||||
if (auto parserVisitor = dynamic_cast<MXParserVisitor*>(visitor))
|
||||
return parserVisitor->visitReturnStmt(this);
|
||||
else
|
||||
return visitor->visitChildren(this);
|
||||
}
|
||||
|
||||
MXParser::ReturnStmtContext* MXParser::returnStmt() {
|
||||
ReturnStmtContext *_localctx = _tracker.createInstance<ReturnStmtContext>(_ctx, getState());
|
||||
enterRule(_localctx, 12, MXParser::RuleReturnStmt);
|
||||
size_t _la = 0;
|
||||
|
||||
#if __cplusplus > 201703L
|
||||
auto onExit = finally([=, this] {
|
||||
#else
|
||||
auto onExit = finally([=] {
|
||||
#endif
|
||||
exitRule();
|
||||
});
|
||||
try {
|
||||
enterOuterAlt(_localctx, 1);
|
||||
setState(65);
|
||||
match(MXParser::RETURN);
|
||||
setState(67);
|
||||
_errHandler->sync(this);
|
||||
|
||||
_la = _input->LA(1);
|
||||
if ((((_la & ~ 0x3fULL) == 0) &&
|
||||
((1ULL << _la) & 198656) != 0)) {
|
||||
setState(66);
|
||||
expression(0);
|
||||
}
|
||||
setState(69);
|
||||
match(MXParser::SEMICOLON);
|
||||
|
||||
}
|
||||
catch (RecognitionException &e) {
|
||||
_errHandler->reportError(this, e);
|
||||
_localctx->exception = std::current_exception();
|
||||
_errHandler->recover(this, _localctx->exception);
|
||||
}
|
||||
|
||||
return _localctx;
|
||||
}
|
||||
|
||||
//----------------- IfStmtContext ------------------------------------------------------------------
|
||||
|
||||
MXParser::IfStmtContext::IfStmtContext(ParserRuleContext *parent, size_t invokingState)
|
||||
: ParserRuleContext(parent, invokingState) {
|
||||
}
|
||||
|
||||
tree::TerminalNode* MXParser::IfStmtContext::IF() {
|
||||
return getToken(MXParser::IF, 0);
|
||||
}
|
||||
|
||||
tree::TerminalNode* MXParser::IfStmtContext::LPAREN() {
|
||||
return getToken(MXParser::LPAREN, 0);
|
||||
}
|
||||
|
||||
MXParser::ExpressionContext* MXParser::IfStmtContext::expression() {
|
||||
return getRuleContext<MXParser::ExpressionContext>(0);
|
||||
}
|
||||
|
||||
tree::TerminalNode* MXParser::IfStmtContext::RPAREN() {
|
||||
return getToken(MXParser::RPAREN, 0);
|
||||
}
|
||||
|
||||
std::vector<MXParser::StatementContext *> MXParser::IfStmtContext::statement() {
|
||||
return getRuleContexts<MXParser::StatementContext>();
|
||||
}
|
||||
|
||||
MXParser::StatementContext* MXParser::IfStmtContext::statement(size_t i) {
|
||||
return getRuleContext<MXParser::StatementContext>(i);
|
||||
}
|
||||
|
||||
tree::TerminalNode* MXParser::IfStmtContext::ELSE() {
|
||||
return getToken(MXParser::ELSE, 0);
|
||||
}
|
||||
|
||||
|
||||
size_t MXParser::IfStmtContext::getRuleIndex() const {
|
||||
return MXParser::RuleIfStmt;
|
||||
}
|
||||
|
||||
|
||||
std::any MXParser::IfStmtContext::accept(tree::ParseTreeVisitor *visitor) {
|
||||
if (auto parserVisitor = dynamic_cast<MXParserVisitor*>(visitor))
|
||||
return parserVisitor->visitIfStmt(this);
|
||||
else
|
||||
return visitor->visitChildren(this);
|
||||
}
|
||||
|
||||
MXParser::IfStmtContext* MXParser::ifStmt() {
|
||||
IfStmtContext *_localctx = _tracker.createInstance<IfStmtContext>(_ctx, getState());
|
||||
enterRule(_localctx, 14, MXParser::RuleIfStmt);
|
||||
|
||||
#if __cplusplus > 201703L
|
||||
auto onExit = finally([=, this] {
|
||||
#else
|
||||
auto onExit = finally([=] {
|
||||
#endif
|
||||
exitRule();
|
||||
});
|
||||
try {
|
||||
enterOuterAlt(_localctx, 1);
|
||||
setState(71);
|
||||
match(MXParser::IF);
|
||||
setState(72);
|
||||
match(MXParser::LPAREN);
|
||||
setState(73);
|
||||
expression(0);
|
||||
setState(74);
|
||||
match(MXParser::RPAREN);
|
||||
setState(75);
|
||||
statement();
|
||||
setState(78);
|
||||
_errHandler->sync(this);
|
||||
|
||||
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 6, _ctx)) {
|
||||
case 1: {
|
||||
setState(76);
|
||||
match(MXParser::ELSE);
|
||||
setState(77);
|
||||
statement();
|
||||
break;
|
||||
}
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
catch (RecognitionException &e) {
|
||||
_errHandler->reportError(this, e);
|
||||
_localctx->exception = std::current_exception();
|
||||
_errHandler->recover(this, _localctx->exception);
|
||||
}
|
||||
|
||||
return _localctx;
|
||||
}
|
||||
|
||||
bool MXParser::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) {
|
||||
switch (ruleIndex) {
|
||||
case 5: return expressionSempred(antlrcpp::downCast<ExpressionContext *>(context), predicateIndex);
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool MXParser::expressionSempred(ExpressionContext *_localctx, size_t predicateIndex) {
|
||||
switch (predicateIndex) {
|
||||
case 0: return precpred(_ctx, 2);
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
void MXParser::initialize() {
|
||||
#if ANTLR4_USE_THREAD_LOCAL_CACHE
|
||||
mxparserParserInitialize();
|
||||
#else
|
||||
::antlr4::internal::call_once(mxparserParserOnceFlag, mxparserParserInitialize);
|
||||
#endif
|
||||
}
|
||||
Reference in New Issue
Block a user