wip

src/Parser.cpp

@@ -32,8 +32,41 @@ shared_ptr<Statement> Parser::nextStatement() {
     return matchInvalidStatement();
 }
 
+shared_ptr<Statement> Parser::matchFunctionDeclarationStatement() {
+    if (!matchesTokenKinds({Token::Kind::IDENTIFIER, Token::Kind::COLON, Token::Kind::FUNCTION}))
+        return make_shared<Statement>(Statement::Kind::INVALID, make_shared<Token>(tokens.at(currentIndex)), nullptr, nullptr, { }, "");
+
+    Token identifierToken = tokens.at(currentIndex);
+    currentIndex++;
+    currentIndex++; // skip colon
+    currentIndex++; // skip fun
+
+    while (tokens.at(currentIndex).getKind() != Token::Kind::NEW_LINE) {
+        currentIndex++;
+    }
+    currentIndex++; // new line
+    shared_ptr<Statement> blockStatement = matchBlockStatement();
+    if (!blockStatement->isValid())
+        return blockStatement;
+    
+    return make_shared<Statement>(Statement::Kind::FUNCTION_DECLARATION, nullptr, nullptr, blockStatement, { }, identifierToken.getLexme());
+}
+
+shared_ptr<Statement> Parser::matchBlockStatement() {
+    vector<shared_ptr<Statement>> statements;
+
+    while (tokens.at(currentIndex).getKind() != Token::Kind::SEMICOLON) {
+        shared_ptr<Statement> statement = nextStatement();
+        if (!statement->isValid())
+            return statement;
+        statements.push_back(statement);
+    }
+    currentIndex++; // skip ;
+    return make_shared<Statement>(Statement::Kind::BLOCK, nullptr, nullptr, nullptr, statements, "");
+}
+
 shared_ptr<Statement> Parser::matchInvalidStatement() {
-    return make_shared<Statement>(Statement::Kind::INVALID, make_shared<Token>(tokens.at(currentIndex)), nullptr);
+    return make_shared<Statement>(Statement::Kind::INVALID, make_shared<Token>(tokens.at(currentIndex)), nullptr, nullptr, { }, "");
 }
 
 //
@@ -43,9 +76,9 @@ shared_ptr<Statement> Parser::matchExpressionStatement() {
     shared_ptr<Expression> expression = term();
     if (expression->isValid() && tokens.at(currentIndex).isOfKind({Token::Kind::NEW_LINE, Token::Kind::END})) {
         currentIndex++;
-        return make_shared<Statement>(Statement::Kind::EXPRESSION, nullptr, expression);
+        return make_shared<Statement>(Statement::Kind::EXPRESSION, nullptr, expression, nullptr, { }, "");
     } else {
-        return make_shared<Statement>(Statement::Kind::INVALID, make_shared<Token>(tokens.at(currentIndex)), expression);
+        return make_shared<Statement>(Statement::Kind::INVALID, make_shared<Token>(tokens.at(currentIndex)), expression, nullptr, { }, "");
     }
 }
 
@@ -128,4 +161,15 @@ shared_ptr<Expression> Parser::matchBinary(shared_ptr<Expression> left) {
     }
 
     return make_shared<Expression>(Expression::Kind::INVALID, token, nullptr, nullptr);
-}
+}
+
+bool Parser::matchesTokenKinds(vector<Token::Kind> kinds) {
+    if (currentIndex + kinds.size() >= tokens.size())
+        return false;
+
+    for (int i=0; i<kinds.size(); i++) {
+        if (kinds.at(i) != tokens.at(currentIndex + i).getKind())
+            return false;
+    }
+    return true;
+}

src/Parser.h

@@ -15,7 +15,9 @@ private:
 
     shared_ptr<Statement> nextStatement();
 
-    shared_ptr<Statement> matchInvalidStatement() ;
+    shared_ptr<Statement> matchFunctionDeclarationStatement();
+    shared_ptr<Statement> matchBlockStatement();
+    shared_ptr<Statement> matchInvalidStatement();
 
     shared_ptr<Statement> matchExpressionStatement();
     shared_ptr<Expression> term(); // +, -
@@ -26,6 +28,8 @@ private:
     shared_ptr<Expression> matchGrouping();
     shared_ptr<Expression> matchBinary(shared_ptr<Expression> left);
 
+    bool matchesTokenKinds(vector<Token::Kind> kinds);
+
 public:
     Parser(vector<Token> tokens);
     vector<shared_ptr<Statement>> getStatements();

src/Statement.cpp

@@ -1,6 +1,7 @@
 #include "Statement.h"
 
-Statement::Statement(Kind kind, shared_ptr<Token> token, shared_ptr<Expression> expression): kind(kind), token(token), expression(expression) {
+Statement::Statement(Kind kind, shared_ptr<Token> token, shared_ptr<Expression> expression, shared_ptr<Statement> blockStatement, vector<shared_ptr<Statement>> statements, string name):
+    kind(kind), token(token), expression(expression), blockStatement(blockStatement), statements(statements), name(name) {
 }
 
 shared_ptr<Expression> Statement::getExpression() {
@@ -19,6 +20,17 @@ string Statement::toString() {
     switch (kind) {
         case EXPRESSION:
             return expression->toString();
+        case BLOCK: {
+            string value;
+            for (int i=0; i<statements.size(); i++) {
+                value += statements.at(i)->toString();
+                if (i < statements.size() - 1)
+                    value += "\n";
+            }
+            return value;
+        }
+        case FUNCTION_DECLARATION:
+            return "FUNCTION " + name + "\n" + blockStatement->toString() + "\n;";
         case INVALID:
             return "INVALID";
     }

src/Statement.h

@@ -12,6 +12,8 @@ class Statement {
 public:
     enum Kind {
         EXPRESSION,
+        BLOCK,
+        FUNCTION_DECLARATION,
         INVALID
     };
 
@@ -19,9 +21,12 @@ private:
     Kind kind;
     shared_ptr<Token> token;
     shared_ptr<Expression> expression;
+    shared_ptr<Statement> blockStatement;
+    vector<shared_ptr<Statement>> statements;
+    string name;
 
 public:
-    Statement(Kind kind, shared_ptr<Token> token, shared_ptr<Expression> expression);
+    Statement(Kind kind, shared_ptr<Token> token, shared_ptr<Expression> expression, shared_ptr<Statement> blockStatement, vector<shared_ptr<Statement>> statements, string name);
     shared_ptr<Token> getToken();
     shared_ptr<Expression> getExpression();
     bool isValid();