From 2a5085cb21d4ca422cfd5f3fc62ac0d2143930db Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rafa=C5=82=20Grodzi=C5=84ski?= Date: Fri, 4 Jul 2025 18:10:24 +0900 Subject: [PATCH] Added ValueType class --- src/Compiler/ModuleBuilder.cpp | 28 +++++---- src/Compiler/ModuleBuilder.h | 4 +- src/Lexer/Lexer.cpp | 4 +- src/Lexer/Token.cpp | 3 +- src/Lexer/Token.h | 2 - src/Logger.cpp | 35 +++++------ src/Logger.h | 7 +-- src/Parser/Expression/Expression.cpp | 7 +-- src/Parser/Expression/Expression.h | 10 +-- src/Parser/Expression/ExpressionBinary.cpp | 7 ++- src/Parser/Expression/ExpressionBlock.cpp | 2 +- src/Parser/Expression/ExpressionCall.cpp | 2 +- src/Parser/Expression/ExpressionIfElse.cpp | 2 +- src/Parser/Expression/ExpressionLiteral.cpp | 19 +++--- src/Parser/Expression/ExpressionLiteral.h | 3 +- src/Parser/Expression/ExpressionVariable.cpp | 2 +- src/Parser/Parser.cpp | 61 ++++++++----------- src/Parser/Parser.h | 2 - src/Parser/Statement/Statement.h | 2 - src/Parser/Statement/StatementFunction.cpp | 19 +----- src/Parser/Statement/StatementFunction.h | 11 ++-- .../Statement/StatementMetaExternFunction.cpp | 19 +----- .../Statement/StatementMetaExternFunction.h | 12 ++-- src/Parser/Statement/StatementVariable.cpp | 17 +----- src/Parser/Statement/StatementVariable.h | 7 ++- src/Parser/ValueType.cpp | 42 +++++++++++++ src/Parser/ValueType.h | 32 ++++++++++ src/Types.h | 11 ---- 28 files changed, 191 insertions(+), 181 deletions(-) create mode 100644 src/Parser/ValueType.cpp create mode 100644 src/Parser/ValueType.h delete mode 100644 src/Types.h diff --git a/src/Compiler/ModuleBuilder.cpp b/src/Compiler/ModuleBuilder.cpp index 28a4c00..eaebd4b 100644 --- a/src/Compiler/ModuleBuilder.cpp +++ b/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) { void ModuleBuilder::buildFunctionDeclaration(shared_ptr statement) { // get argument types vector types; - for (pair &arg : statement->getArguments()) { + for (pair> &arg : statement->getArguments()) { types.push_back(typeForValueType(arg.second)); } @@ -184,7 +186,7 @@ void ModuleBuilder::buildLoop(shared_ptr statement) { void ModuleBuilder::buildMetaExternFunction(shared_ptr statement) { // get argument types vector types; - for (pair &arg : statement->getArguments()) { + for (pair> &arg : statement->getArguments()) { types.push_back(typeForValueType(arg.second)); } @@ -226,14 +228,14 @@ llvm::Value *ModuleBuilder::valueForExpression(shared_ptr expression } llvm::Value *ModuleBuilder::valueForLiteral(shared_ptr expression) { - switch (expression->getValueType()) { - case ValueType::NONE: + switch (expression->getValueType()->getKind()) { + 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 expression) return builder->CreateCall(funType, fun, llvm::ArrayRef(argValues)); } -llvm::Type *ModuleBuilder::typeForValueType(ValueType valueType) { - switch (valueType) { - case ValueType::NONE: +llvm::Type *ModuleBuilder::typeForValueType(shared_ptr valueType) { + switch (valueType->getKind()) { + 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; } } diff --git a/src/Compiler/ModuleBuilder.h b/src/Compiler/ModuleBuilder.h index 1a91fdf..1850951 100644 --- a/src/Compiler/ModuleBuilder.h +++ b/src/Compiler/ModuleBuilder.h @@ -10,7 +10,7 @@ #include #include -#include "Types.h" +class ValueType; class Expression; class ExpressionGrouping; @@ -72,7 +72,7 @@ private: llvm::Value *valueForVar(shared_ptr expression); llvm::Value *valueForCall(shared_ptr expression); - llvm::Type *typeForValueType(ValueType valueType); + llvm::Type *typeForValueType(shared_ptr valueType); void failWithMessage(string message); public: diff --git a/src/Lexer/Lexer.cpp b/src/Lexer/Lexer.cpp index 3eae847..e90acb5 100644 --- a/src/Lexer/Lexer.cpp +++ b/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> Lexer::getTokens() { currentIndex = 0; diff --git a/src/Lexer/Token.cpp b/src/Lexer/Token.cpp index 78874d5..2d4817d 100644 --- a/src/Lexer/Token.cpp +++ b/src/Lexer/Token.cpp @@ -45,8 +45,7 @@ vector 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; diff --git a/src/Lexer/Token.h b/src/Lexer/Token.h index 3c28693..1987b11 100644 --- a/src/Lexer/Token.h +++ b/src/Lexer/Token.h @@ -3,8 +3,6 @@ #include -#include "Types.h" - using namespace std; enum class TokenKind { diff --git a/src/Logger.cpp b/src/Logger.cpp index c333c4f..ed7cc9f 100644 --- a/src/Logger.cpp +++ b/src/Logger.cpp @@ -3,6 +3,7 @@ #include #include "Lexer/Token.h" +#include "Parser/ValueType.h" #include "Parser/Statement/Statement.h" #include "Parser/Statement/StatementMetaExternFunction.h" @@ -179,6 +180,17 @@ string Logger::toString(TokenKind tokenKind) { } } +string Logger::toString(shared_ptr valueType) { + switch (valueType->getKind()) { + case ValueTypeKind::BOOL: + return "BOOL"; + case ValueTypeKind::SINT32: + return "SINT32"; + case ValueTypeKind::REAL32: + return "REAL32"; + } +} + string Logger::toString(shared_ptr statement) { switch (statement->getKind()) { case StatementKind::META_EXTERN_FUNCTION: @@ -281,19 +293,6 @@ string Logger::toString(shared_ptr 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) { switch (expression->getKind()) { case ExpressionKind::BINARY: @@ -363,14 +362,12 @@ string Logger::toString(shared_ptr expression) { } string Logger::toString(shared_ptr expression) { - switch (expression->getValueType()) { - case ValueType::NONE: - return "NONE"; - case ValueType::BOOL: + switch (expression->getValueType()->getKind()) { + 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()); } } diff --git a/src/Logger.h b/src/Logger.h index 9d1735d..0ffcdff 100644 --- a/src/Logger.h +++ b/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); static string toString(TokenKind tokenKind); + static string toString(shared_ptr valueType); static string toString(shared_ptr statement); static string toString(shared_ptr statement); @@ -54,8 +55,6 @@ private: static string toString(shared_ptr expression); static string toString(shared_ptr expression); - static string toString(ValueType valueType); - public: static void print(vector> tokens); static void print(vector> statements); diff --git a/src/Parser/Expression/Expression.cpp b/src/Parser/Expression/Expression.cpp index f5a5913..08829ab 100644 --- a/src/Parser/Expression/Expression.cpp +++ b/src/Parser/Expression/Expression.cpp @@ -1,13 +1,12 @@ #include "Expression.h" -Expression::Expression(ExpressionKind kind, ValueType valueType): - kind(kind), valueType(valueType) { -} +Expression::Expression(ExpressionKind kind, shared_ptr valueType): +kind(kind), valueType(valueType) { } ExpressionKind Expression::getKind() { return kind; } -ValueType Expression::getValueType() { +shared_ptr Expression::getValueType() { return valueType; } diff --git a/src/Parser/Expression/Expression.h b/src/Parser/Expression/Expression.h index 0a7f16c..249f606 100644 --- a/src/Parser/Expression/Expression.h +++ b/src/Parser/Expression/Expression.h @@ -3,8 +3,8 @@ #include -#include "Lexer/Token.h" -#include "Types.h" +class Token; +class ValueType; using namespace std; @@ -23,13 +23,13 @@ private: ExpressionKind kind; protected: - ValueType valueType; + shared_ptr valueType; public: - Expression(ExpressionKind kind, ValueType valueType); + Expression(ExpressionKind kind, shared_ptr valueType); virtual ~Expression() { } ExpressionKind getKind(); - ValueType getValueType(); + shared_ptr getValueType(); }; #endif \ No newline at end of file diff --git a/src/Parser/Expression/ExpressionBinary.cpp b/src/Parser/Expression/ExpressionBinary.cpp index 29a42be..aa162fe 100644 --- a/src/Parser/Expression/ExpressionBinary.cpp +++ b/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, shared_ptr left, shared_ptr 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; } diff --git a/src/Parser/Expression/ExpressionBlock.cpp b/src/Parser/Expression/ExpressionBlock.cpp index c21d5ba..78f0df2 100644 --- a/src/Parser/Expression/ExpressionBlock.cpp +++ b/src/Parser/Expression/ExpressionBlock.cpp @@ -5,7 +5,7 @@ #include "Parser/Statement/StatementBlock.h" ExpressionBlock::ExpressionBlock(vector> statements): -Expression(ExpressionKind::BLOCK, ValueType::NONE) { +Expression(ExpressionKind::BLOCK, nullptr) { if (!statements.empty() && statements.back()->getKind() == StatementKind::EXPRESSION) { resultStatementExpression = dynamic_pointer_cast(statements.back()); valueType = resultStatementExpression->getExpression()->getValueType(); diff --git a/src/Parser/Expression/ExpressionCall.cpp b/src/Parser/Expression/ExpressionCall.cpp index ea917e9..6f22678 100644 --- a/src/Parser/Expression/ExpressionCall.cpp +++ b/src/Parser/Expression/ExpressionCall.cpp @@ -1,7 +1,7 @@ #include "ExpressionCall.h" ExpressionCall::ExpressionCall(string name, vector> argumentExpressions): -Expression(ExpressionKind::CALL, ValueType::NONE), name(name), argumentExpressions(argumentExpressions) { } +Expression(ExpressionKind::CALL, nullptr), name(name), argumentExpressions(argumentExpressions) { } string ExpressionCall::getName() { return name; diff --git a/src/Parser/Expression/ExpressionIfElse.cpp b/src/Parser/Expression/ExpressionIfElse.cpp index 5c2d6d9..7e2beaf 100644 --- a/src/Parser/Expression/ExpressionIfElse.cpp +++ b/src/Parser/Expression/ExpressionIfElse.cpp @@ -3,7 +3,7 @@ #include "Parser/Expression/ExpressionBlock.h" ExpressionIfElse::ExpressionIfElse(shared_ptr condition, shared_ptr thenBlock, shared_ptr 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(); diff --git a/src/Parser/Expression/ExpressionLiteral.cpp b/src/Parser/Expression/ExpressionLiteral.cpp index ee1c084..3bd506f 100644 --- a/src/Parser/Expression/ExpressionLiteral.cpp +++ b/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): -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); diff --git a/src/Parser/Expression/ExpressionLiteral.h b/src/Parser/Expression/ExpressionLiteral.h index 77972d2..0a9dfb2 100644 --- a/src/Parser/Expression/ExpressionLiteral.h +++ b/src/Parser/Expression/ExpressionLiteral.h @@ -5,8 +5,7 @@ private: bool boolValue; int32_t sint32Value; float real32Value; - - + public: ExpressionLiteral(shared_ptr token); ExpressionLiteral(); diff --git a/src/Parser/Expression/ExpressionVariable.cpp b/src/Parser/Expression/ExpressionVariable.cpp index da9e78e..b75cddf 100644 --- a/src/Parser/Expression/ExpressionVariable.cpp +++ b/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; diff --git a/src/Parser/Parser.cpp b/src/Parser/Parser.cpp index 2be34c2..af1a90d 100644 --- a/src/Parser/Parser.cpp +++ b/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> tokens): tokens(tokens) { -} +Parser::Parser(vector> tokens) : +tokens(tokens) { } vector> Parser::getStatements() { vector> statements; @@ -102,8 +105,8 @@ shared_ptr Parser::matchStatementMetaExternFunction() { return nullptr; string name; - vector> arguments; - ValueType returnType = ValueType::NONE; + vector>> arguments; + shared_ptr returnType = ValueType::NONE; currentIndex++; // skip meta shared_ptr identifierToken = tokens.at(currentIndex++); @@ -118,14 +121,14 @@ shared_ptr Parser::matchStatementMetaExternFunction() { return nullptr; } shared_ptr identifierToken = tokens.at(currentIndex++); - shared_ptr typeToken = tokens.at(currentIndex++); - optional argumentType = valueTypeForToken(typeToken); - if (!argumentType) { + shared_ptr argumentTypeToken = tokens.at(currentIndex++); + shared_ptr argumentType = ValueType::valueTypeForToken(argumentTypeToken); + if (argumentType == nullptr) { markError(TokenKind::TYPE, {}); return nullptr; } - arguments.push_back(pair(identifierToken->getLexme(), *argumentType)); + arguments.push_back(pair>(identifierToken->getLexme(), argumentType)); } while (tryMatchingTokenKinds({TokenKind::COMMA}, true, true)); } @@ -133,13 +136,12 @@ shared_ptr Parser::matchStatementMetaExternFunction() { if (tryMatchingTokenKinds({TokenKind::RIGHT_ARROW}, true, true)) { tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true); // skip new line - shared_ptr typeToken = tokens.at(currentIndex); - optional type = valueTypeForToken(typeToken); - if (!type) { + shared_ptr returnTypeToken = tokens.at(currentIndex); + shared_ptr returnType = ValueType::valueTypeForToken(returnTypeToken); + if (returnType == nullptr) { markError(TokenKind::TYPE, {}); return nullptr; } - returnType = *type; currentIndex++; // type } @@ -154,7 +156,7 @@ shared_ptr Parser::matchStatementVariable() { shared_ptr identifierToken = tokens.at(currentIndex++); shared_ptr valueTypeToken = tokens.at(currentIndex); - ValueType valueType; + shared_ptr valueType; if (valueTypeToken->getLexme().compare("bool") == 0) valueType = ValueType::BOOL; else if (valueTypeToken->getLexme().compare("sint32") == 0) @@ -186,8 +188,8 @@ shared_ptr Parser::matchStatementFunction() { return nullptr; string name; - vector> arguments; - ValueType returnType = ValueType::NONE; + vector>> arguments; + shared_ptr returnType = ValueType::NONE; shared_ptr statementBlock; // name @@ -203,14 +205,14 @@ shared_ptr Parser::matchStatementFunction() { return nullptr; } shared_ptr identifierToken = tokens.at(currentIndex++); - shared_ptr typeToken = tokens.at(currentIndex++); - optional argumentType = valueTypeForToken(typeToken); - if (!argumentType) { + shared_ptr argumentTypeToken = tokens.at(currentIndex++); + shared_ptr argumentType = ValueType::valueTypeForToken(argumentTypeToken); + if (argumentType == nullptr) { markError(TokenKind::TYPE, {}); return nullptr; } - arguments.push_back(pair(identifierToken->getLexme(), *argumentType)); + arguments.push_back(pair>(identifierToken->getLexme(), argumentType)); } while (tryMatchingTokenKinds({TokenKind::COMMA}, true, true)); } @@ -218,13 +220,12 @@ shared_ptr Parser::matchStatementFunction() { if (tryMatchingTokenKinds({TokenKind::RIGHT_ARROW}, true, true)) { tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true); // skip new line - shared_ptr typeToken = tokens.at(currentIndex); - optional type = valueTypeForToken(typeToken); - if (!type) { + shared_ptr returnTypeToken = tokens.at(currentIndex); + shared_ptr returnType = ValueType::valueTypeForToken(returnTypeToken); + if (returnType != nullptr) { markError(TokenKind::TYPE, {}); return nullptr; } - returnType = *type; currentIndex++; // type } @@ -639,20 +640,6 @@ bool Parser::tryMatchingTokenKinds(vector kinds, bool shouldMatchAll, } } -optional Parser::valueTypeForToken(shared_ptr 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 expectedTokenKind, optional message) { shared_ptr actualToken = tokens.at(currentIndex); diff --git a/src/Parser/Parser.h b/src/Parser/Parser.h index dd9cc58..1d6533c 100644 --- a/src/Parser/Parser.h +++ b/src/Parser/Parser.h @@ -2,7 +2,6 @@ #define PARSER_H #include -#include "Types.h" class Token; enum class TokenKind; @@ -48,7 +47,6 @@ private: shared_ptr matchExpressionBlock(vector terminalTokenKinds); bool tryMatchingTokenKinds(vector kinds, bool shouldMatchAll, bool shouldAdvance); - optional valueTypeForToken(shared_ptr token); void markError(optional expectedTokenKind, optional message); diff --git a/src/Parser/Statement/Statement.h b/src/Parser/Statement/Statement.h index f1e9b29..727e480 100644 --- a/src/Parser/Statement/Statement.h +++ b/src/Parser/Statement/Statement.h @@ -3,8 +3,6 @@ #include -#include "Types.h" - using namespace std; enum class StatementKind { diff --git a/src/Parser/Statement/StatementFunction.cpp b/src/Parser/Statement/StatementFunction.cpp index df5b24f..aefa974 100644 --- a/src/Parser/Statement/StatementFunction.cpp +++ b/src/Parser/Statement/StatementFunction.cpp @@ -3,20 +3,7 @@ #include "Parser/Statement/StatementBlock.h" #include "Parser/Statement/StatementReturn.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> arguments, ValueType returnValueType, shared_ptr statementBlock): +StatementFunction::StatementFunction(string name, vector>> arguments, shared_ptr returnValueType, shared_ptr statementBlock): Statement(StatementKind::FUNCTION), name(name), arguments(arguments), returnValueType(returnValueType), statementBlock(statementBlock) { vector> statements = statementBlock->getStatements(); if (!statements.empty() && statements.back()->getKind() == StatementKind::RETURN) @@ -32,11 +19,11 @@ string StatementFunction::getName() { return name; } -vector> StatementFunction::getArguments() { +vector>> StatementFunction::getArguments() { return arguments; } -ValueType StatementFunction::getReturnValueType() { +shared_ptr StatementFunction::getReturnValueType() { return returnValueType; } diff --git a/src/Parser/Statement/StatementFunction.h b/src/Parser/Statement/StatementFunction.h index 7e358b9..7b2ee84 100644 --- a/src/Parser/Statement/StatementFunction.h +++ b/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> arguments; - ValueType returnValueType; + vector>> arguments; + shared_ptr returnValueType; shared_ptr statementBlock; public: - StatementFunction(string name, vector> arguments, ValueType returnValueType, shared_ptr statementBlock); + StatementFunction(string name, vector>> arguments, shared_ptr returnValueType, shared_ptr statementBlock); string getName(); - vector> getArguments(); - ValueType getReturnValueType(); + vector>> getArguments(); + shared_ptr getReturnValueType(); shared_ptr getStatementBlock(); }; \ No newline at end of file diff --git a/src/Parser/Statement/StatementMetaExternFunction.cpp b/src/Parser/Statement/StatementMetaExternFunction.cpp index 6285def..2f74cab 100644 --- a/src/Parser/Statement/StatementMetaExternFunction.cpp +++ b/src/Parser/Statement/StatementMetaExternFunction.cpp @@ -1,29 +1,16 @@ #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> arguments, ValueType returnValueType): +StatementMetaExternFunction::StatementMetaExternFunction(string name, vector>> arguments, shared_ptr returnValueType): Statement(StatementKind::META_EXTERN_FUNCTION), name(name), arguments(arguments), returnValueType(returnValueType) { } string StatementMetaExternFunction::getName() { return name; } -vector> StatementMetaExternFunction::getArguments() { +vector>> StatementMetaExternFunction::getArguments() { return arguments; } -ValueType StatementMetaExternFunction::getReturnValueType() { +shared_ptr StatementMetaExternFunction::getReturnValueType() { return returnValueType; } diff --git a/src/Parser/Statement/StatementMetaExternFunction.h b/src/Parser/Statement/StatementMetaExternFunction.h index b5f9310..304a716 100644 --- a/src/Parser/Statement/StatementMetaExternFunction.h +++ b/src/Parser/Statement/StatementMetaExternFunction.h @@ -1,14 +1,16 @@ #include "Parser/Statement/Statement.h" +class ValueType; + class StatementMetaExternFunction: public Statement { private: string name; - vector> arguments; - ValueType returnValueType; + vector>> arguments; + shared_ptr returnValueType; public: - StatementMetaExternFunction(string name, vector> arguments, ValueType returnValueType); + StatementMetaExternFunction(string name, vector>> arguments, shared_ptr returnValueType); string getName(); - vector> getArguments(); - ValueType getReturnValueType(); + vector>> getArguments(); + shared_ptr getReturnValueType(); }; \ No newline at end of file diff --git a/src/Parser/Statement/StatementVariable.cpp b/src/Parser/Statement/StatementVariable.cpp index c188af3..7599aae 100644 --- a/src/Parser/Statement/StatementVariable.cpp +++ b/src/Parser/Statement/StatementVariable.cpp @@ -2,27 +2,14 @@ #include "Parser/Expression/Expression.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): +StatementVariable::StatementVariable(string name, shared_ptr valueType, shared_ptr expression): Statement(StatementKind::VARIABLE), name(name), valueType(valueType), expression(expression) { } string StatementVariable::getName() { return name; } -ValueType StatementVariable::getValueType() { +shared_ptr StatementVariable::getValueType() { return valueType; } diff --git a/src/Parser/Statement/StatementVariable.h b/src/Parser/Statement/StatementVariable.h index 5e3b7c0..e34f5c5 100644 --- a/src/Parser/Statement/StatementVariable.h +++ b/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; shared_ptr expression; public: - StatementVariable(string name, ValueType valueType, shared_ptr expression); + StatementVariable(string name, shared_ptr valueType, shared_ptr expression); string getName(); - ValueType getValueType(); + shared_ptr getValueType(); shared_ptr getExpression(); }; \ No newline at end of file diff --git a/src/Parser/ValueType.cpp b/src/Parser/ValueType.cpp new file mode 100644 index 0000000..abd399f --- /dev/null +++ b/src/Parser/ValueType.cpp @@ -0,0 +1,42 @@ +#include "ValueType.h" + +#include "Lexer/Token.h" + +shared_ptr ValueType::NONE = make_shared(ValueTypeKind::NONE); +shared_ptr ValueType::BOOL = make_shared(ValueTypeKind::BOOL); +shared_ptr ValueType::SINT32 = make_shared(ValueTypeKind::SINT32); +shared_ptr ValueType::REAL32 = make_shared(ValueTypeKind::REAL32); + +ValueType::ValueType(ValueTypeKind kind): +kind(kind) { } + +shared_ptr ValueType::valueTypeForToken(shared_ptr token) { + switch (token->getKind()) { + case TokenKind::TYPE: { + string lexme = token->getLexme(); + if (lexme.compare("bool") == 0) + return make_shared(ValueTypeKind::BOOL); + else if (lexme.compare("sint32") == 0) + return make_shared(ValueTypeKind::SINT32); + else if (lexme.compare("real32") == 0) + return make_shared(ValueTypeKind::REAL32); + else + return nullptr; + } + case TokenKind::BOOL: + return make_shared(ValueTypeKind::BOOL); + case TokenKind::INTEGER_DEC: + case TokenKind::INTEGER_HEX: + case TokenKind::INTEGER_BIN: + case TokenKind::INTEGER_CHAR: + return make_shared(ValueTypeKind::SINT32); + case TokenKind::REAL: + return make_shared(ValueTypeKind::REAL32); + default: + return nullptr; + } +} + +ValueTypeKind ValueType::getKind() { + return kind; +} \ No newline at end of file diff --git a/src/Parser/ValueType.h b/src/Parser/ValueType.h new file mode 100644 index 0000000..2540cd8 --- /dev/null +++ b/src/Parser/ValueType.h @@ -0,0 +1,32 @@ +#ifndef VALUE_TYPE_H +#define VALUE_TYPE_H + +#include + +class Token; + +using namespace std; + +enum class ValueTypeKind { + NONE, + BOOL, + SINT32, + REAL32 +}; + +class ValueType { +private: + ValueTypeKind kind; + +public: + static shared_ptr NONE; + static shared_ptr BOOL; + static shared_ptr SINT32; + static shared_ptr REAL32; + static shared_ptr valueTypeForToken(shared_ptr token); + + ValueType(ValueTypeKind kind); + ValueTypeKind getKind(); +}; + +#endif \ No newline at end of file diff --git a/src/Types.h b/src/Types.h deleted file mode 100644 index 912756b..0000000 --- a/src/Types.h +++ /dev/null @@ -1,11 +0,0 @@ -#ifndef TYPES_H -#define TYPES_H - -enum class ValueType { - NONE, - BOOL, - SINT32, - REAL32 -}; - -#endif \ No newline at end of file