Add new comments and lines
This commit is contained in:
@@ -1,16 +1,21 @@
|
||||
NEWLINE=1
|
||||
COMMENT=2
|
||||
INPUT=3
|
||||
OUTPUT=4
|
||||
DEC=5
|
||||
INC=6
|
||||
LEFT=7
|
||||
RIGHT=8
|
||||
WS=3
|
||||
LOOPSTART=4
|
||||
LOOPEND=5
|
||||
NUMBER=6
|
||||
INPUT=7
|
||||
OUTPUT=8
|
||||
DEC=9
|
||||
INC=10
|
||||
LEFT=11
|
||||
RIGHT=12
|
||||
'\n'=1
|
||||
'\\\\.*?\\\\'=2
|
||||
'?'=3
|
||||
'.'=4
|
||||
'-'=5
|
||||
'+'=6
|
||||
'>'=7
|
||||
'<'=8
|
||||
'['=4
|
||||
']'=5
|
||||
'?'=7
|
||||
'.'=8
|
||||
'-'=9
|
||||
'+'=10
|
||||
'>'=11
|
||||
'<'=12
|
||||
|
||||
@@ -22,9 +22,21 @@ public:
|
||||
virtual void enterStatements(bfParser::StatementsContext * /*ctx*/) override { }
|
||||
virtual void exitStatements(bfParser::StatementsContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterLoopStmt(bfParser::LoopStmtContext * /*ctx*/) override { }
|
||||
virtual void exitLoopStmt(bfParser::LoopStmtContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterNumberedStatement(bfParser::NumberedStatementContext * /*ctx*/) override { }
|
||||
virtual void exitNumberedStatement(bfParser::NumberedStatementContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterStatement(bfParser::StatementContext * /*ctx*/) override { }
|
||||
virtual void exitStatement(bfParser::StatementContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterInputStmt(bfParser::InputStmtContext * /*ctx*/) override { }
|
||||
virtual void exitInputStmt(bfParser::InputStmtContext * /*ctx*/) override { }
|
||||
|
||||
virtual void enterOutputStmt(bfParser::OutputStmtContext * /*ctx*/) override { }
|
||||
virtual void exitOutputStmt(bfParser::OutputStmtContext * /*ctx*/) override { }
|
||||
|
||||
|
||||
virtual void enterEveryRule(antlr4::ParserRuleContext * /*ctx*/) override { }
|
||||
virtual void exitEveryRule(antlr4::ParserRuleContext * /*ctx*/) override { }
|
||||
|
||||
@@ -23,10 +23,26 @@ public:
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual antlrcpp::Any visitLoopStmt(bfParser::LoopStmtContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual antlrcpp::Any visitNumberedStatement(bfParser::NumberedStatementContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual antlrcpp::Any visitStatement(bfParser::StatementContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual antlrcpp::Any visitInputStmt(bfParser::InputStmtContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
virtual antlrcpp::Any visitOutputStmt(bfParser::OutputStmtContext *ctx) override {
|
||||
return visitChildren(ctx);
|
||||
}
|
||||
|
||||
|
||||
};
|
||||
|
||||
|
||||
@@ -60,8 +60,8 @@ atn::ATN bfLexer::_atn;
|
||||
std::vector<uint16_t> bfLexer::_serializedATN;
|
||||
|
||||
std::vector<std::string> bfLexer::_ruleNames = {
|
||||
u8"NEWLINE", u8"COMMENT", u8"INPUT", u8"OUTPUT", u8"DEC", u8"INC", u8"LEFT",
|
||||
u8"RIGHT"
|
||||
u8"NEWLINE", u8"COMMENT", u8"WS", u8"LOOPSTART", u8"LOOPEND", u8"NUMBER",
|
||||
u8"INPUT", u8"OUTPUT", u8"DEC", u8"INC", u8"LEFT", u8"RIGHT"
|
||||
};
|
||||
|
||||
std::vector<std::string> bfLexer::_channelNames = {
|
||||
@@ -73,13 +73,13 @@ std::vector<std::string> bfLexer::_modeNames = {
|
||||
};
|
||||
|
||||
std::vector<std::string> bfLexer::_literalNames = {
|
||||
"", u8"'\n'", u8"'\\\\.*?\\\\'", u8"'?'", u8"'.'", u8"'-'", u8"'+'", u8"'>'",
|
||||
u8"'<'"
|
||||
"", u8"'\n'", "", "", u8"'['", u8"']'", "", u8"'?'", u8"'.'", u8"'-'",
|
||||
u8"'+'", u8"'>'", u8"'<'"
|
||||
};
|
||||
|
||||
std::vector<std::string> bfLexer::_symbolicNames = {
|
||||
"", u8"NEWLINE", u8"COMMENT", u8"INPUT", u8"OUTPUT", u8"DEC", u8"INC",
|
||||
u8"LEFT", u8"RIGHT"
|
||||
"", u8"NEWLINE", u8"COMMENT", u8"WS", u8"LOOPSTART", u8"LOOPEND", u8"NUMBER",
|
||||
u8"INPUT", u8"OUTPUT", u8"DEC", u8"INC", u8"LEFT", u8"RIGHT"
|
||||
};
|
||||
|
||||
dfa::Vocabulary bfLexer::_vocabulary(_literalNames, _symbolicNames);
|
||||
@@ -103,34 +103,56 @@ bfLexer::Initializer::Initializer() {
|
||||
|
||||
_serializedATN = {
|
||||
0x3, 0x608b, 0xa72a, 0x8133, 0xb9ed, 0x417c, 0x3be7, 0x7786, 0x5964,
|
||||
0x2, 0xa, 0x2d, 0x8, 0x1, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x4,
|
||||
0x2, 0xe, 0x49, 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, 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, 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,
|
||||
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, 0x3, 0x2, 0x3,
|
||||
0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x7,
|
||||
0x3, 0x24, 0xa, 0x3, 0xc, 0x3, 0xe, 0x3, 0x27, 0xb, 0x3, 0x3, 0x3, 0x5,
|
||||
0x3, 0x2a, 0xa, 0x3, 0x3, 0x3, 0x5, 0x3, 0x2d, 0xa, 0x3, 0x3, 0x3, 0x3,
|
||||
0x3, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x5, 0x3, 0x5, 0x3,
|
||||
0x6, 0x3, 0x6, 0x3, 0x7, 0x6, 0x7, 0x3a, 0xa, 0x7, 0xd, 0x7, 0xe, 0x7,
|
||||
0x3b, 0x3, 0x8, 0x3, 0x8, 0x3, 0x9, 0x3, 0x9, 0x3, 0xa, 0x3, 0xa, 0x3,
|
||||
0xb, 0x3, 0xb, 0x3, 0xc, 0x3, 0xc, 0x3, 0xd, 0x3, 0xd, 0x2, 0x2, 0xe,
|
||||
0x3, 0x3, 0x5, 0x4, 0x7, 0x5, 0x9, 0x6, 0xb, 0x7, 0xd, 0x8, 0xf, 0x9,
|
||||
0x11, 0xa, 0x13, 0xb, 0x15, 0xc, 0x17, 0xd, 0x19, 0xe, 0x3, 0x2, 0x5,
|
||||
0x4, 0x2, 0xc, 0xc, 0xf, 0xf, 0x5, 0x2, 0xc, 0xc, 0xf, 0xf, 0x22, 0x22,
|
||||
0x3, 0x2, 0x32, 0x3b, 0x2, 0x4c, 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, 0x2, 0x11, 0x3, 0x2, 0x2, 0x2, 0x2,
|
||||
0x13, 0x3, 0x2, 0x2, 0x2, 0x2, 0x15, 0x3, 0x2, 0x2, 0x2, 0x2, 0x17,
|
||||
0x3, 0x2, 0x2, 0x2, 0x2, 0x19, 0x3, 0x2, 0x2, 0x2, 0x3, 0x1b, 0x3, 0x2,
|
||||
0x2, 0x2, 0x5, 0x1f, 0x3, 0x2, 0x2, 0x2, 0x7, 0x30, 0x3, 0x2, 0x2, 0x2,
|
||||
0x9, 0x34, 0x3, 0x2, 0x2, 0x2, 0xb, 0x36, 0x3, 0x2, 0x2, 0x2, 0xd, 0x39,
|
||||
0x3, 0x2, 0x2, 0x2, 0xf, 0x3d, 0x3, 0x2, 0x2, 0x2, 0x11, 0x3f, 0x3,
|
||||
0x2, 0x2, 0x2, 0x13, 0x41, 0x3, 0x2, 0x2, 0x2, 0x15, 0x43, 0x3, 0x2,
|
||||
0x2, 0x2, 0x17, 0x45, 0x3, 0x2, 0x2, 0x2, 0x19, 0x47, 0x3, 0x2, 0x2,
|
||||
0x2, 0x1b, 0x1c, 0x7, 0xc, 0x2, 0x2, 0x1c, 0x1d, 0x3, 0x2, 0x2, 0x2,
|
||||
0x1d, 0x1e, 0x8, 0x2, 0x2, 0x2, 0x1e, 0x4, 0x3, 0x2, 0x2, 0x2, 0x1f,
|
||||
0x20, 0x7, 0x31, 0x2, 0x2, 0x20, 0x21, 0x7, 0x31, 0x2, 0x2, 0x21, 0x25,
|
||||
0x3, 0x2, 0x2, 0x2, 0x22, 0x24, 0xa, 0x2, 0x2, 0x2, 0x23, 0x22, 0x3,
|
||||
0x2, 0x2, 0x2, 0x24, 0x27, 0x3, 0x2, 0x2, 0x2, 0x25, 0x23, 0x3, 0x2,
|
||||
0x2, 0x2, 0x25, 0x26, 0x3, 0x2, 0x2, 0x2, 0x26, 0x29, 0x3, 0x2, 0x2,
|
||||
0x2, 0x27, 0x25, 0x3, 0x2, 0x2, 0x2, 0x28, 0x2a, 0x7, 0xf, 0x2, 0x2,
|
||||
0x29, 0x28, 0x3, 0x2, 0x2, 0x2, 0x29, 0x2a, 0x3, 0x2, 0x2, 0x2, 0x2a,
|
||||
0x2c, 0x3, 0x2, 0x2, 0x2, 0x2b, 0x2d, 0x7, 0xc, 0x2, 0x2, 0x2c, 0x2b,
|
||||
0x3, 0x2, 0x2, 0x2, 0x2c, 0x2d, 0x3, 0x2, 0x2, 0x2, 0x2d, 0x2e, 0x3,
|
||||
0x2, 0x2, 0x2, 0x2e, 0x2f, 0x8, 0x3, 0x3, 0x2, 0x2f, 0x6, 0x3, 0x2,
|
||||
0x2, 0x2, 0x30, 0x31, 0x9, 0x3, 0x2, 0x2, 0x31, 0x32, 0x3, 0x2, 0x2,
|
||||
0x2, 0x32, 0x33, 0x8, 0x4, 0x2, 0x2, 0x33, 0x8, 0x3, 0x2, 0x2, 0x2,
|
||||
0x34, 0x35, 0x7, 0x5d, 0x2, 0x2, 0x35, 0xa, 0x3, 0x2, 0x2, 0x2, 0x36,
|
||||
0x37, 0x7, 0x5f, 0x2, 0x2, 0x37, 0xc, 0x3, 0x2, 0x2, 0x2, 0x38, 0x3a,
|
||||
0x9, 0x4, 0x2, 0x2, 0x39, 0x38, 0x3, 0x2, 0x2, 0x2, 0x3a, 0x3b, 0x3,
|
||||
0x2, 0x2, 0x2, 0x3b, 0x39, 0x3, 0x2, 0x2, 0x2, 0x3b, 0x3c, 0x3, 0x2,
|
||||
0x2, 0x2, 0x3c, 0xe, 0x3, 0x2, 0x2, 0x2, 0x3d, 0x3e, 0x7, 0x41, 0x2,
|
||||
0x2, 0x3e, 0x10, 0x3, 0x2, 0x2, 0x2, 0x3f, 0x40, 0x7, 0x30, 0x2, 0x2,
|
||||
0x40, 0x12, 0x3, 0x2, 0x2, 0x2, 0x41, 0x42, 0x7, 0x2f, 0x2, 0x2, 0x42,
|
||||
0x14, 0x3, 0x2, 0x2, 0x2, 0x43, 0x44, 0x7, 0x2d, 0x2, 0x2, 0x44, 0x16,
|
||||
0x3, 0x2, 0x2, 0x2, 0x45, 0x46, 0x7, 0x40, 0x2, 0x2, 0x46, 0x18, 0x3,
|
||||
0x2, 0x2, 0x2, 0x47, 0x48, 0x7, 0x3e, 0x2, 0x2, 0x48, 0x1a, 0x3, 0x2,
|
||||
0x2, 0x2, 0x7, 0x2, 0x25, 0x29, 0x2c, 0x3b, 0x4, 0x8, 0x2, 0x2, 0x2,
|
||||
0x3, 0x2,
|
||||
};
|
||||
|
||||
atn::ATNDeserializer deserializer;
|
||||
|
||||
@@ -12,8 +12,8 @@
|
||||
class bfLexer : public antlr4::Lexer {
|
||||
public:
|
||||
enum {
|
||||
NEWLINE = 1, COMMENT = 2, INPUT = 3, OUTPUT = 4, DEC = 5, INC = 6, LEFT = 7,
|
||||
RIGHT = 8
|
||||
NEWLINE = 1, COMMENT = 2, WS = 3, LOOPSTART = 4, LOOPEND = 5, NUMBER = 6,
|
||||
INPUT = 7, OUTPUT = 8, DEC = 9, INC = 10, LEFT = 11, RIGHT = 12
|
||||
};
|
||||
|
||||
bfLexer(antlr4::CharStream *input);
|
||||
|
||||
@@ -1,16 +1,21 @@
|
||||
NEWLINE=1
|
||||
COMMENT=2
|
||||
INPUT=3
|
||||
OUTPUT=4
|
||||
DEC=5
|
||||
INC=6
|
||||
LEFT=7
|
||||
RIGHT=8
|
||||
WS=3
|
||||
LOOPSTART=4
|
||||
LOOPEND=5
|
||||
NUMBER=6
|
||||
INPUT=7
|
||||
OUTPUT=8
|
||||
DEC=9
|
||||
INC=10
|
||||
LEFT=11
|
||||
RIGHT=12
|
||||
'\n'=1
|
||||
'\\\\.*?\\\\'=2
|
||||
'?'=3
|
||||
'.'=4
|
||||
'-'=5
|
||||
'+'=6
|
||||
'>'=7
|
||||
'<'=8
|
||||
'['=4
|
||||
']'=5
|
||||
'?'=7
|
||||
'.'=8
|
||||
'-'=9
|
||||
'+'=10
|
||||
'>'=11
|
||||
'<'=12
|
||||
|
||||
@@ -20,9 +20,21 @@ public:
|
||||
virtual void enterStatements(bfParser::StatementsContext *ctx) = 0;
|
||||
virtual void exitStatements(bfParser::StatementsContext *ctx) = 0;
|
||||
|
||||
virtual void enterLoopStmt(bfParser::LoopStmtContext *ctx) = 0;
|
||||
virtual void exitLoopStmt(bfParser::LoopStmtContext *ctx) = 0;
|
||||
|
||||
virtual void enterNumberedStatement(bfParser::NumberedStatementContext *ctx) = 0;
|
||||
virtual void exitNumberedStatement(bfParser::NumberedStatementContext *ctx) = 0;
|
||||
|
||||
virtual void enterStatement(bfParser::StatementContext *ctx) = 0;
|
||||
virtual void exitStatement(bfParser::StatementContext *ctx) = 0;
|
||||
|
||||
virtual void enterInputStmt(bfParser::InputStmtContext *ctx) = 0;
|
||||
virtual void exitInputStmt(bfParser::InputStmtContext *ctx) = 0;
|
||||
|
||||
virtual void enterOutputStmt(bfParser::OutputStmtContext *ctx) = 0;
|
||||
virtual void exitOutputStmt(bfParser::OutputStmtContext *ctx) = 0;
|
||||
|
||||
|
||||
};
|
||||
|
||||
|
||||
@@ -85,21 +85,24 @@ bfParser::ProgramContext* bfParser::program() {
|
||||
});
|
||||
try {
|
||||
enterOuterAlt(_localctx, 1);
|
||||
setState(9);
|
||||
setState(17);
|
||||
_errHandler->sync(this);
|
||||
_la = _input->LA(1);
|
||||
while ((((_la & ~ 0x3fULL) == 0) &&
|
||||
((1ULL << _la) & ((1ULL << bfParser::INPUT)
|
||||
((1ULL << _la) & ((1ULL << bfParser::LOOPSTART)
|
||||
| (1ULL << bfParser::INPUT)
|
||||
| (1ULL << bfParser::OUTPUT)
|
||||
| (1ULL << bfParser::DEC)
|
||||
| (1ULL << bfParser::INC))) != 0)) {
|
||||
setState(6);
|
||||
| (1ULL << bfParser::INC)
|
||||
| (1ULL << bfParser::LEFT)
|
||||
| (1ULL << bfParser::RIGHT))) != 0)) {
|
||||
setState(14);
|
||||
statements();
|
||||
setState(11);
|
||||
setState(19);
|
||||
_errHandler->sync(this);
|
||||
_la = _input->LA(1);
|
||||
}
|
||||
setState(12);
|
||||
setState(20);
|
||||
match(bfParser::EOF);
|
||||
|
||||
}
|
||||
@@ -126,6 +129,22 @@ 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;
|
||||
@@ -161,23 +180,43 @@ bfParser::StatementsContext* bfParser::statements() {
|
||||
try {
|
||||
size_t alt;
|
||||
enterOuterAlt(_localctx, 1);
|
||||
setState(15);
|
||||
setState(25);
|
||||
_errHandler->sync(this);
|
||||
alt = 1;
|
||||
do {
|
||||
switch (alt) {
|
||||
case 1: {
|
||||
setState(14);
|
||||
statement();
|
||||
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(17);
|
||||
setState(27);
|
||||
_errHandler->sync(this);
|
||||
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1, _ctx);
|
||||
alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 2, _ctx);
|
||||
} while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
|
||||
|
||||
}
|
||||
@@ -190,6 +229,138 @@ bfParser::StatementsContext* bfParser::statements() {
|
||||
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)
|
||||
@@ -204,12 +375,20 @@ tree::TerminalNode* bfParser::StatementContext::DEC() {
|
||||
return getToken(bfParser::DEC, 0);
|
||||
}
|
||||
|
||||
tree::TerminalNode* bfParser::StatementContext::INPUT() {
|
||||
return getToken(bfParser::INPUT, 0);
|
||||
tree::TerminalNode* bfParser::StatementContext::LEFT() {
|
||||
return getToken(bfParser::LEFT, 0);
|
||||
}
|
||||
|
||||
tree::TerminalNode* bfParser::StatementContext::OUTPUT() {
|
||||
return getToken(bfParser::OUTPUT, 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);
|
||||
}
|
||||
|
||||
|
||||
@@ -239,27 +418,174 @@ antlrcpp::Any bfParser::StatementContext::accept(tree::ParseTreeVisitor *visitor
|
||||
|
||||
bfParser::StatementContext* bfParser::statement() {
|
||||
StatementContext *_localctx = _tracker.createInstance<StatementContext>(_ctx, getState());
|
||||
enterRule(_localctx, 4, bfParser::RuleStatement);
|
||||
size_t _la = 0;
|
||||
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(19);
|
||||
_la = _input->LA(1);
|
||||
if (!((((_la & ~ 0x3fULL) == 0) &&
|
||||
((1ULL << _la) & ((1ULL << bfParser::INPUT)
|
||||
| (1ULL << bfParser::OUTPUT)
|
||||
| (1ULL << bfParser::DEC)
|
||||
| (1ULL << bfParser::INC))) != 0))) {
|
||||
_errHandler->recoverInline(this);
|
||||
}
|
||||
else {
|
||||
_errHandler->reportMatch(this);
|
||||
consume();
|
||||
}
|
||||
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) {
|
||||
@@ -280,15 +606,18 @@ atn::ATN bfParser::_atn;
|
||||
std::vector<uint16_t> bfParser::_serializedATN;
|
||||
|
||||
std::vector<std::string> bfParser::_ruleNames = {
|
||||
"program", "statements", "statement"
|
||||
"program", "statements", "loopStmt", "numberedStatement", "statement",
|
||||
"inputStmt", "outputStmt"
|
||||
};
|
||||
|
||||
std::vector<std::string> bfParser::_literalNames = {
|
||||
"", "'\n'", "'\\\\.*?\\\\'", "'?'", "'.'", "'-'", "'+'", "'>'", "'<'"
|
||||
"", "'\n'", "", "", "'['", "']'", "", "'?'", "'.'", "'-'", "'+'", "'>'",
|
||||
"'<'"
|
||||
};
|
||||
|
||||
std::vector<std::string> bfParser::_symbolicNames = {
|
||||
"", "NEWLINE", "COMMENT", "INPUT", "OUTPUT", "DEC", "INC", "LEFT", "RIGHT"
|
||||
"", "NEWLINE", "COMMENT", "WS", "LOOPSTART", "LOOPEND", "NUMBER", "INPUT",
|
||||
"OUTPUT", "DEC", "INC", "LEFT", "RIGHT"
|
||||
};
|
||||
|
||||
dfa::Vocabulary bfParser::_vocabulary(_literalNames, _symbolicNames);
|
||||
@@ -311,20 +640,38 @@ bfParser::Initializer::Initializer() {
|
||||
|
||||
_serializedATN = {
|
||||
0x3, 0x608b, 0xa72a, 0x8133, 0xb9ed, 0x417c, 0x3be7, 0x7786, 0x5964,
|
||||
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,
|
||||
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;
|
||||
|
||||
@@ -12,12 +12,13 @@
|
||||
class bfParser : public antlr4::Parser {
|
||||
public:
|
||||
enum {
|
||||
NEWLINE = 1, COMMENT = 2, INPUT = 3, OUTPUT = 4, DEC = 5, INC = 6, LEFT = 7,
|
||||
RIGHT = 8
|
||||
NEWLINE = 1, COMMENT = 2, WS = 3, LOOPSTART = 4, LOOPEND = 5, NUMBER = 6,
|
||||
INPUT = 7, OUTPUT = 8, DEC = 9, INC = 10, LEFT = 11, RIGHT = 12
|
||||
};
|
||||
|
||||
enum {
|
||||
RuleProgram = 0, RuleStatements = 1, RuleStatement = 2
|
||||
RuleProgram = 0, RuleStatements = 1, RuleLoopStmt = 2, RuleNumberedStatement = 3,
|
||||
RuleStatement = 4, RuleInputStmt = 5, RuleOutputStmt = 6
|
||||
};
|
||||
|
||||
bfParser(antlr4::TokenStream *input);
|
||||
@@ -32,7 +33,11 @@ public:
|
||||
|
||||
class ProgramContext;
|
||||
class StatementsContext;
|
||||
class StatementContext;
|
||||
class LoopStmtContext;
|
||||
class NumberedStatementContext;
|
||||
class StatementContext;
|
||||
class InputStmtContext;
|
||||
class OutputStmtContext;
|
||||
|
||||
class ProgramContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
@@ -57,6 +62,10 @@ public:
|
||||
virtual size_t getRuleIndex() const override;
|
||||
std::vector<StatementContext *> statement();
|
||||
StatementContext* statement(size_t i);
|
||||
std::vector<NumberedStatementContext *> numberedStatement();
|
||||
NumberedStatementContext* numberedStatement(size_t i);
|
||||
std::vector<LoopStmtContext *> loopStmt();
|
||||
LoopStmtContext* loopStmt(size_t i);
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
@@ -67,14 +76,49 @@ public:
|
||||
|
||||
StatementsContext* statements();
|
||||
|
||||
class LoopStmtContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
LoopStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
antlr4::tree::TerminalNode *LOOPSTART();
|
||||
StatementsContext *statements();
|
||||
antlr4::tree::TerminalNode *LOOPEND();
|
||||
|
||||
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;
|
||||
|
||||
};
|
||||
|
||||
LoopStmtContext* loopStmt();
|
||||
|
||||
class NumberedStatementContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
NumberedStatementContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
StatementContext *statement();
|
||||
antlr4::tree::TerminalNode *NUMBER();
|
||||
|
||||
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;
|
||||
|
||||
};
|
||||
|
||||
NumberedStatementContext* numberedStatement();
|
||||
|
||||
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();
|
||||
antlr4::tree::TerminalNode *OUTPUT();
|
||||
antlr4::tree::TerminalNode *LEFT();
|
||||
antlr4::tree::TerminalNode *RIGHT();
|
||||
InputStmtContext *inputStmt();
|
||||
OutputStmtContext *outputStmt();
|
||||
|
||||
virtual void enterRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
virtual void exitRule(antlr4::tree::ParseTreeListener *listener) override;
|
||||
@@ -85,6 +129,36 @@ public:
|
||||
|
||||
StatementContext* statement();
|
||||
|
||||
class InputStmtContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
InputStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
antlr4::tree::TerminalNode *INPUT();
|
||||
|
||||
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;
|
||||
|
||||
};
|
||||
|
||||
InputStmtContext* inputStmt();
|
||||
|
||||
class OutputStmtContext : public antlr4::ParserRuleContext {
|
||||
public:
|
||||
OutputStmtContext(antlr4::ParserRuleContext *parent, size_t invokingState);
|
||||
virtual size_t getRuleIndex() const override;
|
||||
antlr4::tree::TerminalNode *OUTPUT();
|
||||
|
||||
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;
|
||||
|
||||
};
|
||||
|
||||
OutputStmtContext* outputStmt();
|
||||
|
||||
|
||||
private:
|
||||
static std::vector<antlr4::dfa::DFA> _decisionToDFA;
|
||||
|
||||
@@ -23,8 +23,16 @@ public:
|
||||
|
||||
virtual antlrcpp::Any visitStatements(bfParser::StatementsContext *context) = 0;
|
||||
|
||||
virtual antlrcpp::Any visitLoopStmt(bfParser::LoopStmtContext *context) = 0;
|
||||
|
||||
virtual antlrcpp::Any visitNumberedStatement(bfParser::NumberedStatementContext *context) = 0;
|
||||
|
||||
virtual antlrcpp::Any visitStatement(bfParser::StatementContext *context) = 0;
|
||||
|
||||
virtual antlrcpp::Any visitInputStmt(bfParser::InputStmtContext *context) = 0;
|
||||
|
||||
virtual antlrcpp::Any visitOutputStmt(bfParser::OutputStmtContext *context) = 0;
|
||||
|
||||
|
||||
};
|
||||
|
||||
|
||||
Reference in New Issue
Block a user