Basic statements logging

src/Logger.cpp

@@ -3,6 +3,17 @@
 #include <iostream>
 
 #include "Lexer/Token.h"
+#include "Parser/Statement/Statement.h"
+#include "Parser/Statement/StatementMetaExternFunction.h"
+#include "Parser/Statement/StatementVariable.h"
+#include "Parser/Statement/StatementFunction.h"
+#include "Parser/Statement/StatementBlock.h"
+#include "Parser/Statement/StatementAssignment.h"
+#include "Parser/Statement/StatementReturn.h"
+#include "Parser/Statement/StatementRepeat.h"
+#include "Parser/Statement/StatementExpression.h"
+
+#include "Parser/Expression/Expression.h"
 
 string Logger::toString(shared_ptr<Token> token) {
     switch (token->getKind()) {
@@ -83,11 +94,136 @@ string Logger::toString(shared_ptr<Token> token) {
     }
 }
 
+string Logger::toString(shared_ptr<Statement> statement) {
+    switch (statement->getKind()) {
+        case StatementKind::META_EXTERN_FUNCTION:
+            return toString(dynamic_pointer_cast<StatementMetaExternFunction>(statement));
+        case StatementKind::VARIABLE:
+            return toString(dynamic_pointer_cast<StatementVariable>(statement));
+        case StatementKind::FUNCTION:
+            return toString(dynamic_pointer_cast<StatementFunction>(statement));
+        case StatementKind::BLOCK:
+            return toString(dynamic_pointer_cast<StatementBlock>(statement));
+        case StatementKind::ASSIGNMENT:
+            return toString(dynamic_pointer_cast<StatementAssignment>(statement));
+        case StatementKind::RETURN:
+            return toString(dynamic_pointer_cast<StatementReturn>(statement));
+        case StatementKind::REPEAT:
+            return toString(dynamic_pointer_cast<StatementRepeat>(statement));
+        case StatementKind::EXPRESSION:
+            return toString(dynamic_pointer_cast<StatementExpression>(statement));
+    }
+}
+
+string Logger::toString(shared_ptr<StatementMetaExternFunction> statement) {
+    string text;
+
+    string argsString;
+    for (int i = 0; i < statement->getArguments().size(); i++) {
+        auto arg = statement->getArguments().at(i);
+        argsString +=  format("ARG({}, {})", arg.first, toString(arg.second));
+    }
+    text += format("@EXTERN FUN(\"{}\"|{}|{})", statement->getName(), argsString, toString(statement->getReturnValueType()));
+
+
+    return text;
+}
+
+string Logger::toString(shared_ptr<StatementVariable> statement) {
+    return format("{}({}|)", statement->getName(), toString(statement->getValueType()), toString(statement->getExpression()));
+}
+
+string Logger::toString(shared_ptr<StatementFunction> statement) {
+    string text;
+
+    string argsString;
+    for (int i = 0; i < statement->getArguments().size(); i++) {
+        auto arg = statement->getArguments().at(i);
+        argsString +=  format("ARG({}, {})", arg.first, toString(arg.second));
+    }
+    text += format("FUN(\"{}\"|{}|{}):\n", statement->getName(), argsString, toString(statement->getReturnValueType()));
+    text += toString(statement->getStatementBlock());
+
+    return text;
+}
+
+string Logger::toString(shared_ptr<StatementBlock> statement) {
+    string text;
+
+    for (int i=0; i<statement->getStatements().size(); i++) {
+        text += toString(statement->getStatements().at(i));
+        if (i < statement->getStatements().size() - 1)
+            text += "\n";
+    }
+
+    return text;
+}
+
+string Logger::toString(shared_ptr<StatementAssignment> statement) {
+    return format("{} <- {}", statement->getName(), toString(statement->getExpression()));
+}
+
+string Logger::toString(shared_ptr<StatementReturn> statement) {
+    string text = "RET";
+    if (statement != nullptr)
+        text += format("({})", toString(statement->getExpression()));
+    return text;
+}
+
+string Logger::toString(shared_ptr<StatementRepeat> statement) {
+    string text;
+
+    string initStatement;
+    string preCondition;
+    string postCondition;
+
+    if (statement->getInitStatement() != nullptr)
+        initStatement = toString(statement->getInitStatement());
+    
+    if (statement->getPostConditionExpression() != nullptr)
+        preCondition = toString(statement->getPreConditionExpression());
+    
+    if (statement->getPostConditionExpression() != nullptr)
+        postCondition = toString(statement->getPostConditionExpression());
+
+    text += format("REP({}|{}|{}):\n", initStatement, preCondition, postCondition);
+    text += toString(statement->getBodyBlockStatement());
+
+    return text;
+}
+
+string Logger::toString(shared_ptr<StatementExpression> statement) {
+    return format("EXPR({})", toString(statement->getExpression()));
+}
+
+string Logger::toString(ValueType valueType) {
+    switch (valueType) {
+        case ValueType::NONE:
+            return "NONE";
+        case ValueType::BOOL:
+            return "BOOL";
+        case ValueType::SINT32:
+            return "SINT32";
+        case ValueType::REAL32:
+            return "REAL32";
+    }
+}
+
+string Logger::toString(shared_ptr<Expression> expression) {
+    return "";
+}
+
 void Logger::print(vector<shared_ptr<Token>> tokens) {
         for (int i=0; i<tokens.size(); i++) {
             cout << i << "|" << toString(tokens.at(i));
             if (i < tokens.size() - 1)
                 cout << "  ";
         }
-        cout << endl << endl;
+        cout << endl;
+}
+
+void Logger::print(vector<shared_ptr<Statement>> statements) {
+    for (shared_ptr<Statement> &statement : statements) {
+        cout << toString(statement) << endl << endl;
+    }
 }

src/Logger.h

@@ -4,6 +4,19 @@
 #include <vector>
 
 class Token;
+class Statement;
+class StatementMetaExternFunction;
+class StatementVariable;
+class StatementFunction;
+class StatementBlock;
+class StatementAssignment;
+class StatementReturn;
+class StatementRepeat;
+class StatementExpression;
+
+class Expression;
+
+enum class ValueType;
 
 using namespace std;
 
@@ -11,8 +24,23 @@ class Logger {
 private:
     static string toString(shared_ptr<Token> token);
 
+    static string toString(shared_ptr<Statement> statement);
+    static string toString(shared_ptr<StatementMetaExternFunction> statement);
+    static string toString(shared_ptr<StatementVariable> statement);
+    static string toString(shared_ptr<StatementFunction> statement);
+    static string toString(shared_ptr<StatementBlock> statement);
+    static string toString(shared_ptr<StatementAssignment> statement);
+    static string toString(shared_ptr<StatementReturn> statement);
+    static string toString(shared_ptr<StatementRepeat> statement);
+    static string toString(shared_ptr<StatementExpression> statement);
+
+    static string toString(shared_ptr<Expression> expression);
+
+    static string toString(ValueType valueType);
+
 public:
     static void print(vector<shared_ptr<Token>> tokens);
+    static void print(vector<shared_ptr<Statement>> statements);
 };
 
 #endif

src/Parser/Parser.cpp

@@ -339,9 +339,6 @@ shared_ptr<Statement> Parser::matchStatementExpression() {
     else if (!expression->isValid())
         return make_shared<StatementInvalid>(tokens.at(currentIndex), expression->toString(0));
 
-    // Consume new line
-    tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true);
-
     return make_shared<StatementExpression>(expression);
 }
 
@@ -578,6 +575,13 @@ shared_ptr<Expression> Parser::matchExpressionBlock(vector<TokenKind> terminalTo
         if (statement == nullptr || !statement->isValid())
             return matchExpressionInvalid("Expected statement");
         statements.push_back(statement);
+
+        if (tryMatchingTokenKinds(terminalTokenKinds, false, false))
+            break;
+
+        // except new line
+        if (!tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true))
+            return matchExpressionInvalid("Expected new line");
     }
 
     return make_shared<ExpressionBlock>(statements);

src/main.cpp

@@ -56,27 +56,26 @@ int main(int argc, char **argv) {
 
     Lexer lexer(source);
     vector<shared_ptr<Token>> tokens = lexer.getTokens();
-    if (isVerbose)
+    if (isVerbose) {
         Logger::print(tokens);
+        cout << endl;
+    }
 
     Parser parser(tokens);
     vector<shared_ptr<Statement>> statements = parser.getStatements();
     if (isVerbose) {
-        for (shared_ptr<Statement> &statement : statements) {
-            cout << statement->toString(0);
-            cout << endl;
-        }
-        cout << endl << endl;
+        Logger::print(statements);
+        cout << endl;
     }
 
-    ModuleBuilder moduleBuilder(moduleName, inputFilePath, statements);
+    /*ModuleBuilder moduleBuilder(moduleName, inputFilePath, statements);
     shared_ptr<llvm::Module> module = moduleBuilder.getModule();
     if (isVerbose) {
         module->print(llvm::outs(), nullptr);
     }
 
     CodeGenerator codeGenerator(module);
-    codeGenerator.generateObjectFile(outputKind);
+    codeGenerator.generateObjectFile(outputKind);*/
 
     return 0;
 }