atreyabain/bfc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
289cba0625bb088ac8e04c76168236569e6b4e2a
bfc/lib/generated/bfParser.cpp

688 lines
21 KiB
C++
Raw Normal View History

add antlr
2020-09-29 23:16:42 +05:30
// 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) {
}
add statement support
2020-09-29 23:30:58 +05:30
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);
add antlr
2020-09-29 23:16:42 +05:30
}
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);
add statement support
2020-09-29 23:30:58 +05:30
size_t _la = 0;
add antlr
2020-09-29 23:16:42 +05:30
auto onExit = finally([=] {
exitRule();
});
try {
enterOuterAlt(_localctx, 1);
Add new comments and lines
2020-09-30 00:50:00 +05:30
setState(17);
add statement support
2020-09-29 23:30:58 +05:30
_errHandler->sync(this);
_la = _input->LA(1);
while ((((_la & ~ 0x3fULL) == 0) &&
Add new comments and lines
2020-09-30 00:50:00 +05:30
((1ULL << _la) & ((1ULL << bfParser::LOOPSTART)
| (1ULL << bfParser::INPUT)
add statement support
2020-09-29 23:30:58 +05:30
| (1ULL << bfParser::OUTPUT)
| (1ULL << bfParser::DEC)
Add new comments and lines
2020-09-30 00:50:00 +05:30
| (1ULL << bfParser::INC)
| (1ULL << bfParser::LEFT)
| (1ULL << bfParser::RIGHT))) != 0)) {
setState(14);
add statement support
2020-09-29 23:30:58 +05:30
statements();
Add new comments and lines
2020-09-30 00:50:00 +05:30
setState(19);
add statement support
2020-09-29 23:30:58 +05:30
_errHandler->sync(this);
_la = _input->LA(1);
}
Add new comments and lines
2020-09-30 00:50:00 +05:30
setState(20);
add statement support
2020-09-29 23:30:58 +05:30
match(bfParser::EOF);
add antlr
2020-09-29 23:16:42 +05:30
}
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) {
}
add statement support
2020-09-29 23:30:58 +05:30
std::vector<bfParser::StatementContext *> bfParser::StatementsContext::statement() {
return getRuleContexts<bfParser::StatementContext>();
add antlr
2020-09-29 23:16:42 +05:30
}
add statement support
2020-09-29 23:30:58 +05:30
bfParser::StatementContext* bfParser::StatementsContext::statement(size_t i) {
return getRuleContext<bfParser::StatementContext>(i);
add antlr
2020-09-29 23:16:42 +05:30
}
Add new comments and lines
2020-09-30 00:50:00 +05:30
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);
}
add antlr
2020-09-29 23:16:42 +05:30
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);
add statement support
2020-09-29 23:30:58 +05:30
auto onExit = finally([=] {
exitRule();
});
try {
size_t alt;
enterOuterAlt(_localctx, 1);
Add new comments and lines
2020-09-30 00:50:00 +05:30
setState(25);
add statement support
2020-09-29 23:30:58 +05:30
_errHandler->sync(this);
alt = 1;
do {
switch (alt) {
case 1: {
Add new comments and lines
2020-09-30 00:50:00 +05:30
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;
}
}
add statement support
2020-09-29 23:30:58 +05:30
break;
}
default:
throw NoViableAltException(this);
}
Add new comments and lines
2020-09-30 00:50:00 +05:30
setState(27);
add statement support
2020-09-29 23:30:58 +05:30
_errHandler->sync(this);
Add new comments and lines
2020-09-30 00:50:00 +05:30
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 2, _ctx);
add statement support
2020-09-29 23:30:58 +05:30
} 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;
}
Add new comments and lines
2020-09-30 00:50:00 +05:30
//----------------- 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;
}
add statement support
2020-09-29 23:30:58 +05:30
//----------------- 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);
}
Add new comments and lines
2020-09-30 00:50:00 +05:30
tree::TerminalNode* bfParser::StatementContext::LEFT() {
return getToken(bfParser::LEFT, 0);
add statement support
2020-09-29 23:30:58 +05:30
}
Add new comments and lines
2020-09-30 00:50:00 +05:30
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);
add statement support
2020-09-29 23:30:58 +05:30
}
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());
Add new comments and lines
2020-09-30 00:50:00 +05:30
enterRule(_localctx, 8, bfParser::RuleStatement);
add antlr
2020-09-29 23:16:42 +05:30
auto onExit = finally([=] {
exitRule();
});
try {
Add new comments and lines
2020-09-30 00:50:00 +05:30
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);
add antlr
2020-09-29 23:16:42 +05:30
}
}
catch (RecognitionException &e) {
_errHandler->reportError(this, e);
_localctx->exception = std::current_exception();
_errHandler->recover(this, _localctx->exception);
}
return _localctx;
}
Add new comments and lines
2020-09-30 00:50:00 +05:30
//----------------- 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;
}
add antlr
2020-09-29 23:16:42 +05:30
// 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 = {
Add new comments and lines
2020-09-30 00:50:00 +05:30
"program", "statements", "loopStmt", "numberedStatement", "statement",
"inputStmt", "outputStmt"
add antlr
2020-09-29 23:16:42 +05:30
};
std::vector<std::string> bfParser::_literalNames = {
Add new comments and lines
2020-09-30 00:50:00 +05:30
"", "'\n'", "", "", "'['", "']'", "", "'?'", "'.'", "'-'", "'+'", "'>'",
"'<'"
add antlr
2020-09-29 23:16:42 +05:30
};
std::vector<std::string> bfParser::_symbolicNames = {
Add new comments and lines
2020-09-30 00:50:00 +05:30
"", "NEWLINE", "COMMENT", "WS", "LOOPSTART", "LOOPEND", "NUMBER", "INPUT",
"OUTPUT", "DEC", "INC", "LEFT", "RIGHT"
add antlr
2020-09-29 23:16:42 +05:30
};
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,
Add new comments and lines
2020-09-30 00:50:00 +05:30
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,
add antlr
2020-09-29 23:16:42 +05:30
};
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;
Reference in New Issue Copy Permalink