CarGDev/bits-runner-builder
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added ValueType class

Browse Source
This commit is contained in:
Rafał Grodziński
2025-07-04 18:10:24 +09:00
parent ffdaf14174
commit 2a5085cb21
28 changed files with 191 additions and 181 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
src/Compiler/ModuleBuilder.cpp
View File

@@ -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()) {
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<ExpressionCall> 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> 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;
}
}

4
src/Compiler/ModuleBuilder.h
View File

@@ -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:

4
src/Lexer/Lexer.cpp
View File

@@ -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;

3
src/Lexer/Token.cpp
View File

@@ -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;

2
src/Lexer/Token.h
View File

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

35
src/Logger.cpp
View File

@@ -3,6 +3,7 @@
#include <iostream>
#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> 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> statement) {
switch (statement->getKind()) {
case StatementKind::META_EXTERN_FUNCTION:
@@ -281,19 +293,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:
@@ -363,14 +362,12 @@ string Logger::toString(shared_ptr<ExpressionGrouping> expression) {
}
string Logger::toString(shared_ptr<ExpressionLiteral> 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());
}
}

7
src/Logger.h
View File

@@ -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);

7
src/Parser/Expression/Expression.cpp
View File

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

10
src/Parser/Expression/Expression.h
View File

@@ -3,8 +3,8 @@
#include <iostream>
#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> 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

7
src/Parser/Expression/ExpressionBinary.cpp
View File

@@ -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;
}

2
src/Parser/Expression/ExpressionBlock.cpp
View File

@@ -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();

2
src/Parser/Expression/ExpressionCall.cpp
View File

@@ -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;

2
src/Parser/Expression/ExpressionIfElse.cpp
View File

@@ -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();

19
src/Parser/Expression/ExpressionLiteral.cpp
View File

@@ -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);

3
src/Parser/Expression/ExpressionLiteral.h
View File

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

2
src/Parser/Expression/ExpressionVariable.cpp
View File

@@ -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;

61
src/Parser/Parser.cpp
View File

@@ -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;
ValueType returnType = ValueType::NONE;
vector<pair<string, shared_ptr<ValueType>>> arguments;
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++);
optional<ValueType> argumentType = valueTypeForToken(typeToken);
if (!argumentType) {
shared_ptr<Token> argumentTypeToken = tokens.at(currentIndex++);
shared_ptr<ValueType> argumentType = ValueType::valueTypeForToken(argumentTypeToken);
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);
optional<ValueType> type = valueTypeForToken(typeToken);
if (!type) {
shared_ptr<Token> returnTypeToken = tokens.at(currentIndex);
shared_ptr<ValueType> returnType = ValueType::valueTypeForToken(returnTypeToken);
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;
ValueType returnType = ValueType::NONE;
vector<pair<string, shared_ptr<ValueType>>> arguments;
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++);
optional<ValueType> argumentType = valueTypeForToken(typeToken);
if (!argumentType) {
shared_ptr<Token> argumentTypeToken = tokens.at(currentIndex++);
shared_ptr<ValueType> argumentType = ValueType::valueTypeForToken(argumentTypeToken);
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);
optional<ValueType> type = valueTypeForToken(typeToken);
if (!type) {
shared_ptr<Token> returnTypeToken = tokens.at(currentIndex);
shared_ptr<ValueType> returnType = ValueType::valueTypeForToken(returnTypeToken);
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);

2
src/Parser/Parser.h
View File

@@ -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);

2
src/Parser/Statement/Statement.h
View File

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

19
src/Parser/Statement/StatementFunction.cpp
View File

@@ -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<pair<string, ValueType>> arguments, ValueType returnValueType, shared_ptr<StatementBlock> statementBlock):
StatementFunction::StatementFunction(string name, vector<pair<string, shared_ptr<ValueType>>> arguments, shared_ptr<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;
}

11
src/Parser/Statement/StatementFunction.h
View File

@@ -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;
ValueType returnValueType;
vector<pair<string, shared_ptr<ValueType>>> arguments;
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();
ValueType getReturnValueType();
vector<pair<string, shared_ptr<ValueType>>> getArguments();
shared_ptr<ValueType> getReturnValueType();
shared_ptr<StatementBlock> getStatementBlock();
};

19
src/Parser/Statement/StatementMetaExternFunction.cpp
View File

@@ -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<pair<string, ValueType>> arguments, ValueType returnValueType):
StatementMetaExternFunction::StatementMetaExternFunction(string name, vector<pair<string, shared_ptr<ValueType>>> arguments, shared_ptr<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;
}

12
src/Parser/Statement/StatementMetaExternFunction.h
View File

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

17
src/Parser/Statement/StatementVariable.cpp
View File

@@ -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> expression):
StatementVariable::StatementVariable(string name, shared_ptr<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;
}

7
src/Parser/Statement/StatementVariable.h
View File

@@ -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();
};

42
src/Parser/ValueType.cpp Normal file
View File

@@ -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;
}

32
src/Parser/ValueType.h Normal file
View File

@@ -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

11
src/Types.h
View File

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