Each statement class in separate file

src/Parser/Statement/Statement.cpp

@@ -0,0 +1,16 @@
+#include "Statement.h"
+
+Statement::Statement(StatementKind kind):
+kind(kind) { }
+
+StatementKind Statement::getKind() {
+    return kind;
+}
+
+bool Statement::isValid() {
+    return kind != StatementKind::INVALID;
+}
+
+string Statement::toString(int indent) {
+   return "STATEMENT";
+}

src/Parser/Statement/Statement.h

@@ -0,0 +1,40 @@
+#ifndef STATEMENT_H
+#define STATEMENT_H
+
+#include <iostream>
+
+#include "Lexer/Token.h"
+#include "Parser/Expression.h"
+#include "Types.h"
+
+class Expression;
+class Statement;
+class StatementBlock;
+class StatementReturn;
+class StatementExpression;
+class StatementInvalid;
+
+using namespace std;
+
+enum class StatementKind {
+    FUNCTION_DECLARATION,
+    VAR_DECLARATION,
+    BLOCK,
+    RETURN,
+    EXPRESSION,
+    META_EXTERN_FUNCTION,
+    INVALID
+};
+
+class Statement {
+private:
+    StatementKind kind;
+
+public:
+    Statement(StatementKind kind);
+    StatementKind getKind();
+    bool isValid();
+    virtual string toString(int indent);
+};
+
+#endif

src/Parser/Statement/StatementBlock.cpp

@@ -0,0 +1,38 @@
+#include "StatementBlock.h"
+
+#include "Parser/Statement/StatementExpression.h"
+
+StatementBlock::StatementBlock(vector<shared_ptr<Statement>> statements):
+Statement(StatementKind::BLOCK), statements(statements) {
+    if (!statements.empty() && statements.back()->getKind() == StatementKind::EXPRESSION) {
+        statementExpression = dynamic_pointer_cast<StatementExpression>(statements.back());
+        this->statements.pop_back();
+    }
+}
+
+vector<shared_ptr<Statement>> StatementBlock::getStatements() {
+    return statements;
+}
+
+shared_ptr<StatementExpression> StatementBlock::getStatementExpression() {
+    return statementExpression;
+}
+
+string StatementBlock::toString(int indent) {
+    string value;
+    for (int i=0; i<statements.size(); i++) {
+        //for (int ind=0; ind<indent; ind++)
+        //    value += "  ";
+        value += statements.at(i)->toString(indent);
+    }
+    if (statementExpression != nullptr) {
+        for (int ind=0; ind<indent; ind++)
+            value += "  ";
+        value += "WRAP_UP:\n";
+        value += statementExpression->toString(indent);
+    }
+    for (int ind=0; ind<indent; ind++)
+        value += "  ";
+    value += "#\n";
+    return value;
+}

src/Parser/Statement/StatementBlock.h

@@ -0,0 +1,13 @@
+#include "Parser/Statement/Statement.h"
+
+class StatementBlock: public Statement {
+private:
+    vector<shared_ptr<Statement>> statements;
+    shared_ptr<StatementExpression> statementExpression;
+
+public:
+    StatementBlock(vector<shared_ptr<Statement>> statements);
+    vector<shared_ptr<Statement>> getStatements();
+    shared_ptr<StatementExpression> getStatementExpression();
+    string toString(int indent) override;
+};

src/Parser/Statement/StatementExpression.cpp

@@ -0,0 +1,17 @@
+#include "StatementExpression.h"
+
+StatementExpression::StatementExpression(shared_ptr<Expression> expression):
+Statement(StatementKind::EXPRESSION), expression(expression) { }
+
+shared_ptr<Expression> StatementExpression::getExpression() {
+    return expression;
+}
+
+string StatementExpression::toString(int indent) {
+    string value;
+    for (int ind=0; ind<indent; ind++)
+        value += "  ";
+    value += expression->toString(indent);
+    value += "\n";
+    return value;
+}

src/Parser/Statement/StatementExpression.h

@@ -0,0 +1,11 @@
+#include "Parser/Statement/Statement.h"
+
+class StatementExpression: public Statement {
+private:
+    shared_ptr<Expression> expression;
+
+public:
+    StatementExpression(shared_ptr<Expression> expression);
+    shared_ptr<Expression> getExpression();
+    string toString(int indent) override;
+};

src/Parser/Statement/StatementFunction.cpp

@@ -0,0 +1,49 @@
+#include "StatementFunction.h"
+
+#include "Parser/Statement/StatementBlock.h"
+
+static string valueTypeToString(ValueType valueType) {
+    switch (valueType) {
+        case ValueType::NONE:
+            return "NONE";
+        case ValueType::BOOL:
+            return "BOOL";
+        case ValueType::SINT32:
+            return "SINT32";
+        case ValueType::REAL32:
+            return "REAL32";
+    }
+}
+
+StatementFunction::StatementFunction(string name, vector<pair<string, ValueType>> arguments, ValueType returnValueType, shared_ptr<StatementBlock> statementBlock):
+Statement(StatementKind::FUNCTION_DECLARATION), name(name), arguments(arguments), returnValueType(returnValueType), statementBlock(statementBlock) { }
+
+string StatementFunction::getName() {
+    return name;
+}
+
+vector<pair<string, ValueType>> StatementFunction::getArguments() {
+    return arguments;
+}
+
+ValueType StatementFunction::getReturnValueType() {
+    return returnValueType;
+}
+
+shared_ptr<StatementBlock> StatementFunction::getStatementBlock() {
+    return statementBlock;
+}
+
+string StatementFunction::toString(int indent) {
+    string value = "";
+    for (int ind=0; ind<indent; ind++)
+        value += "  ";
+    value += "FUNCTION(";
+    value += valueTypeToString(returnValueType);
+    value += ", " + name + "):\n";
+    value += statementBlock->toString(indent+1);
+    for (int ind=0; ind<indent; ind++)
+        value += "  ";
+    value += ";";
+    return value;
+}

src/Parser/Statement/StatementFunction.h

@@ -0,0 +1,19 @@
+#include "Parser/Statement/Statement.h"
+
+class StatementBlock;
+
+class StatementFunction: public Statement {
+private:
+    string name;
+    vector<pair<string, ValueType>> arguments;
+    ValueType returnValueType;
+    shared_ptr<StatementBlock> statementBlock;
+
+public:
+    StatementFunction(string name, vector<pair<string, ValueType>> arguments, ValueType returnValueType, shared_ptr<StatementBlock> statementBlock);
+    string getName();
+    vector<pair<string, ValueType>> getArguments();
+    ValueType getReturnValueType();
+    shared_ptr<StatementBlock> getStatementBlock();
+    string toString(int indent) override;
+};

src/Parser/Statement/StatementInvalid.cpp

@@ -0,0 +1,12 @@
+#include "Parser/Statement/StatementInvalid.h"
+
+StatementInvalid::StatementInvalid(shared_ptr<Token> token, string message):
+Statement(StatementKind::INVALID), token(token), message(message) { }
+
+string StatementInvalid::toString(int indent) {
+    return "Error for token " + token->toString() + " at " + to_string(token->getLine()) + ":" + to_string(token->getColumn()) + ": " + message + "\n";
+}
+
+string StatementInvalid::getMessage() {
+    return message;
+}

src/Parser/Statement/StatementInvalid.h

@@ -0,0 +1,12 @@
+#include "Parser/Statement/Statement.h"
+
+class StatementInvalid: public Statement {
+private:
+    shared_ptr<Token> token;
+    string message;
+
+public:
+    StatementInvalid(shared_ptr<Token> token, string message);
+    string toString(int indent) override;
+    string getMessage();
+};

src/Parser/Statement/StatementMetaExternFunction.cpp

@@ -0,0 +1,40 @@
+#include "Parser/Statement/StatementMetaExternFunction.h"
+
+static string valueTypeToString(ValueType valueType) {
+    switch (valueType) {
+        case ValueType::NONE:
+            return "NONE";
+        case ValueType::BOOL:
+            return "BOOL";
+        case ValueType::SINT32:
+            return "SINT32";
+        case ValueType::REAL32:
+            return "REAL32";
+    }
+}
+
+StatementMetaExternFunction::StatementMetaExternFunction(string name, vector<pair<string, ValueType>> arguments, ValueType returnValueType):
+Statement(StatementKind::META_EXTERN_FUNCTION), name(name), arguments(arguments), returnValueType(returnValueType) { }
+
+string StatementMetaExternFunction::getName() {
+    return name;
+}
+
+vector<pair<string, ValueType>> StatementMetaExternFunction::getArguments() {
+    return arguments;
+}
+
+ValueType StatementMetaExternFunction::getReturnValueType() {
+    return returnValueType;
+}
+
+string StatementMetaExternFunction::toString(int indent) {
+    string value;
+    for (int ind=0; ind<indent; ind++)
+        value += "  ";
+    value += "EXTERN_FUN(";
+    value += name + ", ";
+    value += valueTypeToString(returnValueType);
+    value += ")\n";
+    return value;
+}

src/Parser/Statement/StatementMetaExternFunction.h

@@ -0,0 +1,15 @@
+#include "Parser/Parser.h"
+
+class StatementMetaExternFunction: public Statement {
+private:
+    string name;
+    vector<pair<string, ValueType>> arguments;
+    ValueType returnValueType;
+
+public:
+    StatementMetaExternFunction(string name, vector<pair<string, ValueType>> arguments, ValueType returnValueType);
+    string getName();
+    vector<pair<string, ValueType>> getArguments();
+    ValueType getReturnValueType();
+    string toString(int indent) override;
+};

src/Parser/Statement/StatementReturn.cpp

@@ -0,0 +1,25 @@
+#include "Parser/Statement/StatementReturn.h"
+
+#include "Parser/Expression.h"
+
+StatementReturn::StatementReturn(shared_ptr<Expression> expression):
+Statement(StatementKind::RETURN), expression(expression) { }
+
+shared_ptr<Expression> StatementReturn::getExpression() {
+    return expression;
+}
+
+string StatementReturn::toString(int indent) {
+    string value;
+    for (int ind=0; ind<indent; ind++)
+        value += "  ";
+    value += "RETURN";
+    if (expression != nullptr) {
+        value += ":\n";
+        for (int ind=0; ind<indent+1; ind++)
+            value += "  ";
+        value += expression->toString(indent+1);
+    }
+    value += "\n";
+    return value;
+}

src/Parser/Statement/StatementReturn.h

@@ -0,0 +1,13 @@
+#include "Parser/Statement/Statement.h"
+
+class Expression;
+
+class StatementReturn: public Statement {
+private:
+    shared_ptr<Expression> expression;
+
+public:
+    StatementReturn(shared_ptr<Expression> expression);
+    shared_ptr<Expression> getExpression();
+    string toString(int indent) override;
+};

src/Parser/Statement/StatementVariable.cpp

@@ -0,0 +1,43 @@
+#include "StatementVariable.h"
+
+static string valueTypeToString(ValueType valueType) {
+    switch (valueType) {
+        case ValueType::NONE:
+            return "NONE";
+        case ValueType::BOOL:
+            return "BOOL";
+        case ValueType::SINT32:
+            return "SINT32";
+        case ValueType::REAL32:
+            return "REAL32";
+    }
+}
+
+StatementVariable::StatementVariable(string name, ValueType valueType, shared_ptr<Expression> expression):
+Statement(StatementKind::VAR_DECLARATION), name(name), valueType(valueType), expression(expression) { }
+
+string StatementVariable::getName() {
+    return name;
+}
+
+ValueType StatementVariable::getValueType() {
+    return valueType;
+}
+
+shared_ptr<Expression> StatementVariable::getExpression() {
+    return expression;
+}
+
+string StatementVariable::toString(int indent) {
+    string value;
+    for (int ind=0; ind<indent; ind++)
+        value += "  ";
+    value += name + "(";
+    value += valueTypeToString(valueType);
+    value += "):\n";
+    for (int ind=0; ind<indent+1; ind++)
+        value += "  ";
+    value += expression->toString(indent+1);
+    value += "\n";
+    return value;
+}

src/Parser/Statement/StatementVariable.h

@@ -0,0 +1,15 @@
+#include "Parser/Statement/Statement.h"
+
+class StatementVariable: public Statement {
+private:
+    string name;
+    ValueType valueType;
+    shared_ptr<Expression> expression;
+
+public:
+    StatementVariable(string name, ValueType valueType, shared_ptr<Expression> expression);
+    string getName();
+    ValueType getValueType();
+    shared_ptr<Expression> getExpression();
+    string toString(int indent) override;
+};