Merge pull request #20 from rafalgrodzinski/14-handle-types-through-a-single-class

Handle types through a single class

src/Compiler/ModuleBuilder.cpp

@@ -1,5 +1,7 @@
 #include "ModuleBuilder.h"
 
+#include "Parser/ValueType.h"
+
 #include "Parser/Expression/ExpressionGrouping.h"
 #include "Parser/Expression/ExpressionLiteral.h"
 #include "Parser/Expression/ExpressionVariable.h"
@@ -71,7 +73,7 @@ void ModuleBuilder::buildStatement(shared_ptr<Statement> statement) {
 void ModuleBuilder::buildFunctionDeclaration(shared_ptr<StatementFunction> statement) {
     // get argument types
     vector<llvm::Type *> types;
-    for (pair<string, ValueType> &arg : statement->getArguments()) {
+    for (pair<string, shared_ptr<ValueType>> &arg : statement->getArguments()) {
         types.push_back(typeForValueType(arg.second));
     }
 
@@ -184,7 +186,7 @@ void ModuleBuilder::buildLoop(shared_ptr<StatementRepeat> statement) {
 void ModuleBuilder::buildMetaExternFunction(shared_ptr<StatementMetaExternFunction> statement) {
     // get argument types
     vector<llvm::Type *> types;
-    for (pair<string, ValueType> &arg : statement->getArguments()) {
+    for (pair<string, shared_ptr<ValueType>> &arg : statement->getArguments()) {
         types.push_back(typeForValueType(arg.second));
     }
 
@@ -226,14 +228,14 @@ llvm::Value *ModuleBuilder::valueForExpression(shared_ptr<Expression> expression
 }
 
 llvm::Value *ModuleBuilder::valueForLiteral(shared_ptr<ExpressionLiteral> expression) {
-    switch (expression->getValueType()) {
+    switch (expression->getValueType()->getKind()) {
-        case ValueType::NONE:
+        case ValueTypeKind::NONE:
             return llvm::UndefValue::get(typeVoid);
-        case ValueType::BOOL:
+        case ValueTypeKind::BOOL:
             return llvm::ConstantInt::get(typeBool, expression->getBoolValue(), true);
-        case ValueType::SINT32:
+        case ValueTypeKind::SINT32:
             return llvm::ConstantInt::get(typeSint32, expression->getSint32Value(), true);
-        case ValueType::REAL32:
+        case ValueTypeKind::REAL32:
             return llvm::ConstantInt::get(typeReal32, expression->getReal32Value(), true);
     }
 }
@@ -393,15 +395,15 @@ llvm::Value *ModuleBuilder::valueForCall(shared_ptr<ExpressionCall> expression)
     return builder->CreateCall(funType, fun, llvm::ArrayRef(argValues));
 }
 
-llvm::Type *ModuleBuilder::typeForValueType(ValueType valueType) {
+llvm::Type *ModuleBuilder::typeForValueType(shared_ptr<ValueType> valueType) {
-    switch (valueType) {
+    switch (valueType->getKind()) {
-        case ValueType::NONE:
+        case ValueTypeKind::NONE:
             return typeVoid;
-        case ValueType::BOOL:
+        case ValueTypeKind::BOOL:
             return typeBool;
-        case ValueType::SINT32:
+        case ValueTypeKind::SINT32:
             return typeSint32;
-        case ValueType::REAL32:
+        case ValueTypeKind::REAL32:
             return typeReal32;
     }
 }

src/Compiler/ModuleBuilder.h

@@ -10,7 +10,7 @@
 #include <llvm/Support/raw_ostream.h>
 #include <llvm/IR/Verifier.h>
 
-#include "Types.h"
+class ValueType;
 
 class Expression;
 class ExpressionGrouping;
@@ -72,7 +72,7 @@ private:
     llvm::Value *valueForVar(shared_ptr<ExpressionVariable> expression);
     llvm::Value *valueForCall(shared_ptr<ExpressionCall> expression);
 
-    llvm::Type *typeForValueType(ValueType valueType);
+    llvm::Type *typeForValueType(shared_ptr<ValueType> valueType);
     void failWithMessage(string message);
 
 public:

src/Lexer/Lexer.cpp

@@ -4,8 +4,8 @@
 #include "Error.h"
 #include "Logger.h"
 
-Lexer::Lexer(string source): source(source) {
+Lexer::Lexer(string source):
-}
+source(source) { }
 
 vector<shared_ptr<Token>> Lexer::getTokens() {
     currentIndex = 0;

src/Lexer/Token.cpp

@@ -45,8 +45,7 @@ vector<TokenKind> Token::tokensLiteral = {
 };
 
 Token::Token(TokenKind kind, string lexme, int line, int column):
-    kind(kind), lexme(lexme), line(line), column(column) {
+kind(kind), lexme(lexme), line(line), column(column) { }
-}
 
 TokenKind Token::getKind() {
     return kind;

src/Lexer/Token.h

@@ -3,8 +3,6 @@
 
 #include <iostream>
 
-#include "Types.h"
-
 using namespace std;
 
 enum class TokenKind {        

src/Logger.cpp

@@ -3,6 +3,7 @@
 #include <iostream>
 
 #include "Lexer/Token.h"
+#include "Parser/ValueType.h"
 
 #include "Parser/Statement/Statement.h"
 #include "Parser/Statement/StatementMetaExternFunction.h"
@@ -150,6 +151,7 @@ string Logger::toString(TokenKind tokenKind) {
         case TokenKind::INTEGER_DEC:
         case TokenKind::INTEGER_HEX:
         case TokenKind::INTEGER_BIN:
+        case TokenKind::INTEGER_CHAR:
             return "LITERAL(INTEGER)";
         case TokenKind::REAL:
             return "LITERAL(REAL)";
@@ -179,6 +181,19 @@ string Logger::toString(TokenKind tokenKind) {
     }
 }
 
+string Logger::toString(shared_ptr<ValueType> valueType) {
+    switch (valueType->getKind()) {
+        case ValueTypeKind::NONE:
+            return "NONE";
+        case ValueTypeKind::BOOL:
+            return "BOOL";
+        case ValueTypeKind::SINT32:
+            return "SINT32";
+        case ValueTypeKind::REAL32:
+            return "REAL32";
+    }
+}
+
 string Logger::toString(shared_ptr<Statement> statement) {
     switch (statement->getKind()) {
         case StatementKind::META_EXTERN_FUNCTION:
@@ -281,19 +296,6 @@ 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) {
     switch (expression->getKind()) {
         case ExpressionKind::BINARY:
@@ -337,6 +339,8 @@ string Logger::toString(shared_ptr<ExpressionBinary> expression) {
             return "{/ " + toString(expression->getLeft()) + " " + toString(expression->getRight()) + "}";
         case ExpressionBinaryOperation::MOD:
             return "{% " + toString(expression->getLeft()) + " " + toString(expression->getRight()) + "}";
+        case ExpressionBinaryOperation::INVALID:
+            return "{INVALID}";
     }
 }
 
@@ -363,14 +367,14 @@ string Logger::toString(shared_ptr<ExpressionGrouping> expression) {
 }
 
 string Logger::toString(shared_ptr<ExpressionLiteral> expression) {
-    switch (expression->getValueType()) {
+    switch (expression->getValueType()->getKind()) {
-        case ValueType::NONE:
+        case ValueTypeKind::NONE:
             return "NONE";
-        case ValueType::BOOL:
+        case ValueTypeKind::BOOL:
             return expression->getBoolValue() ? "true" : "false";
-        case ValueType::SINT32:
+        case ValueTypeKind::SINT32:
             return to_string(expression->getSint32Value());
-        case ValueType::REAL32:
+        case ValueTypeKind::REAL32:
             return to_string(expression->getReal32Value());
     }
 }

src/Logger.h

@@ -5,6 +5,8 @@
 
 class Token;
 enum class TokenKind;
+class ValueType;
+
 class Statement;
 class StatementMetaExternFunction;
 class StatementVariable;
@@ -24,8 +26,6 @@ class ExpressionLiteral;
 class ExpressionCall;
 class ExpressionBlock;
 
-enum class ValueType;
-
 class Error;
 
 using namespace std;
@@ -34,6 +34,7 @@ class Logger {
 private:
     static string toString(shared_ptr<Token> token);
     static string toString(TokenKind tokenKind);
+    static string toString(shared_ptr<ValueType> valueType);
 
     static string toString(shared_ptr<Statement> statement);
     static string toString(shared_ptr<StatementMetaExternFunction> statement);
@@ -54,8 +55,6 @@ private:
     static string toString(shared_ptr<ExpressionCall> expression);
     static string toString(shared_ptr<ExpressionBlock> expression);
 
-    static string toString(ValueType valueType);
-
 public:
     static void print(vector<shared_ptr<Token>> tokens);
     static void print(vector<shared_ptr<Statement>> statements);

src/Parser/Expression/Expression.cpp

@@ -1,13 +1,12 @@
 #include "Expression.h"
 
-Expression::Expression(ExpressionKind kind, ValueType valueType):
+Expression::Expression(ExpressionKind kind, shared_ptr<ValueType> valueType):
-    kind(kind), valueType(valueType) {
+kind(kind), valueType(valueType) { }
-}
 
 ExpressionKind Expression::getKind() {
     return kind;
 }
 
-ValueType Expression::getValueType() {
+shared_ptr<ValueType> Expression::getValueType() {
     return valueType;
 }

src/Parser/Expression/Expression.h

@@ -3,8 +3,8 @@
 
 #include <iostream>
 
-#include "Lexer/Token.h"
+class Token;
-#include "Types.h"
+class ValueType;
 
 using namespace std;
 
@@ -23,13 +23,13 @@ private:
     ExpressionKind kind;
 
 protected:
-    ValueType valueType;
+    shared_ptr<ValueType> valueType;
 
 public:
-    Expression(ExpressionKind kind, ValueType valueType);
+    Expression(ExpressionKind kind, shared_ptr<ValueType> valueType);
     virtual ~Expression() { }
     ExpressionKind getKind();
-    ValueType getValueType();
+    shared_ptr<ValueType> getValueType();
 };
 
 #endif

src/Parser/Expression/ExpressionBinary.cpp

@@ -1,7 +1,10 @@
 #include "ExpressionBinary.h"
 
+#include "Lexer/Token.h"
+#include "Parser/ValueType.h"
+
 ExpressionBinary::ExpressionBinary(shared_ptr<Token> token, shared_ptr<Expression> left, shared_ptr<Expression> right):
-Expression(ExpressionKind::BINARY, ValueType::NONE), operation(ExpressionBinaryOperation::INVALID), left(left), right(right) {
+Expression(ExpressionKind::BINARY, nullptr), operation(ExpressionBinaryOperation::INVALID), left(left), right(right) {
     switch (token->getKind()) {
         case TokenKind::EQUAL:
             operation = ExpressionBinaryOperation::EQUAL;
@@ -56,7 +59,7 @@ Expression(ExpressionKind::BINARY, ValueType::NONE), operation(ExpressionBinaryO
         valueType = ValueType::NONE;
 
     // Booleans can only do = or !=
-    if (valueType == ValueType::BOOL && (token->getKind() != TokenKind::EQUAL || token->getKind() != TokenKind::NOT_EQUAL))
+    if (valueType->getKind() == ValueTypeKind::BOOL && (token->getKind() != TokenKind::EQUAL || token->getKind() != TokenKind::NOT_EQUAL))
         valueType = ValueType::NONE;
 }
 

src/Parser/Expression/ExpressionBlock.cpp

@@ -5,7 +5,7 @@
 #include "Parser/Statement/StatementBlock.h"
 
 ExpressionBlock::ExpressionBlock(vector<shared_ptr<Statement>> statements):
-Expression(ExpressionKind::BLOCK, ValueType::NONE) {
+Expression(ExpressionKind::BLOCK, nullptr) {
     if (!statements.empty() && statements.back()->getKind() == StatementKind::EXPRESSION) {
         resultStatementExpression = dynamic_pointer_cast<StatementExpression>(statements.back());
         valueType = resultStatementExpression->getExpression()->getValueType();

src/Parser/Expression/ExpressionCall.cpp

@@ -1,7 +1,7 @@
 #include "ExpressionCall.h"
 
 ExpressionCall::ExpressionCall(string name, vector<shared_ptr<Expression>> argumentExpressions):
-Expression(ExpressionKind::CALL, ValueType::NONE), name(name), argumentExpressions(argumentExpressions) { }
+Expression(ExpressionKind::CALL, nullptr), name(name), argumentExpressions(argumentExpressions) { }
 
 string ExpressionCall::getName() {
     return name;

src/Parser/Expression/ExpressionIfElse.cpp

@@ -3,7 +3,7 @@
 #include "Parser/Expression/ExpressionBlock.h"
 
 ExpressionIfElse::ExpressionIfElse(shared_ptr<Expression> condition, shared_ptr<ExpressionBlock> thenBlock, shared_ptr<ExpressionBlock> elseBlock):
-Expression(ExpressionKind::IF_ELSE, ValueType::NONE), condition(condition), thenBlock(thenBlock), elseBlock(elseBlock) {
+Expression(ExpressionKind::IF_ELSE, nullptr), condition(condition), thenBlock(thenBlock), elseBlock(elseBlock) {
     // Figure out resulting type
     if (elseBlock == nullptr || thenBlock->getValueType() == elseBlock->getValueType())
         valueType = thenBlock->getValueType();

src/Parser/Expression/ExpressionLiteral.cpp

@@ -1,27 +1,30 @@
 #include "ExpressionLiteral.h"
 
+#include "Lexer/Token.h"
+#include "Parser/ValueType.h"
+
 ExpressionLiteral::ExpressionLiteral():
-Expression(ExpressionKind::LITERAL, ValueType::NONE) { }
+Expression(ExpressionKind::LITERAL, nullptr) { }
 
 ExpressionLiteral::ExpressionLiteral(shared_ptr<Token> token):
-Expression(ExpressionKind::LITERAL, ValueType::NONE) {
+Expression(ExpressionKind::LITERAL, nullptr) {
     switch (token->getKind()) {
         case TokenKind::BOOL:
             boolValue = token->getLexme().compare("true") == 0;
-            valueType = ValueType::BOOL;
+            valueType = ValueType::valueTypeForToken(token);
             break;
         case TokenKind::INTEGER_DEC: {
             string numString = token->getLexme();
             erase(numString, '_');
             sint32Value = stoi(numString, nullptr, 10);
-            valueType = ValueType::SINT32;
+            valueType = ValueType::valueTypeForToken(token);
             break;
         }
         case TokenKind::INTEGER_HEX: {
             string numString = token->getLexme();
             erase(numString, '_');
             sint32Value = stoi(numString, nullptr, 16);
-            valueType = ValueType::SINT32;
+            valueType = ValueType::valueTypeForToken(token);
             break;
         }
         case TokenKind::INTEGER_BIN: {
@@ -29,13 +32,13 @@ Expression(ExpressionKind::LITERAL, ValueType::NONE) {
             erase(numString, '_');
             numString = numString.substr(2, numString.size()-1);
             sint32Value = stoi(numString, nullptr, 2);
-            valueType = ValueType::SINT32;
+            valueType = ValueType::valueTypeForToken(token);
             break;
         }
         case TokenKind::INTEGER_CHAR: {
             string charString = token->getLexme();
 
-            valueType = ValueType::SINT32;
+            valueType = ValueType::valueTypeForToken(token);
             if (charString.length() == 3) {
                 sint32Value = charString[1];
             } else if (charString.length() == 4 && charString[1] == '\\') {
@@ -64,7 +67,7 @@ Expression(ExpressionKind::LITERAL, ValueType::NONE) {
         }
         case TokenKind::REAL:
             real32Value = stof(token->getLexme());
-            valueType = ValueType::REAL32;
+            valueType = ValueType::valueTypeForToken(token);
             break;
         default:
             exit(1);

src/Parser/Expression/ExpressionLiteral.h

@@ -5,8 +5,7 @@ private:
     bool boolValue;
     int32_t sint32Value;
     float real32Value;
-    
+
-    
 public:
     ExpressionLiteral(shared_ptr<Token> token);
     ExpressionLiteral();

src/Parser/Expression/ExpressionVariable.cpp

@@ -1,7 +1,7 @@
 #include "ExpressionVariable.h"
 
 ExpressionVariable::ExpressionVariable(string name):
-Expression(ExpressionKind::VAR, ValueType::NONE), name(name) { }
+Expression(ExpressionKind::VAR, nullptr), name(name) { }
 
 string ExpressionVariable::getName() {
     return name;

src/Parser/Parser.cpp

@@ -3,6 +3,9 @@
 #include "Error.h"
 #include "Logger.h"
 
+#include "Lexer/Token.h"
+#include "Parser/ValueType.h"
+
 #include "Parser/Expression/ExpressionGrouping.h"
 #include "Parser/Expression/ExpressionLiteral.h"
 #include "Parser/Expression/ExpressionVariable.h"
@@ -20,8 +23,8 @@
 #include "Parser/Statement/StatementBlock.h"
 #include "Parser/Statement/StatementRepeat.h"
 
-Parser::Parser(vector<shared_ptr<Token>> tokens): tokens(tokens) {
+Parser::Parser(vector<shared_ptr<Token>> tokens) :
-}
+tokens(tokens) { }
 
 vector<shared_ptr<Statement>> Parser::getStatements() {
     vector<shared_ptr<Statement>> statements;
@@ -102,8 +105,8 @@ shared_ptr<Statement> Parser::matchStatementMetaExternFunction() {
         return nullptr;
 
     string name;
-    vector<pair<string, ValueType>> arguments;
+    vector<pair<string, shared_ptr<ValueType>>> arguments;
-    ValueType returnType = ValueType::NONE;
+    shared_ptr<ValueType> returnType = ValueType::NONE;
 
     currentIndex++; // skip meta
     shared_ptr<Token> identifierToken = tokens.at(currentIndex++);
@@ -118,14 +121,14 @@ shared_ptr<Statement> Parser::matchStatementMetaExternFunction() {
                 return nullptr;
             }
             shared_ptr<Token> identifierToken = tokens.at(currentIndex++);
-            shared_ptr<Token> typeToken = tokens.at(currentIndex++);
+            shared_ptr<Token> argumentTypeToken = tokens.at(currentIndex++);
-            optional<ValueType> argumentType = valueTypeForToken(typeToken);
+            shared_ptr<ValueType> argumentType = ValueType::valueTypeForToken(argumentTypeToken);
-            if (!argumentType) {
+            if (argumentType == nullptr) {
                 markError(TokenKind::TYPE, {});
                 return nullptr;
             }
             
-            arguments.push_back(pair<string, ValueType>(identifierToken->getLexme(), *argumentType));
+            arguments.push_back(pair<string, shared_ptr<ValueType>>(identifierToken->getLexme(), argumentType));
         } while (tryMatchingTokenKinds({TokenKind::COMMA}, true, true));
     }
 
@@ -133,13 +136,12 @@ shared_ptr<Statement> Parser::matchStatementMetaExternFunction() {
     if (tryMatchingTokenKinds({TokenKind::RIGHT_ARROW}, true, true)) {
         tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true); // skip new line
 
-        shared_ptr<Token> typeToken = tokens.at(currentIndex);
+        shared_ptr<Token> returnTypeToken = tokens.at(currentIndex);
-        optional<ValueType> type = valueTypeForToken(typeToken);
+        returnType = ValueType::valueTypeForToken(returnTypeToken);
-        if (!type) {
+        if (returnType == nullptr) {
             markError(TokenKind::TYPE, {});
             return nullptr;
         }
-        returnType = *type;
 
         currentIndex++; // type
     }
@@ -154,7 +156,7 @@ shared_ptr<Statement> Parser::matchStatementVariable() {
     shared_ptr<Token> identifierToken = tokens.at(currentIndex++);
     shared_ptr<Token> valueTypeToken = tokens.at(currentIndex);
 
-    ValueType valueType;
+    shared_ptr<ValueType> valueType;
     if (valueTypeToken->getLexme().compare("bool") == 0)
         valueType = ValueType::BOOL; 
     else if (valueTypeToken->getLexme().compare("sint32") == 0)
@@ -186,8 +188,8 @@ shared_ptr<Statement> Parser::matchStatementFunction() {
         return nullptr;
 
     string name;
-    vector<pair<string, ValueType>> arguments;
+    vector<pair<string, shared_ptr<ValueType>>> arguments;
-    ValueType returnType = ValueType::NONE;
+    shared_ptr<ValueType> returnType = ValueType::NONE;
     shared_ptr<Statement> statementBlock;
 
     // name
@@ -203,14 +205,14 @@ shared_ptr<Statement> Parser::matchStatementFunction() {
                 return nullptr;
             }
             shared_ptr<Token> identifierToken = tokens.at(currentIndex++);
-            shared_ptr<Token> typeToken = tokens.at(currentIndex++);
+            shared_ptr<Token> argumentTypeToken = tokens.at(currentIndex++);
-            optional<ValueType> argumentType = valueTypeForToken(typeToken);
+            shared_ptr<ValueType> argumentType = ValueType::valueTypeForToken(argumentTypeToken);
-            if (!argumentType) {
+            if (argumentType == nullptr) {
                 markError(TokenKind::TYPE, {});
                 return nullptr;
             }
             
-            arguments.push_back(pair<string, ValueType>(identifierToken->getLexme(), *argumentType));
+            arguments.push_back(pair<string, shared_ptr<ValueType>>(identifierToken->getLexme(), argumentType));
         } while (tryMatchingTokenKinds({TokenKind::COMMA}, true, true));
     }
 
@@ -218,13 +220,12 @@ shared_ptr<Statement> Parser::matchStatementFunction() {
     if (tryMatchingTokenKinds({TokenKind::RIGHT_ARROW}, true, true)) {
         tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true); // skip new line
 
-        shared_ptr<Token> typeToken = tokens.at(currentIndex);
+        shared_ptr<Token> returnTypeToken = tokens.at(currentIndex);
-        optional<ValueType> type = valueTypeForToken(typeToken);
+        returnType = ValueType::valueTypeForToken(returnTypeToken);
-        if (!type) {
+        if (returnType == nullptr) {
             markError(TokenKind::TYPE, {});
             return nullptr;
         }
-        returnType = *type;
 
         currentIndex++; // type
     }
@@ -639,20 +640,6 @@ bool Parser::tryMatchingTokenKinds(vector<TokenKind> kinds, bool shouldMatchAll,
     }
 }
 
-optional<ValueType> Parser::valueTypeForToken(shared_ptr<Token> token) {
-    if (token->getKind() != TokenKind::TYPE)
-        return {};
-    
-    if (token->getLexme().compare("bool") == 0)
-        return ValueType::BOOL; 
-    else if (token->getLexme().compare("sint32") == 0)
-        return ValueType::SINT32;
-    else if (token->getLexme().compare("real32") == 0)
-        return ValueType::REAL32;
-
-    return {};
-}
-
 void Parser::markError(optional<TokenKind> expectedTokenKind, optional<string> message) {
     shared_ptr<Token> actualToken = tokens.at(currentIndex);
 

src/Parser/Parser.h

@@ -2,7 +2,6 @@
 #define PARSER_H
 
 #include <vector>
-#include "Types.h"
 
 class Token;
 enum class TokenKind;
@@ -48,7 +47,6 @@ private:
     shared_ptr<Expression> matchExpressionBlock(vector<TokenKind> terminalTokenKinds);
 
     bool tryMatchingTokenKinds(vector<TokenKind> kinds, bool shouldMatchAll, bool shouldAdvance);
-    optional<ValueType> valueTypeForToken(shared_ptr<Token> token);
 
     void markError(optional<TokenKind> expectedTokenKind, optional<string> message);
 

src/Parser/Statement/Statement.h

@@ -3,8 +3,6 @@
 
 #include <iostream>
 
-#include "Types.h"
-
 using namespace std;
 
 enum class StatementKind {

src/Parser/Statement/StatementFunction.cpp

@@ -3,20 +3,7 @@
 #include "Parser/Statement/StatementBlock.h"
 #include "Parser/Statement/StatementReturn.h"
 
-static string valueTypeToString(ValueType valueType) {
+StatementFunction::StatementFunction(string name, vector<pair<string, shared_ptr<ValueType>>> arguments, shared_ptr<ValueType> returnValueType, shared_ptr<StatementBlock> statementBlock):
-    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), name(name), arguments(arguments), returnValueType(returnValueType), statementBlock(statementBlock) {
     vector<shared_ptr<Statement>> statements = statementBlock->getStatements();
     if (!statements.empty() && statements.back()->getKind() == StatementKind::RETURN)
@@ -32,11 +19,11 @@ string StatementFunction::getName() {
     return name;
 }
 
-vector<pair<string, ValueType>> StatementFunction::getArguments() {
+vector<pair<string, shared_ptr<ValueType>>> StatementFunction::getArguments() {
     return arguments;
 }
 
-ValueType StatementFunction::getReturnValueType() {
+shared_ptr<ValueType> StatementFunction::getReturnValueType() {
     return returnValueType;
 }
 

src/Parser/Statement/StatementFunction.h

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

src/Parser/Statement/StatementMetaExternFunction.cpp

@@ -1,29 +1,16 @@
 #include "Parser/Statement/StatementMetaExternFunction.h"
 
-static string valueTypeToString(ValueType valueType) {
+StatementMetaExternFunction::StatementMetaExternFunction(string name, vector<pair<string, shared_ptr<ValueType>>> arguments, shared_ptr<ValueType> returnValueType):
-    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() {
+vector<pair<string, shared_ptr<ValueType>>> StatementMetaExternFunction::getArguments() {
     return arguments;
 }
 
-ValueType StatementMetaExternFunction::getReturnValueType() {
+shared_ptr<ValueType> StatementMetaExternFunction::getReturnValueType() {
     return returnValueType;
 }

src/Parser/Statement/StatementMetaExternFunction.h

@@ -1,14 +1,16 @@
 #include "Parser/Statement/Statement.h"
 
+class ValueType;
+
 class StatementMetaExternFunction: public Statement {
 private:
     string name;
-    vector<pair<string, ValueType>> arguments;
+    vector<pair<string, shared_ptr<ValueType>>> arguments;
-    ValueType returnValueType;
+    shared_ptr<ValueType> returnValueType;
 
 public:
-    StatementMetaExternFunction(string name, vector<pair<string, ValueType>> arguments, ValueType returnValueType);
+    StatementMetaExternFunction(string name, vector<pair<string, shared_ptr<ValueType>>> arguments, shared_ptr<ValueType> returnValueType);
     string getName();
-    vector<pair<string, ValueType>> getArguments();
+    vector<pair<string, shared_ptr<ValueType>>> getArguments();
-    ValueType getReturnValueType();
+    shared_ptr<ValueType> getReturnValueType();
 };

src/Parser/Statement/StatementVariable.cpp

@@ -2,27 +2,14 @@
 
 #include "Parser/Expression/Expression.h"
 
-static string valueTypeToString(ValueType valueType) {
+StatementVariable::StatementVariable(string name, shared_ptr<ValueType> valueType, shared_ptr<Expression> expression):
-    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::VARIABLE), name(name), valueType(valueType), expression(expression) { }
 
 string StatementVariable::getName() {
     return name;
 }
 
-ValueType StatementVariable::getValueType() {
+shared_ptr<ValueType> StatementVariable::getValueType() {
     return valueType;
 }
 

src/Parser/Statement/StatementVariable.h

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

src/Parser/ValueType.cpp

@@ -0,0 +1,42 @@
+#include "ValueType.h"
+
+#include "Lexer/Token.h"
+
+shared_ptr<ValueType> ValueType::NONE = make_shared<ValueType>(ValueTypeKind::NONE);
+shared_ptr<ValueType> ValueType::BOOL = make_shared<ValueType>(ValueTypeKind::BOOL);
+shared_ptr<ValueType> ValueType::SINT32 = make_shared<ValueType>(ValueTypeKind::SINT32);
+shared_ptr<ValueType> ValueType::REAL32 = make_shared<ValueType>(ValueTypeKind::REAL32);
+
+ValueType::ValueType(ValueTypeKind kind):
+kind(kind) { }
+
+shared_ptr<ValueType> ValueType::valueTypeForToken(shared_ptr<Token> token) {
+    switch (token->getKind()) {
+        case TokenKind::TYPE: {
+            string lexme = token->getLexme();
+            if (lexme.compare("bool") == 0)
+                return make_shared<ValueType>(ValueTypeKind::BOOL);
+            else if (lexme.compare("sint32") == 0)
+                return make_shared<ValueType>(ValueTypeKind::SINT32);
+            else if (lexme.compare("real32") == 0)
+                return make_shared<ValueType>(ValueTypeKind::REAL32);
+            else
+                return nullptr;
+        }
+        case TokenKind::BOOL:
+            return make_shared<ValueType>(ValueTypeKind::BOOL);
+        case TokenKind::INTEGER_DEC:
+        case TokenKind::INTEGER_HEX:
+        case TokenKind::INTEGER_BIN:
+        case TokenKind::INTEGER_CHAR:
+            return make_shared<ValueType>(ValueTypeKind::SINT32);
+        case TokenKind::REAL:
+            return make_shared<ValueType>(ValueTypeKind::REAL32);
+        default:
+            return nullptr;
+    }
+}
+
+ValueTypeKind ValueType::getKind() {
+    return kind;
+}

src/Parser/ValueType.h

@@ -0,0 +1,32 @@
+#ifndef VALUE_TYPE_H
+#define VALUE_TYPE_H
+
+#include <optional>
+
+class Token;
+
+using namespace std;
+
+enum class ValueTypeKind {
+    NONE,
+    BOOL,
+    SINT32,
+    REAL32
+};
+
+class ValueType {
+private:
+    ValueTypeKind kind;
+
+public:
+    static shared_ptr<ValueType> NONE;
+    static shared_ptr<ValueType> BOOL;
+    static shared_ptr<ValueType> SINT32;
+    static shared_ptr<ValueType> REAL32;
+    static shared_ptr<ValueType> valueTypeForToken(shared_ptr<Token> token);
+
+    ValueType(ValueTypeKind kind);
+    ValueTypeKind getKind();
+};
+
+#endif

src/Types.h

@@ -1,11 +0,0 @@
-#ifndef TYPES_H
-#define TYPES_H
-
-enum class ValueType {
-    NONE,
-    BOOL,
-    SINT32,
-    REAL32
-};
-
-#endif