atreyabain/bfc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add statement support

Browse Source
This commit is contained in:
Atreya Bain
2020-09-29 23:30:58 +05:30
parent 2b36e74ff5
commit 02505f273e
12 changed files with 251 additions and 88 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
grammar/bf.g4
View File

@@ -1,9 +1,19 @@
grammar bf;
program: statements;
program:
statements* EOF;
statements: INC | DEC | INPUT|OUTPUT;
statements:
statement+;
statement:
INC
| DEC
| INPUT
| OUTPUT
;
NEWLINE: '\n' -> skip;
COMMENT: '\\\\.*?\\\\' -> skip;
INPUT: '?';
OUTPUT: '.';

30
lib/generated/bf.tokens
View File

@@ -1,14 +1,16 @@
COMMENT=1
INPUT=2
OUTPUT=3
DEC=4
INC=5
LEFT=6
RIGHT=7
'\\\\.*?\\\\'=1
'?'=2
'.'=3
'-'=4
'+'=5
'>'=6
'<'=7
NEWLINE=1
COMMENT=2
INPUT=3
OUTPUT=4
DEC=5
INC=6
LEFT=7
RIGHT=8
'\n'=1
'\\\\.*?\\\\'=2
'?'=3
'.'=4
'-'=5
'+'=6
'>'=7
'<'=8

3
lib/generated/bfBaseListener.h
View File

@@ -22,6 +22,9 @@ public:
virtual void enterStatements(bfParser::StatementsContext * /*ctx*/) override { }
virtual void exitStatements(bfParser::StatementsContext * /*ctx*/) override { }
virtual void enterStatement(bfParser::StatementContext * /*ctx*/) override { }
virtual void exitStatement(bfParser::StatementContext * /*ctx*/) override { }
virtual void enterEveryRule(antlr4::ParserRuleContext * /*ctx*/) override { }
virtual void exitEveryRule(antlr4::ParserRuleContext * /*ctx*/) override { }

4
lib/generated/bfBaseVisitor.h
View File

@@ -23,6 +23,10 @@ public:
return visitChildren(ctx);
}
virtual antlrcpp::Any visitStatement(bfParser::StatementContext *ctx) override {
return visitChildren(ctx);
}
};

55
lib/generated/bfLexer.cpp
View File

@@ -60,7 +60,8 @@ atn::ATN bfLexer::_atn;
std::vector<uint16_t> bfLexer::_serializedATN;
std::vector<std::string> bfLexer::_ruleNames = {
u8"COMMENT", u8"INPUT", u8"OUTPUT", u8"DEC", u8"INC", u8"LEFT", u8"RIGHT"
u8"NEWLINE", u8"COMMENT", u8"INPUT", u8"OUTPUT", u8"DEC", u8"INC", u8"LEFT",
u8"RIGHT"
};
std::vector<std::string> bfLexer::_channelNames = {
@@ -72,11 +73,13 @@ std::vector<std::string> bfLexer::_modeNames = {
};
std::vector<std::string> bfLexer::_literalNames = {
"", u8"'\\\\.*?\\\\'", u8"'?'", u8"'.'", u8"'-'", u8"'+'", u8"'>'", u8"'<'"
"", u8"'\n'", u8"'\\\\.*?\\\\'", u8"'?'", u8"'.'", u8"'-'", u8"'+'", u8"'>'",
u8"'<'"
};
std::vector<std::string> bfLexer::_symbolicNames = {
"", u8"COMMENT", u8"INPUT", u8"OUTPUT", u8"DEC", u8"INC", u8"LEFT", u8"RIGHT"
"", u8"NEWLINE", u8"COMMENT", u8"INPUT", u8"OUTPUT", u8"DEC", u8"INC",
u8"LEFT", u8"RIGHT"
};
dfa::Vocabulary bfLexer::_vocabulary(_literalNames, _symbolicNames);
@@ -100,30 +103,34 @@ bfLexer::Initializer::Initializer() {
_serializedATN = {
0x3, 0x608b, 0xa72a, 0x8133, 0xb9ed, 0x417c, 0x3be7, 0x7786, 0x5964,
0x2, 0x9, 0x27, 0x8, 0x1, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x4,
0x2, 0xa, 0x2d, 0x8, 0x1, 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, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3,
0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x3, 0x3,
0x3, 0x3, 0x4, 0x3, 0x4, 0x3, 0x5, 0x3, 0x5, 0x3, 0x6, 0x3, 0x6, 0x3,
0x7, 0x3, 0x7, 0x3, 0x8, 0x3, 0x8, 0x2, 0x2, 0x9, 0x3, 0x3, 0x5, 0x4,
0x7, 0x5, 0x9, 0x6, 0xb, 0x7, 0xd, 0x8, 0xf, 0x9, 0x3, 0x2, 0x2, 0x2,
0x26, 0x2, 0x3, 0x3, 0x2, 0x2, 0x2, 0x2, 0x5, 0x3, 0x2, 0x2, 0x2, 0x2,
0x7, 0x4, 0x8, 0x9, 0x8, 0x4, 0x9, 0x9, 0x9, 0x3, 0x2, 0x3, 0x2, 0x3,
0x2, 0x3, 0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3,
0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x4, 0x3,
0x5, 0x3, 0x5, 0x3, 0x6, 0x3, 0x6, 0x3, 0x7, 0x3, 0x7, 0x3, 0x8, 0x3,
0x8, 0x3, 0x9, 0x3, 0x9, 0x2, 0x2, 0xa, 0x3, 0x3, 0x5, 0x4, 0x7, 0x5,
0x9, 0x6, 0xb, 0x7, 0xd, 0x8, 0xf, 0x9, 0x11, 0xa, 0x3, 0x2, 0x2, 0x2,
0x2c, 0x2, 0x3, 0x3, 0x2, 0x2, 0x2, 0x2, 0x5, 0x3, 0x2, 0x2, 0x2, 0x2,
0x7, 0x3, 0x2, 0x2, 0x2, 0x2, 0x9, 0x3, 0x2, 0x2, 0x2, 0x2, 0xb, 0x3,
0x2, 0x2, 0x2, 0x2, 0xd, 0x3, 0x2, 0x2, 0x2, 0x2, 0xf, 0x3, 0x2, 0x2,
0x2, 0x3, 0x11, 0x3, 0x2, 0x2, 0x2, 0x5, 0x1b, 0x3, 0x2, 0x2, 0x2, 0x7,
0x1d, 0x3, 0x2, 0x2, 0x2, 0x9, 0x1f, 0x3, 0x2, 0x2, 0x2, 0xb, 0x21,
0x3, 0x2, 0x2, 0x2, 0xd, 0x23, 0x3, 0x2, 0x2, 0x2, 0xf, 0x25, 0x3, 0x2,
0x2, 0x2, 0x11, 0x12, 0x7, 0x5e, 0x2, 0x2, 0x12, 0x13, 0x7, 0x5e, 0x2,
0x2, 0x13, 0x14, 0x7, 0x30, 0x2, 0x2, 0x14, 0x15, 0x7, 0x2c, 0x2, 0x2,
0x15, 0x16, 0x7, 0x41, 0x2, 0x2, 0x16, 0x17, 0x7, 0x5e, 0x2, 0x2, 0x17,
0x18, 0x7, 0x5e, 0x2, 0x2, 0x18, 0x19, 0x3, 0x2, 0x2, 0x2, 0x19, 0x1a,
0x8, 0x2, 0x2, 0x2, 0x1a, 0x4, 0x3, 0x2, 0x2, 0x2, 0x1b, 0x1c, 0x7,
0x41, 0x2, 0x2, 0x1c, 0x6, 0x3, 0x2, 0x2, 0x2, 0x1d, 0x1e, 0x7, 0x30,
0x2, 0x2, 0x1e, 0x8, 0x3, 0x2, 0x2, 0x2, 0x1f, 0x20, 0x7, 0x2f, 0x2,
0x2, 0x20, 0xa, 0x3, 0x2, 0x2, 0x2, 0x21, 0x22, 0x7, 0x2d, 0x2, 0x2,
0x22, 0xc, 0x3, 0x2, 0x2, 0x2, 0x23, 0x24, 0x7, 0x40, 0x2, 0x2, 0x24,
0xe, 0x3, 0x2, 0x2, 0x2, 0x25, 0x26, 0x7, 0x3e, 0x2, 0x2, 0x26, 0x10,
0x3, 0x2, 0x2, 0x2, 0x3, 0x2, 0x3, 0x8, 0x2, 0x2,
0x2, 0x2, 0x11, 0x3, 0x2, 0x2, 0x2, 0x3, 0x13, 0x3, 0x2, 0x2, 0x2, 0x5,
0x17, 0x3, 0x2, 0x2, 0x2, 0x7, 0x21, 0x3, 0x2, 0x2, 0x2, 0x9, 0x23,
0x3, 0x2, 0x2, 0x2, 0xb, 0x25, 0x3, 0x2, 0x2, 0x2, 0xd, 0x27, 0x3, 0x2,
0x2, 0x2, 0xf, 0x29, 0x3, 0x2, 0x2, 0x2, 0x11, 0x2b, 0x3, 0x2, 0x2,
0x2, 0x13, 0x14, 0x7, 0xc, 0x2, 0x2, 0x14, 0x15, 0x3, 0x2, 0x2, 0x2,
0x15, 0x16, 0x8, 0x2, 0x2, 0x2, 0x16, 0x4, 0x3, 0x2, 0x2, 0x2, 0x17,
0x18, 0x7, 0x5e, 0x2, 0x2, 0x18, 0x19, 0x7, 0x5e, 0x2, 0x2, 0x19, 0x1a,
0x7, 0x30, 0x2, 0x2, 0x1a, 0x1b, 0x7, 0x2c, 0x2, 0x2, 0x1b, 0x1c, 0x7,
0x41, 0x2, 0x2, 0x1c, 0x1d, 0x7, 0x5e, 0x2, 0x2, 0x1d, 0x1e, 0x7, 0x5e,
0x2, 0x2, 0x1e, 0x1f, 0x3, 0x2, 0x2, 0x2, 0x1f, 0x20, 0x8, 0x3, 0x2,
0x2, 0x20, 0x6, 0x3, 0x2, 0x2, 0x2, 0x21, 0x22, 0x7, 0x41, 0x2, 0x2,
0x22, 0x8, 0x3, 0x2, 0x2, 0x2, 0x23, 0x24, 0x7, 0x30, 0x2, 0x2, 0x24,
0xa, 0x3, 0x2, 0x2, 0x2, 0x25, 0x26, 0x7, 0x2f, 0x2, 0x2, 0x26, 0xc,
0x3, 0x2, 0x2, 0x2, 0x27, 0x28, 0x7, 0x2d, 0x2, 0x2, 0x28, 0xe, 0x3,
0x2, 0x2, 0x2, 0x29, 0x2a, 0x7, 0x40, 0x2, 0x2, 0x2a, 0x10, 0x3, 0x2,
0x2, 0x2, 0x2b, 0x2c, 0x7, 0x3e, 0x2, 0x2, 0x2c, 0x12, 0x3, 0x2, 0x2,
0x2, 0x3, 0x2, 0x3, 0x8, 0x2, 0x2,
};
atn::ATNDeserializer deserializer;

3
lib/generated/bfLexer.h
View File

@@ -12,7 +12,8 @@
class bfLexer : public antlr4::Lexer {
public:
enum {
COMMENT = 1, INPUT = 2, OUTPUT = 3, DEC = 4, INC = 5, LEFT = 6, RIGHT = 7
NEWLINE = 1, COMMENT = 2, INPUT = 3, OUTPUT = 4, DEC = 5, INC = 6, LEFT = 7,
RIGHT = 8
};
bfLexer(antlr4::CharStream *input);

30
lib/generated/bfLexer.tokens
View File

@@ -1,14 +1,16 @@
COMMENT=1
INPUT=2
OUTPUT=3
DEC=4
INC=5
LEFT=6
RIGHT=7
'\\\\.*?\\\\'=1
'?'=2
'.'=3
'-'=4
'+'=5
'>'=6
'<'=7
NEWLINE=1
COMMENT=2
INPUT=3
OUTPUT=4
DEC=5
INC=6
LEFT=7
RIGHT=8
'\n'=1
'\\\\.*?\\\\'=2
'?'=3
'.'=4
'-'=5
'+'=6
'>'=7
'<'=8

3
lib/generated/bfListener.h
View File

@@ -20,6 +20,9 @@ public:
virtual void enterStatements(bfParser::StatementsContext *ctx) = 0;
virtual void exitStatements(bfParser::StatementsContext *ctx) = 0;
virtual void enterStatement(bfParser::StatementContext *ctx) = 0;
virtual void exitStatement(bfParser::StatementContext *ctx) = 0;
};

159
lib/generated/bfParser.cpp
View File

@@ -38,8 +38,16 @@ bfParser::ProgramContext::ProgramContext(ParserRuleContext *parent, size_t invok
: ParserRuleContext(parent, invokingState) {
}
bfParser::StatementsContext* bfParser::ProgramContext::statements() {
return getRuleContext<bfParser::StatementsContext>(0);
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);
}
@@ -70,14 +78,29 @@ antlrcpp::Any bfParser::ProgramContext::accept(tree::ParseTreeVisitor *visitor)
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(4);
setState(9);
_errHandler->sync(this);
_la = _input->LA(1);
while ((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << bfParser::INPUT)
| (1ULL << bfParser::OUTPUT)
| (1ULL << bfParser::DEC)
| (1ULL << bfParser::INC))) != 0)) {
setState(6);
statements();
setState(11);
_errHandler->sync(this);
_la = _input->LA(1);
}
setState(12);
match(bfParser::EOF);
}
catch (RecognitionException &e) {
@@ -95,20 +118,12 @@ bfParser::StatementsContext::StatementsContext(ParserRuleContext *parent, size_t
: ParserRuleContext(parent, invokingState) {
}
tree::TerminalNode* bfParser::StatementsContext::INC() {
return getToken(bfParser::INC, 0);
std::vector<bfParser::StatementContext *> bfParser::StatementsContext::statement() {
return getRuleContexts<bfParser::StatementContext>();
}
tree::TerminalNode* bfParser::StatementsContext::DEC() {
return getToken(bfParser::DEC, 0);
}
tree::TerminalNode* bfParser::StatementsContext::INPUT() {
return getToken(bfParser::INPUT, 0);
}
tree::TerminalNode* bfParser::StatementsContext::OUTPUT() {
return getToken(bfParser::OUTPUT, 0);
bfParser::StatementContext* bfParser::StatementsContext::statement(size_t i) {
return getRuleContext<bfParser::StatementContext>(i);
}
@@ -139,6 +154,92 @@ antlrcpp::Any bfParser::StatementsContext::accept(tree::ParseTreeVisitor *visito
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(15);
_errHandler->sync(this);
alt = 1;
do {
switch (alt) {
case 1: {
setState(14);
statement();
break;
}
default:
throw NoViableAltException(this);
}
setState(17);
_errHandler->sync(this);
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1, _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;
}
//----------------- 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::INPUT() {
return getToken(bfParser::INPUT, 0);
}
tree::TerminalNode* bfParser::StatementContext::OUTPUT() {
return getToken(bfParser::OUTPUT, 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, 4, bfParser::RuleStatement);
size_t _la = 0;
auto onExit = finally([=] {
@@ -146,7 +247,7 @@ bfParser::StatementsContext* bfParser::statements() {
});
try {
enterOuterAlt(_localctx, 1);
setState(6);
setState(19);
_la = _input->LA(1);
if (!((((_la & ~ 0x3fULL) == 0) &&
((1ULL << _la) & ((1ULL << bfParser::INPUT)
@@ -179,15 +280,15 @@ atn::ATN bfParser::_atn;
std::vector<uint16_t> bfParser::_serializedATN;
std::vector<std::string> bfParser::_ruleNames = {
"program", "statements"
"program", "statements", "statement"
};
std::vector<std::string> bfParser::_literalNames = {
"", "'\\\\.*?\\\\'", "'?'", "'.'", "'-'", "'+'", "'>'", "'<'"
"", "'\n'", "'\\\\.*?\\\\'", "'?'", "'.'", "'-'", "'+'", "'>'", "'<'"
};
std::vector<std::string> bfParser::_symbolicNames = {
"", "COMMENT", "INPUT", "OUTPUT", "DEC", "INC", "LEFT", "RIGHT"
"", "NEWLINE", "COMMENT", "INPUT", "OUTPUT", "DEC", "INC", "LEFT", "RIGHT"
};
dfa::Vocabulary bfParser::_vocabulary(_literalNames, _symbolicNames);
@@ -210,12 +311,20 @@ bfParser::Initializer::Initializer() {
_serializedATN = {
0x3, 0x608b, 0xa72a, 0x8133, 0xb9ed, 0x417c, 0x3be7, 0x7786, 0x5964,
0x3, 0x9, 0xb, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x3, 0x2, 0x3,
0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x2, 0x2, 0x4, 0x2, 0x4, 0x2, 0x3,
0x3, 0x2, 0x4, 0x7, 0x2, 0x8, 0x2, 0x6, 0x3, 0x2, 0x2, 0x2, 0x4, 0x8,
0x3, 0x2, 0x2, 0x2, 0x6, 0x7, 0x5, 0x4, 0x3, 0x2, 0x7, 0x3, 0x3, 0x2,
0x2, 0x2, 0x8, 0x9, 0x9, 0x2, 0x2, 0x2, 0x9, 0x5, 0x3, 0x2, 0x2, 0x2,
0x2,
0x3, 0xa, 0x18, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x4, 0x4, 0x9,
0x4, 0x3, 0x2, 0x7, 0x2, 0xa, 0xa, 0x2, 0xc, 0x2, 0xe, 0x2, 0xd, 0xb,
0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x3, 0x6, 0x3, 0x12, 0xa, 0x3, 0xd, 0x3,
0xe, 0x3, 0x13, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x2, 0x2, 0x5, 0x2, 0x4,
0x6, 0x2, 0x3, 0x3, 0x2, 0x5, 0x8, 0x2, 0x16, 0x2, 0xb, 0x3, 0x2, 0x2,
0x2, 0x4, 0x11, 0x3, 0x2, 0x2, 0x2, 0x6, 0x15, 0x3, 0x2, 0x2, 0x2, 0x8,
0xa, 0x5, 0x4, 0x3, 0x2, 0x9, 0x8, 0x3, 0x2, 0x2, 0x2, 0xa, 0xd, 0x3,
0x2, 0x2, 0x2, 0xb, 0x9, 0x3, 0x2, 0x2, 0x2, 0xb, 0xc, 0x3, 0x2, 0x2,
0x2, 0xc, 0xe, 0x3, 0x2, 0x2, 0x2, 0xd, 0xb, 0x3, 0x2, 0x2, 0x2, 0xe,
0xf, 0x7, 0x2, 0x2, 0x3, 0xf, 0x3, 0x3, 0x2, 0x2, 0x2, 0x10, 0x12, 0x5,
0x6, 0x4, 0x2, 0x11, 0x10, 0x3, 0x2, 0x2, 0x2, 0x12, 0x13, 0x3, 0x2,
0x2, 0x2, 0x13, 0x11, 0x3, 0x2, 0x2, 0x2, 0x13, 0x14, 0x3, 0x2, 0x2,
0x2, 0x14, 0x5, 0x3, 0x2, 0x2, 0x2, 0x15, 0x16, 0x9, 0x2, 0x2, 0x2,
0x16, 0x7, 0x3, 0x2, 0x2, 0x2, 0x4, 0xb, 0x13,
};
atn::ATNDeserializer deserializer;

28
lib/generated/bfParser.h
View File

@@ -12,11 +12,12 @@
class bfParser : public antlr4::Parser {
public:
enum {
COMMENT = 1, INPUT = 2, OUTPUT = 3, DEC = 4, INC = 5, LEFT = 6, RIGHT = 7
NEWLINE = 1, COMMENT = 2, INPUT = 3, OUTPUT = 4, DEC = 5, INC = 6, LEFT = 7,
RIGHT = 8
};
enum {
RuleProgram = 0, RuleStatements = 1
RuleProgram = 0, RuleStatements = 1, RuleStatement = 2
};
bfParser(antlr4::TokenStream *input);
@@ -31,12 +32,15 @@ public:
class ProgramContext;
class StatementsContext;
class StatementContext;
class ProgramContext : public antlr4::ParserRuleContext {
public:
ProgramContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
StatementsContext *statements();
antlr4::tree::TerminalNode *EOF();
std::vector<StatementsContext *> statements();
StatementsContext* statements(size_t i);
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
@@ -51,6 +55,22 @@ public:
public:
StatementsContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
std::vector<StatementContext *> statement();
StatementContext* statement(size_t i);
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
virtual antlrcpp::Any accept(antlr4::tree::ParseTreeVisitor *visitor) override;
};
StatementsContext* statements();
class StatementContext : public antlr4::ParserRuleContext {
public:
StatementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
virtual size_t getRuleIndex() const override;
antlr4::tree::TerminalNode *INC();
antlr4::tree::TerminalNode *DEC();
antlr4::tree::TerminalNode *INPUT();
@@ -63,7 +83,7 @@ public:
};
StatementsContext* statements();
StatementContext* statement();
private:

2
lib/generated/bfVisitor.h
View File

@@ -23,6 +23,8 @@ public:
virtual antlrcpp::Any visitStatements(bfParser::StatementsContext *context) = 0;
virtual antlrcpp::Any visitStatement(bfParser::StatementContext *context) = 0;
};

4
src/main.cpp
View File

@@ -10,8 +10,8 @@ using namespace antlr4;
class expressionListener : public bfBaseListener{
public:
void enterProgram(bfParser::ProgramContext *ctx) override{
std::cout<<ctx->getText();
void enterStatements(bfParser::StatementsContext *ctx) override{
std::cout<<ctx->getText()<<std::endl;
}
};