Added expression statement

src/Lexer.cpp

@@ -9,7 +9,7 @@ vector<Token> Lexer::getTokens() {
         Token token = nextToken();
 
         // Abort scanning if we got an error
-        if (token.getKind() == Token::Kind::INVALID) {
+        if (!token.isValid()) {
             cerr << "Unexpected character '" << token.getLexme() << "' at " << token.getLine() << ":" << token.getColumn() << endl;
             return vector<Token>();
          }

src/Parser.cpp

@@ -3,21 +3,51 @@
 Parser::Parser(vector<Token> tokens): tokens(tokens) {
 }
 
-/*shared_ptr<Expression> Parser::getExpression() {
-    shared_ptr<Expression> expression = term();
-    if (!expression->isValid()) {
-        cerr << "Unexpected token '" << expression->getToken().getLexme() << "' at " << expression->getToken().getLine() << ":" << expression->getToken().getColumn() << endl;
-        return nullptr;
-    }
-    return expression;
-}*/
-
 vector<shared_ptr<Statement>> Parser::getStatements() {
     vector<shared_ptr<Statement>> statements;
-        statements.push_back(make_shared<Statement>(Statement::Kind::INVALID));
+
+    while (tokens.at(currentIndex).getKind() != Token::Kind::END) {
+        shared_ptr<Statement> statement = nextStatement();
+        // Abort parsing if we got an error
+        if (!statement->isValid()) {
+            cerr << "Unexpected token '" << statement->getToken().getLexme() << "' at " << statement->getToken().getLine() << ":" << statement->getToken().getColumn() << endl;
+            return vector<shared_ptr<Statement>>();
+        }
+        statements.push_back(statement);
+    }
+
     return statements;
 }
 
+//
+// Statement
+//
+shared_ptr<Statement> Parser::nextStatement() {
+    {
+        shared_ptr<Statement> statement = matchExpressionStatement();
+        if (statement->isValid())
+            return statement;
+    }
+
+    return matchInvalidStatement();
+}
+
+shared_ptr<Statement> Parser::matchInvalidStatement() {
+    return make_shared<Statement>(Statement::Kind::INVALID, tokens.at(currentIndex), nullptr);
+}
+
+//
+// Expression
+//
+shared_ptr<Statement> Parser::matchExpressionStatement() {
+    shared_ptr<Expression> expression = term();
+    if (expression->isValid()) {
+        return make_shared<Statement>(Statement::Kind::EXPRESSION, tokens.at(currentIndex), expression);
+    } else {
+        return make_shared<Statement>(Statement::Kind::INVALID, tokens.at(currentIndex), expression);
+    }
+}
+
 shared_ptr<Expression> Parser::term() {
     shared_ptr<Expression> expression = factor();
 

src/Parser.h

@@ -13,6 +13,11 @@ private:
     vector<Token> tokens;
     int currentIndex = 0;
 
+    shared_ptr<Statement> nextStatement();
+
+    shared_ptr<Statement> matchInvalidStatement() ;
+
+    shared_ptr<Statement> matchExpressionStatement();
     shared_ptr<Expression> term(); // +, -
     shared_ptr<Expression> factor(); // *, /, %
     shared_ptr<Expression> primary(); // integer, ()

src/Statement.cpp

@@ -1,10 +1,24 @@
 #include "Statement.h"
 
-Statement::Statement(Kind kind): kind(kind) {
+Statement::Statement(Kind kind, Token token, shared_ptr<Expression> expression): kind(kind), token(token), expression(expression) {
+}
+
+shared_ptr<Expression> Statement::getExpression() {
+    return expression;
+}
+
+Token Statement::getToken() {
+    return token;
+}
+
+bool Statement::isValid() {
+    return kind != Statement::Kind::INVALID;
 }
 
 string Statement::toString() {
     switch (kind) {
+        case EXPRESSION:
+            return expression->toString();
         case INVALID:
             return "INVALID";
     }

src/Statement.h

@@ -3,19 +3,28 @@
 
 #include <iostream>
 
+#include "Token.h"
+#include "Expression.h"
+
 using namespace std;
 
 class Statement {
 public:
     enum Kind {
+        EXPRESSION,
         INVALID
     };
 
 private:
     Kind kind;
+    Token token;
+    shared_ptr<Expression> expression;
 
 public:
-    Statement(Kind kind);
+    Statement(Kind kind, Token token, shared_ptr<Expression> expression);
+    Token getToken();
+    shared_ptr<Expression> getExpression();
+    bool isValid();
     string toString();
 };