Add new comments and lines

.vscode/launch.json

@@ -0,0 +1,35 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "antlr-debug",
+            "request": "launch",
+            "name": "Debug Current Grammar",
+            "input": "sample.bfe",
+            "visualParseTree": true,
+            "grammar": "${file}"
+        },
+        {
+            "name": "(gdb) Launch",
+            "type": "cppdbg",
+            "request": "launch",
+            "program": "${workspaceFolder}/debug/main.out",
+            "args": ["sample.txt"],
+            "stopAtEntry": false,
+            "cwd": "${workspaceFolder}",
+            "environment": [],
+            "externalConsole": false,
+            "MIMode": "gdb",
+            "setupCommands": [
+                {
+                    "description": "Enable pretty-printing for gdb",
+                    "text": "-enable-pretty-printing",
+                    "ignoreFailures": true
+                }
+            ]
+        }
+    ]
+}

grammar/bf.g4

@@ -1,20 +1,42 @@
 grammar bf;
 
-program:
+program
-    statements* EOF;
+    : statements* EOF;
 
-statements:
+statements
-    statement+;
+    : (statement|numberedStatement|loopStmt)+;
 
-statement:
+loopStmt
-      INC
+    : LOOPSTART statements LOOPEND
+    ;
+
+numberedStatement
+    : statement NUMBER
+    ;
+
+statement
+    : INC
     | DEC 
-    | INPUT
+    | LEFT 
-    | OUTPUT
+    | RIGHT
+    | inputStmt
+    | outputStmt
+    ;
+
+inputStmt
+    : INPUT
+    ;
+
+outputStmt
+    : OUTPUT
     ;
 
 NEWLINE: '\n' -> skip;
-COMMENT: '\\\\.*?\\\\' -> skip;
+COMMENT: '//' ~[\r\n]* '\r'? '\n'? -> channel(HIDDEN);
+WS: [ \r\n] -> skip;
+LOOPSTART: '[';
+LOOPEND:']';
+NUMBER: [0-9]+;
 INPUT: '?';
 OUTPUT: '.';
 DEC: '-';

lib/generated/bf.tokens

@@ -1,16 +1,21 @@
 NEWLINE=1
 COMMENT=2
-INPUT=3
+WS=3
-OUTPUT=4
+LOOPSTART=4
-DEC=5
+LOOPEND=5
-INC=6
+NUMBER=6
-LEFT=7
+INPUT=7
-RIGHT=8
+OUTPUT=8
+DEC=9
+INC=10
+LEFT=11
+RIGHT=12
 '\n'=1
-'\\\\.*?\\\\'=2
+'['=4
-'?'=3
+']'=5
-'.'=4
+'?'=7
-'-'=5
+'.'=8
-'+'=6
+'-'=9
-'>'=7
+'+'=10
-'<'=8
+'>'=11
+'<'=12

lib/generated/bfBaseListener.h

@@ -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 { }

lib/generated/bfBaseVisitor.h

@@ -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);
+  }
+
 
 };
 

lib/generated/bfLexer.cpp

@@ -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"NEWLINE", u8"COMMENT", u8"WS", u8"LOOPSTART", u8"LOOPEND", u8"NUMBER", 
-  u8"RIGHT"
+  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"'\n'", "", "", u8"'['", 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"NEWLINE", u8"COMMENT", u8"WS", u8"LOOPSTART", u8"LOOPEND", u8"NUMBER", 
-  u8"LEFT", u8"RIGHT"
+  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, 
+    0x7, 0x4, 0x8, 0x9, 0x8, 0x4, 0x9, 0x9, 0x9, 0x4, 0xa, 0x9, 0xa, 0x4, 
-    0x2, 0x3, 0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 
+    0xb, 0x9, 0xb, 0x4, 0xc, 0x9, 0xc, 0x4, 0xd, 0x9, 0xd, 0x3, 0x2, 0x3, 
-    0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x4, 0x3, 
+    0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x7, 
-    0x5, 0x3, 0x5, 0x3, 0x6, 0x3, 0x6, 0x3, 0x7, 0x3, 0x7, 0x3, 0x8, 0x3, 
+    0x3, 0x24, 0xa, 0x3, 0xc, 0x3, 0xe, 0x3, 0x27, 0xb, 0x3, 0x3, 0x3, 0x5, 
-    0x8, 0x3, 0x9, 0x3, 0x9, 0x2, 0x2, 0xa, 0x3, 0x3, 0x5, 0x4, 0x7, 0x5, 
+    0x3, 0x2a, 0xa, 0x3, 0x3, 0x3, 0x5, 0x3, 0x2d, 0xa, 0x3, 0x3, 0x3, 0x3, 
-    0x9, 0x6, 0xb, 0x7, 0xd, 0x8, 0xf, 0x9, 0x11, 0xa, 0x3, 0x2, 0x2, 0x2, 
+    0x3, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x5, 0x3, 0x5, 0x3, 
-    0x2c, 0x2, 0x3, 0x3, 0x2, 0x2, 0x2, 0x2, 0x5, 0x3, 0x2, 0x2, 0x2, 0x2, 
+    0x6, 0x3, 0x6, 0x3, 0x7, 0x6, 0x7, 0x3a, 0xa, 0x7, 0xd, 0x7, 0xe, 0x7, 
-    0x7, 0x3, 0x2, 0x2, 0x2, 0x2, 0x9, 0x3, 0x2, 0x2, 0x2, 0x2, 0xb, 0x3, 
+    0x3b, 0x3, 0x8, 0x3, 0x8, 0x3, 0x9, 0x3, 0x9, 0x3, 0xa, 0x3, 0xa, 0x3, 
-    0x2, 0x2, 0x2, 0x2, 0xd, 0x3, 0x2, 0x2, 0x2, 0x2, 0xf, 0x3, 0x2, 0x2, 
+    0xb, 0x3, 0xb, 0x3, 0xc, 0x3, 0xc, 0x3, 0xd, 0x3, 0xd, 0x2, 0x2, 0xe, 
-    0x2, 0x2, 0x11, 0x3, 0x2, 0x2, 0x2, 0x3, 0x13, 0x3, 0x2, 0x2, 0x2, 0x5, 
+    0x3, 0x3, 0x5, 0x4, 0x7, 0x5, 0x9, 0x6, 0xb, 0x7, 0xd, 0x8, 0xf, 0x9, 
-    0x17, 0x3, 0x2, 0x2, 0x2, 0x7, 0x21, 0x3, 0x2, 0x2, 0x2, 0x9, 0x23, 
+    0x11, 0xa, 0x13, 0xb, 0x15, 0xc, 0x17, 0xd, 0x19, 0xe, 0x3, 0x2, 0x5, 
-    0x3, 0x2, 0x2, 0x2, 0xb, 0x25, 0x3, 0x2, 0x2, 0x2, 0xd, 0x27, 0x3, 0x2, 
+    0x4, 0x2, 0xc, 0xc, 0xf, 0xf, 0x5, 0x2, 0xc, 0xc, 0xf, 0xf, 0x22, 0x22, 
-    0x2, 0x2, 0xf, 0x29, 0x3, 0x2, 0x2, 0x2, 0x11, 0x2b, 0x3, 0x2, 0x2, 
+    0x3, 0x2, 0x32, 0x3b, 0x2, 0x4c, 0x2, 0x3, 0x3, 0x2, 0x2, 0x2, 0x2, 
-    0x2, 0x13, 0x14, 0x7, 0xc, 0x2, 0x2, 0x14, 0x15, 0x3, 0x2, 0x2, 0x2, 
+    0x5, 0x3, 0x2, 0x2, 0x2, 0x2, 0x7, 0x3, 0x2, 0x2, 0x2, 0x2, 0x9, 0x3, 
-    0x15, 0x16, 0x8, 0x2, 0x2, 0x2, 0x16, 0x4, 0x3, 0x2, 0x2, 0x2, 0x17, 
+    0x2, 0x2, 0x2, 0x2, 0xb, 0x3, 0x2, 0x2, 0x2, 0x2, 0xd, 0x3, 0x2, 0x2, 
-    0x18, 0x7, 0x5e, 0x2, 0x2, 0x18, 0x19, 0x7, 0x5e, 0x2, 0x2, 0x19, 0x1a, 
+    0x2, 0x2, 0xf, 0x3, 0x2, 0x2, 0x2, 0x2, 0x11, 0x3, 0x2, 0x2, 0x2, 0x2, 
-    0x7, 0x30, 0x2, 0x2, 0x1a, 0x1b, 0x7, 0x2c, 0x2, 0x2, 0x1b, 0x1c, 0x7, 
+    0x13, 0x3, 0x2, 0x2, 0x2, 0x2, 0x15, 0x3, 0x2, 0x2, 0x2, 0x2, 0x17, 
-    0x41, 0x2, 0x2, 0x1c, 0x1d, 0x7, 0x5e, 0x2, 0x2, 0x1d, 0x1e, 0x7, 0x5e, 
+    0x3, 0x2, 0x2, 0x2, 0x2, 0x19, 0x3, 0x2, 0x2, 0x2, 0x3, 0x1b, 0x3, 0x2, 
-    0x2, 0x2, 0x1e, 0x1f, 0x3, 0x2, 0x2, 0x2, 0x1f, 0x20, 0x8, 0x3, 0x2, 
+    0x2, 0x2, 0x5, 0x1f, 0x3, 0x2, 0x2, 0x2, 0x7, 0x30, 0x3, 0x2, 0x2, 0x2, 
-    0x2, 0x20, 0x6, 0x3, 0x2, 0x2, 0x2, 0x21, 0x22, 0x7, 0x41, 0x2, 0x2, 
+    0x9, 0x34, 0x3, 0x2, 0x2, 0x2, 0xb, 0x36, 0x3, 0x2, 0x2, 0x2, 0xd, 0x39, 
-    0x22, 0x8, 0x3, 0x2, 0x2, 0x2, 0x23, 0x24, 0x7, 0x30, 0x2, 0x2, 0x24, 
+    0x3, 0x2, 0x2, 0x2, 0xf, 0x3d, 0x3, 0x2, 0x2, 0x2, 0x11, 0x3f, 0x3, 
-    0xa, 0x3, 0x2, 0x2, 0x2, 0x25, 0x26, 0x7, 0x2f, 0x2, 0x2, 0x26, 0xc, 
+    0x2, 0x2, 0x2, 0x13, 0x41, 0x3, 0x2, 0x2, 0x2, 0x15, 0x43, 0x3, 0x2, 
-    0x3, 0x2, 0x2, 0x2, 0x27, 0x28, 0x7, 0x2d, 0x2, 0x2, 0x28, 0xe, 0x3, 
+    0x2, 0x2, 0x17, 0x45, 0x3, 0x2, 0x2, 0x2, 0x19, 0x47, 0x3, 0x2, 0x2, 
-    0x2, 0x2, 0x2, 0x29, 0x2a, 0x7, 0x40, 0x2, 0x2, 0x2a, 0x10, 0x3, 0x2, 
+    0x2, 0x1b, 0x1c, 0x7, 0xc, 0x2, 0x2, 0x1c, 0x1d, 0x3, 0x2, 0x2, 0x2, 
-    0x2, 0x2, 0x2b, 0x2c, 0x7, 0x3e, 0x2, 0x2, 0x2c, 0x12, 0x3, 0x2, 0x2, 
+    0x1d, 0x1e, 0x8, 0x2, 0x2, 0x2, 0x1e, 0x4, 0x3, 0x2, 0x2, 0x2, 0x1f, 
-    0x2, 0x3, 0x2, 0x3, 0x8, 0x2, 0x2, 
+    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;

lib/generated/bfLexer.h

@@ -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, 
+    NEWLINE = 1, COMMENT = 2, WS = 3, LOOPSTART = 4, LOOPEND = 5, NUMBER = 6, 
-    RIGHT = 8
+    INPUT = 7, OUTPUT = 8, DEC = 9, INC = 10, LEFT = 11, RIGHT = 12
   };
 
   bfLexer(antlr4::CharStream *input);

lib/generated/bfLexer.tokens

@@ -1,16 +1,21 @@
 NEWLINE=1
 COMMENT=2
-INPUT=3
+WS=3
-OUTPUT=4
+LOOPSTART=4
-DEC=5
+LOOPEND=5
-INC=6
+NUMBER=6
-LEFT=7
+INPUT=7
-RIGHT=8
+OUTPUT=8
+DEC=9
+INC=10
+LEFT=11
+RIGHT=12
 '\n'=1
-'\\\\.*?\\\\'=2
+'['=4
-'?'=3
+']'=5
-'.'=4
+'?'=7
-'-'=5
+'.'=8
-'+'=6
+'-'=9
-'>'=7
+'+'=10
-'<'=8
+'>'=11
+'<'=12

lib/generated/bfListener.h

@@ -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;
+
 
 };
 

lib/generated/bfParser.cpp

@@ -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)) {
+      | (1ULL << bfParser::INC)
-      setState(6);
+      | (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);
+              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() {
+tree::TerminalNode* bfParser::StatementContext::LEFT() {
-  return getToken(bfParser::INPUT, 0);
+  return getToken(bfParser::LEFT, 0);
 }
 
-tree::TerminalNode* bfParser::StatementContext::OUTPUT() {
+tree::TerminalNode* bfParser::StatementContext::RIGHT() {
-  return getToken(bfParser::OUTPUT, 0);
+  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,28 +418,175 @@ antlrcpp::Any bfParser::StatementContext::accept(tree::ParseTreeVisitor *visitor
 
 bfParser::StatementContext* bfParser::statement() {
   StatementContext *_localctx = _tracker.createInstance<StatementContext>(_ctx, getState());
-  enterRule(_localctx, 4, bfParser::RuleStatement);
+  enterRule(_localctx, 8, bfParser::RuleStatement);
-  size_t _la = 0;
+
+  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);
+    setState(44);
-    _la = _input->LA(1);
+    match(bfParser::INPUT);
-    if (!((((_la & ~ 0x3fULL) == 0) &&
+   
-      ((1ULL << _la) & ((1ULL << bfParser::INPUT)
-      | (1ULL << bfParser::OUTPUT)
-      | (1ULL << bfParser::DEC)
-      | (1ULL << bfParser::INC))) != 0))) {
-    _errHandler->recoverInline(this);
   }
-    else {
+  catch (RecognitionException &e) {
-      _errHandler->reportMatch(this);
+    _errHandler->reportError(this, e);
-      consume();
+    _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);
@@ -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, 
+    0x3, 0xe, 0x33, 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, 
+    0x4, 0x4, 0x5, 0x9, 0x5, 0x4, 0x6, 0x9, 0x6, 0x4, 0x7, 0x9, 0x7, 0x4, 
-    0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x3, 0x6, 0x3, 0x12, 0xa, 0x3, 0xd, 0x3, 
+    0x8, 0x9, 0x8, 0x3, 0x2, 0x7, 0x2, 0x12, 0xa, 0x2, 0xc, 0x2, 0xe, 0x2, 
-    0xe, 0x3, 0x13, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x2, 0x2, 0x5, 0x2, 0x4, 
+    0x15, 0xb, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x6, 
-    0x6, 0x2, 0x3, 0x3, 0x2, 0x5, 0x8, 0x2, 0x16, 0x2, 0xb, 0x3, 0x2, 0x2, 
+    0x3, 0x1c, 0xa, 0x3, 0xd, 0x3, 0xe, 0x3, 0x1d, 0x3, 0x4, 0x3, 0x4, 0x3, 
-    0x2, 0x4, 0x11, 0x3, 0x2, 0x2, 0x2, 0x6, 0x15, 0x3, 0x2, 0x2, 0x2, 0x8, 
+    0x4, 0x3, 0x4, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x6, 0x3, 0x6, 0x3, 
-    0xa, 0x5, 0x4, 0x3, 0x2, 0x9, 0x8, 0x3, 0x2, 0x2, 0x2, 0xa, 0xd, 0x3, 
+    0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x5, 0x6, 0x2d, 0xa, 0x6, 0x3, 0x7, 
-    0x2, 0x2, 0x2, 0xb, 0x9, 0x3, 0x2, 0x2, 0x2, 0xb, 0xc, 0x3, 0x2, 0x2, 
+    0x3, 0x7, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x2, 0x2, 0x9, 0x2, 0x4, 0x6, 
-    0x2, 0xc, 0xe, 0x3, 0x2, 0x2, 0x2, 0xd, 0xb, 0x3, 0x2, 0x2, 0x2, 0xe, 
+    0x8, 0xa, 0xc, 0xe, 0x2, 0x2, 0x2, 0x34, 0x2, 0x13, 0x3, 0x2, 0x2, 0x2, 
-    0xf, 0x7, 0x2, 0x2, 0x3, 0xf, 0x3, 0x3, 0x2, 0x2, 0x2, 0x10, 0x12, 0x5, 
+    0x4, 0x1b, 0x3, 0x2, 0x2, 0x2, 0x6, 0x1f, 0x3, 0x2, 0x2, 0x2, 0x8, 0x23, 
-    0x6, 0x4, 0x2, 0x11, 0x10, 0x3, 0x2, 0x2, 0x2, 0x12, 0x13, 0x3, 0x2, 
+    0x3, 0x2, 0x2, 0x2, 0xa, 0x2c, 0x3, 0x2, 0x2, 0x2, 0xc, 0x2e, 0x3, 0x2, 
-    0x2, 0x2, 0x13, 0x11, 0x3, 0x2, 0x2, 0x2, 0x13, 0x14, 0x3, 0x2, 0x2, 
+    0x2, 0x2, 0xe, 0x30, 0x3, 0x2, 0x2, 0x2, 0x10, 0x12, 0x5, 0x4, 0x3, 
-    0x2, 0x14, 0x5, 0x3, 0x2, 0x2, 0x2, 0x15, 0x16, 0x9, 0x2, 0x2, 0x2, 
+    0x2, 0x11, 0x10, 0x3, 0x2, 0x2, 0x2, 0x12, 0x15, 0x3, 0x2, 0x2, 0x2, 
-    0x16, 0x7, 0x3, 0x2, 0x2, 0x2, 0x4, 0xb, 0x13, 
+    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;

lib/generated/bfParser.h

@@ -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, 
+    NEWLINE = 1, COMMENT = 2, WS = 3, LOOPSTART = 4, LOOPEND = 5, NUMBER = 6, 
-    RIGHT = 8
+    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 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 *LEFT();
-    antlr4::tree::TerminalNode *OUTPUT();
+    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;

lib/generated/bfVisitor.h

@@ -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;
+
 
 };
 

sample.bfe

@@ -0,0 +1 @@
+[+567-756]+2?[+3-2]

sample.txt

@@ -1 +0,0 @@
-+++---

src/main.cpp

@@ -8,25 +8,54 @@
 
 using namespace antlr4;
 
-class expressionListener : public bfBaseListener{
+class expressionPrintingListener : public bfBaseListener
-    public:
+{
-       void enterStatements(bfParser::StatementsContext *ctx) override{
+public:
-           std::cout<<ctx->getText()<<std::endl;
+    void enterStatement(bfParser::StatementContext *ctx) override
+    {
+        std::cout << ctx->getText();
+    }
+    void enterNumberedStatement(bfParser::NumberedStatementContext *ctx) override
+    {
+        int num = 0;
+        try{
+            num = stoi(ctx->NUMBER()->getText());
+        }catch(std::exception e){
+            num = 1;
+        }
+        for (int i = 0; i < num - 1; i++)
+        {
+            std::cout << ctx->statement()->getText();
+        }
+    }
+    void exitProgram(bfParser::ProgramContext *ctx) override{
+        std::cout<<std::endl;
+    }
+    void enterLoopStmt(bfParser::LoopStmtContext *ctx) override{
+        std::cout<<'[';
+    }
+    void exitLoopStmt(bfParser::LoopStmtContext *ctx) override{
+        std::cout<<']';
     }
 };
 
-int main(int argc, const char* argv[])
+int main(int argc, const char *argv[])
 {
     // std::cout<<"Hello World "<<FIVE<<std::endl;
     std::ifstream stream;
+    try{
         stream.open(argv[1]);
+    }catch(std::exception e){
+        std::cout<<"Could not open"<<std::endl;
+        return 1;
+    }
     ANTLRInputStream input(stream);
     bfLexer lexer(&input);
     CommonTokenStream tokens(&lexer);
     bfParser parser(&tokens);
 
     tree::ParseTree *tree = parser.program();
-    expressionListener listener;
+    expressionPrintingListener listener;
     tree::ParseTreeWalker::DEFAULT.walk(&listener, tree);
 
     return 0;