add statement support

grammar/bf.g4

@@ -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: '.';

lib/generated/bf.tokens

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

lib/generated/bfBaseListener.h

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

lib/generated/bfBaseVisitor.h

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

lib/generated/bfLexer.cpp

@@ -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, 
+    0x7, 0x4, 0x8, 0x9, 0x8, 0x4, 0x9, 0x9, 0x9, 0x3, 0x2, 0x3, 0x2, 0x3, 
-    0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x3, 0x3, 
+    0x2, 0x3, 0x2, 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, 
+    0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x4, 0x3, 
-    0x7, 0x3, 0x7, 0x3, 0x8, 0x3, 0x8, 0x2, 0x2, 0x9, 0x3, 0x3, 0x5, 0x4, 
+    0x5, 0x3, 0x5, 0x3, 0x6, 0x3, 0x6, 0x3, 0x7, 0x3, 0x7, 0x3, 0x8, 0x3, 
-    0x7, 0x5, 0x9, 0x6, 0xb, 0x7, 0xd, 0x8, 0xf, 0x9, 0x3, 0x2, 0x2, 0x2, 
+    0x8, 0x3, 0x9, 0x3, 0x9, 0x2, 0x2, 0xa, 0x3, 0x3, 0x5, 0x4, 0x7, 0x5, 
-    0x26, 0x2, 0x3, 0x3, 0x2, 0x2, 0x2, 0x2, 0x5, 0x3, 0x2, 0x2, 0x2, 0x2, 
+    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, 
+    0x2, 0x2, 0x11, 0x3, 0x2, 0x2, 0x2, 0x3, 0x13, 0x3, 0x2, 0x2, 0x2, 0x5, 
-    0x1d, 0x3, 0x2, 0x2, 0x2, 0x9, 0x1f, 0x3, 0x2, 0x2, 0x2, 0xb, 0x21, 
+    0x17, 0x3, 0x2, 0x2, 0x2, 0x7, 0x21, 0x3, 0x2, 0x2, 0x2, 0x9, 0x23, 
-    0x3, 0x2, 0x2, 0x2, 0xd, 0x23, 0x3, 0x2, 0x2, 0x2, 0xf, 0x25, 0x3, 0x2, 
+    0x3, 0x2, 0x2, 0x2, 0xb, 0x25, 0x3, 0x2, 0x2, 0x2, 0xd, 0x27, 0x3, 0x2, 
-    0x2, 0x2, 0x11, 0x12, 0x7, 0x5e, 0x2, 0x2, 0x12, 0x13, 0x7, 0x5e, 0x2, 
+    0x2, 0x2, 0xf, 0x29, 0x3, 0x2, 0x2, 0x2, 0x11, 0x2b, 0x3, 0x2, 0x2, 
-    0x2, 0x13, 0x14, 0x7, 0x30, 0x2, 0x2, 0x14, 0x15, 0x7, 0x2c, 0x2, 0x2, 
+    0x2, 0x13, 0x14, 0x7, 0xc, 0x2, 0x2, 0x14, 0x15, 0x3, 0x2, 0x2, 0x2, 
-    0x15, 0x16, 0x7, 0x41, 0x2, 0x2, 0x16, 0x17, 0x7, 0x5e, 0x2, 0x2, 0x17, 
+    0x15, 0x16, 0x8, 0x2, 0x2, 0x2, 0x16, 0x4, 0x3, 0x2, 0x2, 0x2, 0x17, 
-    0x18, 0x7, 0x5e, 0x2, 0x2, 0x18, 0x19, 0x3, 0x2, 0x2, 0x2, 0x19, 0x1a, 
+    0x18, 0x7, 0x5e, 0x2, 0x2, 0x18, 0x19, 0x7, 0x5e, 0x2, 0x2, 0x19, 0x1a, 
-    0x8, 0x2, 0x2, 0x2, 0x1a, 0x4, 0x3, 0x2, 0x2, 0x2, 0x1b, 0x1c, 0x7, 
+    0x7, 0x30, 0x2, 0x2, 0x1a, 0x1b, 0x7, 0x2c, 0x2, 0x2, 0x1b, 0x1c, 0x7, 
-    0x41, 0x2, 0x2, 0x1c, 0x6, 0x3, 0x2, 0x2, 0x2, 0x1d, 0x1e, 0x7, 0x30, 
+    0x41, 0x2, 0x2, 0x1c, 0x1d, 0x7, 0x5e, 0x2, 0x2, 0x1d, 0x1e, 0x7, 0x5e, 
-    0x2, 0x2, 0x1e, 0x8, 0x3, 0x2, 0x2, 0x2, 0x1f, 0x20, 0x7, 0x2f, 0x2, 
+    0x2, 0x2, 0x1e, 0x1f, 0x3, 0x2, 0x2, 0x2, 0x1f, 0x20, 0x8, 0x3, 0x2, 
-    0x2, 0x20, 0xa, 0x3, 0x2, 0x2, 0x2, 0x21, 0x22, 0x7, 0x2d, 0x2, 0x2, 
+    0x2, 0x20, 0x6, 0x3, 0x2, 0x2, 0x2, 0x21, 0x22, 0x7, 0x41, 0x2, 0x2, 
-    0x22, 0xc, 0x3, 0x2, 0x2, 0x2, 0x23, 0x24, 0x7, 0x40, 0x2, 0x2, 0x24, 
+    0x22, 0x8, 0x3, 0x2, 0x2, 0x2, 0x23, 0x24, 0x7, 0x30, 0x2, 0x2, 0x24, 
-    0xe, 0x3, 0x2, 0x2, 0x2, 0x25, 0x26, 0x7, 0x3e, 0x2, 0x2, 0x26, 0x10, 
+    0xa, 0x3, 0x2, 0x2, 0x2, 0x25, 0x26, 0x7, 0x2f, 0x2, 0x2, 0x26, 0xc, 
-    0x3, 0x2, 0x2, 0x2, 0x3, 0x2, 0x3, 0x8, 0x2, 0x2, 
+    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;

lib/generated/bfLexer.h

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

lib/generated/bfLexer.tokens

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

lib/generated/bfListener.h

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

lib/generated/bfParser.cpp

@@ -38,8 +38,16 @@ bfParser::ProgramContext::ProgramContext(ParserRuleContext *parent, size_t invok
   : ParserRuleContext(parent, invokingState) {
 }
 
-bfParser::StatementsContext* bfParser::ProgramContext::statements() {
+tree::TerminalNode* bfParser::ProgramContext::EOF() {
-  return getRuleContext<bfParser::StatementsContext>(0);
+  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);
-    statements();
+    _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() {
+std::vector<bfParser::StatementContext *> bfParser::StatementsContext::statement() {
-  return getToken(bfParser::INC, 0);
+  return getRuleContexts<bfParser::StatementContext>();
 }
 
-tree::TerminalNode* bfParser::StatementsContext::DEC() {
+bfParser::StatementContext* bfParser::StatementsContext::statement(size_t i) {
-  return getToken(bfParser::DEC, 0);
+  return getRuleContext<bfParser::StatementContext>(i);
-}
-
-tree::TerminalNode* bfParser::StatementsContext::INPUT() {
-  return getToken(bfParser::INPUT, 0);
-}
-
-tree::TerminalNode* bfParser::StatementsContext::OUTPUT() {
-  return getToken(bfParser::OUTPUT, 0);
 }
 
 
@@ -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, 
+    0x3, 0xa, 0x18, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x4, 0x4, 0x9, 
-    0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x2, 0x2, 0x4, 0x2, 0x4, 0x2, 0x3, 
+    0x4, 0x3, 0x2, 0x7, 0x2, 0xa, 0xa, 0x2, 0xc, 0x2, 0xe, 0x2, 0xd, 0xb, 
-    0x3, 0x2, 0x4, 0x7, 0x2, 0x8, 0x2, 0x6, 0x3, 0x2, 0x2, 0x2, 0x4, 0x8, 
+    0x2, 0x3, 0x2, 0x3, 0x2, 0x3, 0x3, 0x6, 0x3, 0x12, 0xa, 0x3, 0xd, 0x3, 
-    0x3, 0x2, 0x2, 0x2, 0x6, 0x7, 0x5, 0x4, 0x3, 0x2, 0x7, 0x3, 0x3, 0x2, 
+    0xe, 0x3, 0x13, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x2, 0x2, 0x5, 0x2, 0x4, 
-    0x2, 0x2, 0x8, 0x9, 0x9, 0x2, 0x2, 0x2, 0x9, 0x5, 0x3, 0x2, 0x2, 0x2, 
+    0x6, 0x2, 0x3, 0x3, 0x2, 0x5, 0x8, 0x2, 0x16, 0x2, 0xb, 0x3, 0x2, 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;

lib/generated/bfParser.h

@@ -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);
@@ -30,13 +31,16 @@ public:
 
 
   class ProgramContext;
-  class StatementsContext; 
+  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:

lib/generated/bfVisitor.h

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

src/main.cpp

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