688 lines
21 KiB
C++
688 lines
21 KiB
C++
|
|
// Generated from /home/atreya/Documents/Projects/Miscellaneous/bfc/grammar/bf.g4 by ANTLR 4.8
|
|
|
|
|
|
#include "bfListener.h"
|
|
#include "bfVisitor.h"
|
|
|
|
#include "bfParser.h"
|
|
|
|
|
|
using namespace antlrcpp;
|
|
using namespace antlr4;
|
|
|
|
bfParser::bfParser(TokenStream *input) : Parser(input) {
|
|
_interpreter = new atn::ParserATNSimulator(this, _atn, _decisionToDFA, _sharedContextCache);
|
|
}
|
|
|
|
bfParser::~bfParser() {
|
|
delete _interpreter;
|
|
}
|
|
|
|
std::string bfParser::getGrammarFileName() const {
|
|
return "bf.g4";
|
|
}
|
|
|
|
const std::vector<std::string>& bfParser::getRuleNames() const {
|
|
return _ruleNames;
|
|
}
|
|
|
|
dfa::Vocabulary& bfParser::getVocabulary() const {
|
|
return _vocabulary;
|
|
}
|
|
|
|
|
|
//----------------- ProgramContext ------------------------------------------------------------------
|
|
|
|
bfParser::ProgramContext::ProgramContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* bfParser::ProgramContext::EOF() {
|
|
return getToken(bfParser::EOF, 0);
|
|
}
|
|
|
|
std::vector<bfParser::StatementsContext *> bfParser::ProgramContext::statements() {
|
|
return getRuleContexts<bfParser::StatementsContext>();
|
|
}
|
|
|
|
bfParser::StatementsContext* bfParser::ProgramContext::statements(size_t i) {
|
|
return getRuleContext<bfParser::StatementsContext>(i);
|
|
}
|
|
|
|
|
|
size_t bfParser::ProgramContext::getRuleIndex() const {
|
|
return bfParser::RuleProgram;
|
|
}
|
|
|
|
void bfParser::ProgramContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<bfListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterProgram(this);
|
|
}
|
|
|
|
void bfParser::ProgramContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<bfListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitProgram(this);
|
|
}
|
|
|
|
|
|
antlrcpp::Any bfParser::ProgramContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<bfVisitor*>(visitor))
|
|
return parserVisitor->visitProgram(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
bfParser::ProgramContext* bfParser::program() {
|
|
ProgramContext *_localctx = _tracker.createInstance<ProgramContext>(_ctx, getState());
|
|
enterRule(_localctx, 0, bfParser::RuleProgram);
|
|
size_t _la = 0;
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(17);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
while ((((_la & ~ 0x3fULL) == 0) &&
|
|
((1ULL << _la) & ((1ULL << bfParser::LOOPSTART)
|
|
| (1ULL << bfParser::INPUT)
|
|
| (1ULL << bfParser::OUTPUT)
|
|
| (1ULL << bfParser::DEC)
|
|
| (1ULL << bfParser::INC)
|
|
| (1ULL << bfParser::LEFT)
|
|
| (1ULL << bfParser::RIGHT))) != 0)) {
|
|
setState(14);
|
|
statements();
|
|
setState(19);
|
|
_errHandler->sync(this);
|
|
_la = _input->LA(1);
|
|
}
|
|
setState(20);
|
|
match(bfParser::EOF);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- StatementsContext ------------------------------------------------------------------
|
|
|
|
bfParser::StatementsContext::StatementsContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
std::vector<bfParser::StatementContext *> bfParser::StatementsContext::statement() {
|
|
return getRuleContexts<bfParser::StatementContext>();
|
|
}
|
|
|
|
bfParser::StatementContext* bfParser::StatementsContext::statement(size_t i) {
|
|
return getRuleContext<bfParser::StatementContext>(i);
|
|
}
|
|
|
|
std::vector<bfParser::NumberedStatementContext *> bfParser::StatementsContext::numberedStatement() {
|
|
return getRuleContexts<bfParser::NumberedStatementContext>();
|
|
}
|
|
|
|
bfParser::NumberedStatementContext* bfParser::StatementsContext::numberedStatement(size_t i) {
|
|
return getRuleContext<bfParser::NumberedStatementContext>(i);
|
|
}
|
|
|
|
std::vector<bfParser::LoopStmtContext *> bfParser::StatementsContext::loopStmt() {
|
|
return getRuleContexts<bfParser::LoopStmtContext>();
|
|
}
|
|
|
|
bfParser::LoopStmtContext* bfParser::StatementsContext::loopStmt(size_t i) {
|
|
return getRuleContext<bfParser::LoopStmtContext>(i);
|
|
}
|
|
|
|
|
|
size_t bfParser::StatementsContext::getRuleIndex() const {
|
|
return bfParser::RuleStatements;
|
|
}
|
|
|
|
void bfParser::StatementsContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<bfListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterStatements(this);
|
|
}
|
|
|
|
void bfParser::StatementsContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<bfListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitStatements(this);
|
|
}
|
|
|
|
|
|
antlrcpp::Any bfParser::StatementsContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<bfVisitor*>(visitor))
|
|
return parserVisitor->visitStatements(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
bfParser::StatementsContext* bfParser::statements() {
|
|
StatementsContext *_localctx = _tracker.createInstance<StatementsContext>(_ctx, getState());
|
|
enterRule(_localctx, 2, bfParser::RuleStatements);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
size_t alt;
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(25);
|
|
_errHandler->sync(this);
|
|
alt = 1;
|
|
do {
|
|
switch (alt) {
|
|
case 1: {
|
|
setState(25);
|
|
_errHandler->sync(this);
|
|
switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1, _ctx)) {
|
|
case 1: {
|
|
setState(22);
|
|
statement();
|
|
break;
|
|
}
|
|
|
|
case 2: {
|
|
setState(23);
|
|
numberedStatement();
|
|
break;
|
|
}
|
|
|
|
case 3: {
|
|
setState(24);
|
|
loopStmt();
|
|
break;
|
|
}
|
|
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
setState(27);
|
|
_errHandler->sync(this);
|
|
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 2, _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;
|
|
}
|
|
|
|
//----------------- LoopStmtContext ------------------------------------------------------------------
|
|
|
|
bfParser::LoopStmtContext::LoopStmtContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* bfParser::LoopStmtContext::LOOPSTART() {
|
|
return getToken(bfParser::LOOPSTART, 0);
|
|
}
|
|
|
|
bfParser::StatementsContext* bfParser::LoopStmtContext::statements() {
|
|
return getRuleContext<bfParser::StatementsContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* bfParser::LoopStmtContext::LOOPEND() {
|
|
return getToken(bfParser::LOOPEND, 0);
|
|
}
|
|
|
|
|
|
size_t bfParser::LoopStmtContext::getRuleIndex() const {
|
|
return bfParser::RuleLoopStmt;
|
|
}
|
|
|
|
void bfParser::LoopStmtContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<bfListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterLoopStmt(this);
|
|
}
|
|
|
|
void bfParser::LoopStmtContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<bfListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitLoopStmt(this);
|
|
}
|
|
|
|
|
|
antlrcpp::Any bfParser::LoopStmtContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<bfVisitor*>(visitor))
|
|
return parserVisitor->visitLoopStmt(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
bfParser::LoopStmtContext* bfParser::loopStmt() {
|
|
LoopStmtContext *_localctx = _tracker.createInstance<LoopStmtContext>(_ctx, getState());
|
|
enterRule(_localctx, 4, bfParser::RuleLoopStmt);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(29);
|
|
match(bfParser::LOOPSTART);
|
|
setState(30);
|
|
statements();
|
|
setState(31);
|
|
match(bfParser::LOOPEND);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- NumberedStatementContext ------------------------------------------------------------------
|
|
|
|
bfParser::NumberedStatementContext::NumberedStatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
bfParser::StatementContext* bfParser::NumberedStatementContext::statement() {
|
|
return getRuleContext<bfParser::StatementContext>(0);
|
|
}
|
|
|
|
tree::TerminalNode* bfParser::NumberedStatementContext::NUMBER() {
|
|
return getToken(bfParser::NUMBER, 0);
|
|
}
|
|
|
|
|
|
size_t bfParser::NumberedStatementContext::getRuleIndex() const {
|
|
return bfParser::RuleNumberedStatement;
|
|
}
|
|
|
|
void bfParser::NumberedStatementContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<bfListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterNumberedStatement(this);
|
|
}
|
|
|
|
void bfParser::NumberedStatementContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<bfListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitNumberedStatement(this);
|
|
}
|
|
|
|
|
|
antlrcpp::Any bfParser::NumberedStatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<bfVisitor*>(visitor))
|
|
return parserVisitor->visitNumberedStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
bfParser::NumberedStatementContext* bfParser::numberedStatement() {
|
|
NumberedStatementContext *_localctx = _tracker.createInstance<NumberedStatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 6, bfParser::RuleNumberedStatement);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(33);
|
|
statement();
|
|
setState(34);
|
|
match(bfParser::NUMBER);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- StatementContext ------------------------------------------------------------------
|
|
|
|
bfParser::StatementContext::StatementContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* bfParser::StatementContext::INC() {
|
|
return getToken(bfParser::INC, 0);
|
|
}
|
|
|
|
tree::TerminalNode* bfParser::StatementContext::DEC() {
|
|
return getToken(bfParser::DEC, 0);
|
|
}
|
|
|
|
tree::TerminalNode* bfParser::StatementContext::LEFT() {
|
|
return getToken(bfParser::LEFT, 0);
|
|
}
|
|
|
|
tree::TerminalNode* bfParser::StatementContext::RIGHT() {
|
|
return getToken(bfParser::RIGHT, 0);
|
|
}
|
|
|
|
bfParser::InputStmtContext* bfParser::StatementContext::inputStmt() {
|
|
return getRuleContext<bfParser::InputStmtContext>(0);
|
|
}
|
|
|
|
bfParser::OutputStmtContext* bfParser::StatementContext::outputStmt() {
|
|
return getRuleContext<bfParser::OutputStmtContext>(0);
|
|
}
|
|
|
|
|
|
size_t bfParser::StatementContext::getRuleIndex() const {
|
|
return bfParser::RuleStatement;
|
|
}
|
|
|
|
void bfParser::StatementContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<bfListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterStatement(this);
|
|
}
|
|
|
|
void bfParser::StatementContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<bfListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitStatement(this);
|
|
}
|
|
|
|
|
|
antlrcpp::Any bfParser::StatementContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<bfVisitor*>(visitor))
|
|
return parserVisitor->visitStatement(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
bfParser::StatementContext* bfParser::statement() {
|
|
StatementContext *_localctx = _tracker.createInstance<StatementContext>(_ctx, getState());
|
|
enterRule(_localctx, 8, bfParser::RuleStatement);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
setState(42);
|
|
_errHandler->sync(this);
|
|
switch (_input->LA(1)) {
|
|
case bfParser::INC: {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(36);
|
|
match(bfParser::INC);
|
|
break;
|
|
}
|
|
|
|
case bfParser::DEC: {
|
|
enterOuterAlt(_localctx, 2);
|
|
setState(37);
|
|
match(bfParser::DEC);
|
|
break;
|
|
}
|
|
|
|
case bfParser::LEFT: {
|
|
enterOuterAlt(_localctx, 3);
|
|
setState(38);
|
|
match(bfParser::LEFT);
|
|
break;
|
|
}
|
|
|
|
case bfParser::RIGHT: {
|
|
enterOuterAlt(_localctx, 4);
|
|
setState(39);
|
|
match(bfParser::RIGHT);
|
|
break;
|
|
}
|
|
|
|
case bfParser::INPUT: {
|
|
enterOuterAlt(_localctx, 5);
|
|
setState(40);
|
|
inputStmt();
|
|
break;
|
|
}
|
|
|
|
case bfParser::OUTPUT: {
|
|
enterOuterAlt(_localctx, 6);
|
|
setState(41);
|
|
outputStmt();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
throw NoViableAltException(this);
|
|
}
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- InputStmtContext ------------------------------------------------------------------
|
|
|
|
bfParser::InputStmtContext::InputStmtContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* bfParser::InputStmtContext::INPUT() {
|
|
return getToken(bfParser::INPUT, 0);
|
|
}
|
|
|
|
|
|
size_t bfParser::InputStmtContext::getRuleIndex() const {
|
|
return bfParser::RuleInputStmt;
|
|
}
|
|
|
|
void bfParser::InputStmtContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<bfListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterInputStmt(this);
|
|
}
|
|
|
|
void bfParser::InputStmtContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<bfListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitInputStmt(this);
|
|
}
|
|
|
|
|
|
antlrcpp::Any bfParser::InputStmtContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<bfVisitor*>(visitor))
|
|
return parserVisitor->visitInputStmt(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
bfParser::InputStmtContext* bfParser::inputStmt() {
|
|
InputStmtContext *_localctx = _tracker.createInstance<InputStmtContext>(_ctx, getState());
|
|
enterRule(_localctx, 10, bfParser::RuleInputStmt);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(44);
|
|
match(bfParser::INPUT);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
//----------------- OutputStmtContext ------------------------------------------------------------------
|
|
|
|
bfParser::OutputStmtContext::OutputStmtContext(ParserRuleContext *parent, size_t invokingState)
|
|
: ParserRuleContext(parent, invokingState) {
|
|
}
|
|
|
|
tree::TerminalNode* bfParser::OutputStmtContext::OUTPUT() {
|
|
return getToken(bfParser::OUTPUT, 0);
|
|
}
|
|
|
|
|
|
size_t bfParser::OutputStmtContext::getRuleIndex() const {
|
|
return bfParser::RuleOutputStmt;
|
|
}
|
|
|
|
void bfParser::OutputStmtContext::enterRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<bfListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->enterOutputStmt(this);
|
|
}
|
|
|
|
void bfParser::OutputStmtContext::exitRule(tree::ParseTreeListener *listener) {
|
|
auto parserListener = dynamic_cast<bfListener *>(listener);
|
|
if (parserListener != nullptr)
|
|
parserListener->exitOutputStmt(this);
|
|
}
|
|
|
|
|
|
antlrcpp::Any bfParser::OutputStmtContext::accept(tree::ParseTreeVisitor *visitor) {
|
|
if (auto parserVisitor = dynamic_cast<bfVisitor*>(visitor))
|
|
return parserVisitor->visitOutputStmt(this);
|
|
else
|
|
return visitor->visitChildren(this);
|
|
}
|
|
|
|
bfParser::OutputStmtContext* bfParser::outputStmt() {
|
|
OutputStmtContext *_localctx = _tracker.createInstance<OutputStmtContext>(_ctx, getState());
|
|
enterRule(_localctx, 12, bfParser::RuleOutputStmt);
|
|
|
|
auto onExit = finally([=] {
|
|
exitRule();
|
|
});
|
|
try {
|
|
enterOuterAlt(_localctx, 1);
|
|
setState(46);
|
|
match(bfParser::OUTPUT);
|
|
|
|
}
|
|
catch (RecognitionException &e) {
|
|
_errHandler->reportError(this, e);
|
|
_localctx->exception = std::current_exception();
|
|
_errHandler->recover(this, _localctx->exception);
|
|
}
|
|
|
|
return _localctx;
|
|
}
|
|
|
|
// Static vars and initialization.
|
|
std::vector<dfa::DFA> bfParser::_decisionToDFA;
|
|
atn::PredictionContextCache bfParser::_sharedContextCache;
|
|
|
|
// We own the ATN which in turn owns the ATN states.
|
|
atn::ATN bfParser::_atn;
|
|
std::vector<uint16_t> bfParser::_serializedATN;
|
|
|
|
std::vector<std::string> bfParser::_ruleNames = {
|
|
"program", "statements", "loopStmt", "numberedStatement", "statement",
|
|
"inputStmt", "outputStmt"
|
|
};
|
|
|
|
std::vector<std::string> bfParser::_literalNames = {
|
|
"", "'\n'", "", "", "'['", "']'", "", "'?'", "'.'", "'-'", "'+'", "'>'",
|
|
"'<'"
|
|
};
|
|
|
|
std::vector<std::string> bfParser::_symbolicNames = {
|
|
"", "NEWLINE", "COMMENT", "WS", "LOOPSTART", "LOOPEND", "NUMBER", "INPUT",
|
|
"OUTPUT", "DEC", "INC", "LEFT", "RIGHT"
|
|
};
|
|
|
|
dfa::Vocabulary bfParser::_vocabulary(_literalNames, _symbolicNames);
|
|
|
|
std::vector<std::string> bfParser::_tokenNames;
|
|
|
|
bfParser::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, 0xe, 0x33, 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, 0x3, 0x2, 0x7, 0x2, 0x12, 0xa, 0x2, 0xc, 0x2, 0xe, 0x2,
|
|
0x15, 0xb, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x6,
|
|
0x3, 0x1c, 0xa, 0x3, 0xd, 0x3, 0xe, 0x3, 0x1d, 0x3, 0x4, 0x3, 0x4, 0x3,
|
|
0x4, 0x3, 0x4, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x6, 0x3, 0x6, 0x3,
|
|
0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x5, 0x6, 0x2d, 0xa, 0x6, 0x3, 0x7,
|
|
0x3, 0x7, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x2, 0x2, 0x9, 0x2, 0x4, 0x6,
|
|
0x8, 0xa, 0xc, 0xe, 0x2, 0x2, 0x2, 0x34, 0x2, 0x13, 0x3, 0x2, 0x2, 0x2,
|
|
0x4, 0x1b, 0x3, 0x2, 0x2, 0x2, 0x6, 0x1f, 0x3, 0x2, 0x2, 0x2, 0x8, 0x23,
|
|
0x3, 0x2, 0x2, 0x2, 0xa, 0x2c, 0x3, 0x2, 0x2, 0x2, 0xc, 0x2e, 0x3, 0x2,
|
|
0x2, 0x2, 0xe, 0x30, 0x3, 0x2, 0x2, 0x2, 0x10, 0x12, 0x5, 0x4, 0x3,
|
|
0x2, 0x11, 0x10, 0x3, 0x2, 0x2, 0x2, 0x12, 0x15, 0x3, 0x2, 0x2, 0x2,
|
|
0x13, 0x11, 0x3, 0x2, 0x2, 0x2, 0x13, 0x14, 0x3, 0x2, 0x2, 0x2, 0x14,
|
|
0x16, 0x3, 0x2, 0x2, 0x2, 0x15, 0x13, 0x3, 0x2, 0x2, 0x2, 0x16, 0x17,
|
|
0x7, 0x2, 0x2, 0x3, 0x17, 0x3, 0x3, 0x2, 0x2, 0x2, 0x18, 0x1c, 0x5,
|
|
0xa, 0x6, 0x2, 0x19, 0x1c, 0x5, 0x8, 0x5, 0x2, 0x1a, 0x1c, 0x5, 0x6,
|
|
0x4, 0x2, 0x1b, 0x18, 0x3, 0x2, 0x2, 0x2, 0x1b, 0x19, 0x3, 0x2, 0x2,
|
|
0x2, 0x1b, 0x1a, 0x3, 0x2, 0x2, 0x2, 0x1c, 0x1d, 0x3, 0x2, 0x2, 0x2,
|
|
0x1d, 0x1b, 0x3, 0x2, 0x2, 0x2, 0x1d, 0x1e, 0x3, 0x2, 0x2, 0x2, 0x1e,
|
|
0x5, 0x3, 0x2, 0x2, 0x2, 0x1f, 0x20, 0x7, 0x6, 0x2, 0x2, 0x20, 0x21,
|
|
0x5, 0x4, 0x3, 0x2, 0x21, 0x22, 0x7, 0x7, 0x2, 0x2, 0x22, 0x7, 0x3,
|
|
0x2, 0x2, 0x2, 0x23, 0x24, 0x5, 0xa, 0x6, 0x2, 0x24, 0x25, 0x7, 0x8,
|
|
0x2, 0x2, 0x25, 0x9, 0x3, 0x2, 0x2, 0x2, 0x26, 0x2d, 0x7, 0xc, 0x2,
|
|
0x2, 0x27, 0x2d, 0x7, 0xb, 0x2, 0x2, 0x28, 0x2d, 0x7, 0xd, 0x2, 0x2,
|
|
0x29, 0x2d, 0x7, 0xe, 0x2, 0x2, 0x2a, 0x2d, 0x5, 0xc, 0x7, 0x2, 0x2b,
|
|
0x2d, 0x5, 0xe, 0x8, 0x2, 0x2c, 0x26, 0x3, 0x2, 0x2, 0x2, 0x2c, 0x27,
|
|
0x3, 0x2, 0x2, 0x2, 0x2c, 0x28, 0x3, 0x2, 0x2, 0x2, 0x2c, 0x29, 0x3,
|
|
0x2, 0x2, 0x2, 0x2c, 0x2a, 0x3, 0x2, 0x2, 0x2, 0x2c, 0x2b, 0x3, 0x2,
|
|
0x2, 0x2, 0x2d, 0xb, 0x3, 0x2, 0x2, 0x2, 0x2e, 0x2f, 0x7, 0x9, 0x2,
|
|
0x2, 0x2f, 0xd, 0x3, 0x2, 0x2, 0x2, 0x30, 0x31, 0x7, 0xa, 0x2, 0x2,
|
|
0x31, 0xf, 0x3, 0x2, 0x2, 0x2, 0x6, 0x13, 0x1b, 0x1d, 0x2c,
|
|
};
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
bfParser::Initializer bfParser::_init;
|