Deukhoofd
/
PorygonLang
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Added namespaces to most classes, general cleanup
continuous-integration/drone/push Build is failing Details

This commit is contained in:
Deukhoofd 2019-06-17 18:35:12 +02:00
parent 21d3329c55
commit fde102d954
No known key found for this signature in database
GPG Key ID: B4C087AC81641654
66 changed files with 4301 additions and 3909 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

588
src/Binder/Binder.cpp
View File

@ -6,125 +6,142 @@
#include "../UserData/UserDataScriptType.hpp" #include "../UserData/UserDataScriptType.hpp"
#include <memory> #include <memory>
BoundScriptStatement *Binder::Bind(Script* script, const ParsedScriptStatement *s, BoundScope* scriptScope) { using namespace Porygon::Parser;
namespace Porygon::Binder {
BoundScriptStatement *Binder::Bind(Script *script, const ParsedScriptStatement *s, BoundScope *scriptScope) {
auto binder = Binder(); auto binder = Binder();
binder._scriptData = script; binder._scriptData = script;
binder._scope = scriptScope; binder._scope = scriptScope;
auto statements = s->GetStatements(); auto statements = s->GetStatements();
vector<BoundStatement*> boundStatements (statements->size()); vector<BoundStatement *> boundStatements(statements->size());
for (int i = 0; i < statements->size(); i++){ for (int i = 0; i < statements->size(); i++) {
boundStatements[i] = binder.BindStatement(statements->at(i)); boundStatements[i] = binder.BindStatement(statements->at(i));
} }
return new BoundScriptStatement(boundStatements, scriptScope->GetLocalVariableCount()); return new BoundScriptStatement(boundStatements, scriptScope->GetLocalVariableCount());
}
Binder::~Binder() {
delete _scope;
}
BoundStatement* Binder::BindStatement(const ParsedStatement* statement){
switch (statement -> GetKind()) {
case ParsedStatementKind ::Script: throw; // This shouldn't happen.
case ParsedStatementKind ::Block: return this -> BindBlockStatement(statement);
case ParsedStatementKind ::Expression: return this -> BindExpressionStatement(statement);
case ParsedStatementKind::Assignment: return this -> BindAssignmentStatement(statement);
case ParsedStatementKind::IndexAssignment: return this -> BindIndexAssignmentStatement(statement);
case ParsedStatementKind ::FunctionDeclaration: return this->BindFunctionDeclarationStatement(statement);
case ParsedStatementKind::Return: return this -> BindReturnStatement(statement);
case ParsedStatementKind::Conditional: return this -> BindConditionalStatement(statement);
case ParsedStatementKind::Bad: return new BoundBadStatement();
} }
}
BoundStatement *Binder::BindBlockStatement(const ParsedStatement *statement) { Binder::~Binder() {
auto statements = ((ParsedBlockStatement*)statement)->GetStatements(); delete _scope;
vector<BoundStatement*> boundStatements (statements->size()); }
BoundStatement *Binder::BindStatement(const ParsedStatement *statement) {
switch (statement->GetKind()) {
case ParsedStatementKind::Script:
throw; // This shouldn't happen.
case ParsedStatementKind::Block:
return this->BindBlockStatement(statement);
case ParsedStatementKind::Expression:
return this->BindExpressionStatement(statement);
case ParsedStatementKind::Assignment:
return this->BindAssignmentStatement(statement);
case ParsedStatementKind::IndexAssignment:
return this->BindIndexAssignmentStatement(statement);
case ParsedStatementKind::FunctionDeclaration:
return this->BindFunctionDeclarationStatement(statement);
case ParsedStatementKind::Return:
return this->BindReturnStatement(statement);
case ParsedStatementKind::Conditional:
return this->BindConditionalStatement(statement);
case ParsedStatementKind::Bad:
return new BoundBadStatement();
}
}
BoundStatement *Binder::BindBlockStatement(const ParsedStatement *statement) {
auto statements = ((ParsedBlockStatement *) statement)->GetStatements();
vector<BoundStatement *> boundStatements(statements->size());
this->_scope->GoInnerScope(); this->_scope->GoInnerScope();
for (int i = 0; i < statements->size(); i++){ for (int i = 0; i < statements->size(); i++) {
boundStatements[i] = this -> BindStatement(statements->at(i)); boundStatements[i] = this->BindStatement(statements->at(i));
} }
this->_scope->GoOuterScope(); this->_scope->GoOuterScope();
return new BoundBlockStatement(boundStatements); return new BoundBlockStatement(boundStatements);
} }
BoundStatement *Binder::BindExpressionStatement(const ParsedStatement *statement) { BoundStatement *Binder::BindExpressionStatement(const ParsedStatement *statement) {
auto exp = ((ParsedExpressionStatement*)statement)->GetExpression(); auto exp = ((ParsedExpressionStatement *) statement)->GetExpression();
return new BoundExpressionStatement(this -> BindExpression(exp)); return new BoundExpressionStatement(this->BindExpression(exp));
} }
BoundStatement* Binder::BindAssignmentStatement(const ParsedStatement *statement){ BoundStatement *Binder::BindAssignmentStatement(const ParsedStatement *statement) {
auto s = (ParsedAssignmentStatement*) statement; auto s = (ParsedAssignmentStatement *) statement;
auto boundExpression = this->BindExpression(s->GetExpression()); auto boundExpression = this->BindExpression(s->GetExpression());
VariableAssignment assignment = VariableAssignment assignment =
s->IsLocal() ? s->IsLocal() ?
this->_scope->CreateExplicitLocal(s->GetIdentifier().GetHash(), boundExpression->GetType()) this->_scope->CreateExplicitLocal(s->GetIdentifier().GetHash(), boundExpression->GetType())
: this->_scope->AssignVariable(s->GetIdentifier().GetHash(), boundExpression->GetType()); : this->_scope->AssignVariable(s->GetIdentifier().GetHash(), boundExpression->GetType());
if (assignment.GetResult() == VariableAssignmentResult::Ok){ if (assignment.GetResult() == VariableAssignmentResult::Ok) {
auto key = assignment.GetKey(); auto key = assignment.GetKey();
return new BoundAssignmentStatement(key, boundExpression); return new BoundAssignmentStatement(key, boundExpression);
} } else {
else{ this->_scriptData->Diagnostics->LogError(DiagnosticCode::CantAssignVariable, statement->GetStartPosition(),
this -> _scriptData -> Diagnostics -> LogError(DiagnosticCode::CantAssignVariable, statement->GetStartPosition(), statement->GetLength()); statement->GetLength());
return new BoundBadStatement(); return new BoundBadStatement();
} }
}
BoundStatement *Binder::BindIndexAssignmentStatement(const ParsedStatement *statement) {
auto s = (ParsedIndexAssignmentStatement*) statement;
auto indexExp = s -> GetIndexExpression();
const BoundExpression* indexable;
if (indexExp->GetKind() == ParsedExpressionKind::Indexer){
indexable = this -> BindIndexExpression((IndexExpression*)indexExp, true);
} else{
indexable = this -> BindPeriodIndexExpression((PeriodIndexExpression*)indexExp, true);
} }
auto valueExpression = this -> BindExpression(s->GetValueExpression());
auto boundIndexType = indexable -> GetType(); BoundStatement *Binder::BindIndexAssignmentStatement(const ParsedStatement *statement) {
if (boundIndexType ->GetClass() != TypeClass ::Error && boundIndexType->operator!=(valueExpression->GetType().get())){ auto s = (ParsedIndexAssignmentStatement *) statement;
this -> _scriptData -> Diagnostics -> LogError(DiagnosticCode::InvalidTableValueType, statement->GetStartPosition(), statement->GetLength()); auto indexExp = s->GetIndexExpression();
const BoundExpression *indexable;
if (indexExp->GetKind() == ParsedExpressionKind::Indexer) {
indexable = this->BindIndexExpression((IndexExpression *) indexExp, true);
} else {
indexable = this->BindPeriodIndexExpression((PeriodIndexExpression *) indexExp, true);
}
auto valueExpression = this->BindExpression(s->GetValueExpression());
auto boundIndexType = indexable->GetType();
if (boundIndexType->GetClass() != TypeClass::Error &&
boundIndexType->operator!=(valueExpression->GetType().get())) {
this->_scriptData->Diagnostics->LogError(DiagnosticCode::InvalidTableValueType,
statement->GetStartPosition(), statement->GetLength());
return new BoundBadStatement(); return new BoundBadStatement();
} }
return new BoundIndexAssignmentStatement(indexable, valueExpression); return new BoundIndexAssignmentStatement(indexable, valueExpression);
} }
std::shared_ptr<ScriptType> ParseTypeIdentifier(HashedString s){ std::shared_ptr<ScriptType> ParseTypeIdentifier(HashedString s) {
auto hash = s.GetHash(); auto hash = s.GetHash();
switch (hash){ switch (hash) {
case HashedString::ConstHash("number"): return std::make_shared<NumericScriptType>(false, false); case HashedString::ConstHash("number"):
case HashedString::ConstHash("bool"): return std::make_shared<ScriptType>(TypeClass::Bool); return std::make_shared<NumericScriptType>(false, false);
case HashedString::ConstHash("string"): return std::make_shared<StringScriptType>(false, 0); case HashedString::ConstHash("bool"):
return std::make_shared<ScriptType>(TypeClass::Bool);
case HashedString::ConstHash("string"):
return std::make_shared<StringScriptType>(false, 0);
default: default:
if (!UserDataStorage::HasUserDataType(hash)){ if (!UserData::UserDataStorage::HasUserDataType(hash)) {
return nullptr; return nullptr;
} }
return std::make_shared<UserDataScriptType>(hash); return std::make_shared<UserData::UserDataScriptType>(hash);
}
} }
}
BoundStatement *Binder::BindFunctionDeclarationStatement(const ParsedStatement *statement) { BoundStatement *Binder::BindFunctionDeclarationStatement(const ParsedStatement *statement) {
auto functionStatement = (ParsedFunctionDeclarationStatement*) statement; auto functionStatement = (ParsedFunctionDeclarationStatement *) statement;
auto parameters = functionStatement->GetParameters(); auto parameters = functionStatement->GetParameters();
auto parameterTypes = vector<shared_ptr<ScriptType>>(parameters->size()); auto parameterTypes = vector<shared_ptr<ScriptType>>(parameters->size());
auto parameterKeys = vector<shared_ptr<BoundVariableKey>>(parameters->size()); auto parameterKeys = vector<shared_ptr<BoundVariableKey>>(parameters->size());
auto scopeIndex = this->_scope->GetCurrentScope(); auto scopeIndex = this->_scope->GetCurrentScope();
this->_scope->GoInnerScope(); this->_scope->GoInnerScope();
for (int i = 0; i < parameters->size(); i++){ for (int i = 0; i < parameters->size(); i++) {
auto var = parameters -> at(i); auto var = parameters->at(i);
auto parsedType = ParseTypeIdentifier(var->GetType()); auto parsedType = ParseTypeIdentifier(var->GetType());
if (parsedType == nullptr){ if (parsedType == nullptr) {
this -> _scriptData -> Diagnostics -> LogError(DiagnosticCode::InvalidTypeName, statement->GetStartPosition(), statement->GetLength()); this->_scriptData->Diagnostics->LogError(DiagnosticCode::InvalidTypeName, statement->GetStartPosition(),
statement->GetLength());
return new BoundBadStatement(); return new BoundBadStatement();
} }
parameterTypes.at(i) = parsedType; parameterTypes.at(i) = parsedType;
auto parameterAssignment = this->_scope->CreateExplicitLocal(var->GetIdentifier().GetHash(), parsedType); auto parameterAssignment = this->_scope->CreateExplicitLocal(var->GetIdentifier().GetHash(), parsedType);
if (parameterAssignment.GetResult() == VariableAssignmentResult::Ok){ if (parameterAssignment.GetResult() == VariableAssignmentResult::Ok) {
parameterKeys.at(i) = std::shared_ptr<BoundVariableKey>(parameterAssignment.GetKey()); parameterKeys.at(i) = std::shared_ptr<BoundVariableKey>(parameterAssignment.GetKey());
} } else {
else{
//TODO: log error //TODO: log error
continue; continue;
} }
@ -136,250 +153,280 @@ BoundStatement *Binder::BindFunctionDeclarationStatement(const ParsedStatement *
this->_currentFunction = type; this->_currentFunction = type;
auto assignment = this->_scope->AssignVariable(identifier.GetHash(), type); auto assignment = this->_scope->AssignVariable(identifier.GetHash(), type);
if (assignment.GetResult() != VariableAssignmentResult::Ok){ if (assignment.GetResult() != VariableAssignmentResult::Ok) {
this -> _scriptData -> Diagnostics -> LogError(DiagnosticCode::CantAssignVariable, statement->GetStartPosition(), statement->GetLength()); this->_scriptData->Diagnostics->LogError(DiagnosticCode::CantAssignVariable, statement->GetStartPosition(),
statement->GetLength());
return new BoundBadStatement(); return new BoundBadStatement();
} }
auto boundBlock = this -> BindBlockStatement(functionStatement->GetBlock()); auto boundBlock = this->BindBlockStatement(functionStatement->GetBlock());
this->_scope->GoOuterScope(); this->_scope->GoOuterScope();
this->_currentFunction = nullptr; this->_currentFunction = nullptr;
return new BoundFunctionDeclarationStatement(type, assignment.GetKey(), (BoundBlockStatement*)boundBlock); return new BoundFunctionDeclarationStatement(type, assignment.GetKey(), (BoundBlockStatement *) boundBlock);
} }
BoundStatement *Binder::BindReturnStatement(const ParsedStatement* statement){ BoundStatement *Binder::BindReturnStatement(const ParsedStatement *statement) {
auto expression = ((ParsedReturnStatement*)statement)->GetExpression(); auto expression = ((ParsedReturnStatement *) statement)->GetExpression();
shared_ptr<ScriptType> currentReturnType; shared_ptr<ScriptType> currentReturnType;
if (this->_currentFunction == nullptr){ if (this->_currentFunction == nullptr) {
currentReturnType = this->_scriptData->GetReturnType(); currentReturnType = this->_scriptData->GetReturnType();
} else{ } else {
currentReturnType = this->_currentFunction->GetReturnType(); currentReturnType = this->_currentFunction->GetReturnType();
} }
if (expression == nullptr && currentReturnType != nullptr){ if (expression == nullptr && currentReturnType != nullptr) {
this -> _scriptData -> Diagnostics -> LogError(DiagnosticCode::InvalidReturnType, statement->GetStartPosition(), statement->GetLength()); this->_scriptData->Diagnostics->LogError(DiagnosticCode::InvalidReturnType, statement->GetStartPosition(),
statement->GetLength());
return new BoundBadStatement(); return new BoundBadStatement();
} }
auto boundExpression = this->BindExpression(expression); auto boundExpression = this->BindExpression(expression);
auto expresionType = boundExpression->GetType(); auto expresionType = boundExpression->GetType();
if (currentReturnType == nullptr || currentReturnType->GetClass() == TypeClass::Nil){ if (currentReturnType == nullptr || currentReturnType->GetClass() == TypeClass::Nil) {
if (this->_currentFunction == nullptr){ if (this->_currentFunction == nullptr) {
this->_scriptData->SetReturnType(expresionType); this->_scriptData->SetReturnType(expresionType);
} else{ } else {
this->_currentFunction->SetReturnType(expresionType); this->_currentFunction->SetReturnType(expresionType);
} }
return new BoundReturnStatement(boundExpression); return new BoundReturnStatement(boundExpression);
} }
if (currentReturnType.get()->operator!=(expresionType.get())){ if (currentReturnType.get()->operator!=(expresionType.get())) {
this -> _scriptData -> Diagnostics -> LogError(DiagnosticCode::InvalidReturnType, statement->GetStartPosition(), statement->GetLength()); this->_scriptData->Diagnostics->LogError(DiagnosticCode::InvalidReturnType, statement->GetStartPosition(),
statement->GetLength());
return new BoundBadStatement(); return new BoundBadStatement();
} }
return new BoundReturnStatement(boundExpression); return new BoundReturnStatement(boundExpression);
} }
BoundStatement *Binder::BindConditionalStatement(const ParsedStatement* statement) { BoundStatement *Binder::BindConditionalStatement(const ParsedStatement *statement) {
auto conditionalStatement = (ParsedConditionalStatement*)statement; auto conditionalStatement = (ParsedConditionalStatement *) statement;
auto boundCondition = this -> BindExpression(conditionalStatement -> GetCondition()); auto boundCondition = this->BindExpression(conditionalStatement->GetCondition());
if (boundCondition->GetType() -> GetClass() != TypeClass::Bool){ if (boundCondition->GetType()->GetClass() != TypeClass::Bool) {
this -> _scriptData -> Diagnostics -> LogError(DiagnosticCode::ConditionNotABool, statement->GetStartPosition(), statement->GetLength()); this->_scriptData->Diagnostics->LogError(DiagnosticCode::ConditionNotABool, statement->GetStartPosition(),
statement->GetLength());
return new BoundBadStatement(); return new BoundBadStatement();
} }
auto boundBlock = this -> BindStatement(conditionalStatement->GetBlock()); auto boundBlock = this->BindStatement(conditionalStatement->GetBlock());
BoundStatement* elseStatement = nullptr; BoundStatement *elseStatement = nullptr;
if (conditionalStatement->GetElseStatement() != nullptr){ if (conditionalStatement->GetElseStatement() != nullptr) {
elseStatement = this -> BindStatement(conditionalStatement->GetElseStatement()); elseStatement = this->BindStatement(conditionalStatement->GetElseStatement());
} }
return new BoundConditionalStatement(boundCondition, boundBlock, elseStatement); return new BoundConditionalStatement(boundCondition, boundBlock, elseStatement);
}
BoundExpression* Binder::BindExpression(const ParsedExpression* expression){
switch (expression -> GetKind()){
case ParsedExpressionKind ::LiteralInteger:
return new BoundLiteralIntegerExpression(((LiteralIntegerExpression*)expression)->GetValue(), expression->GetStartPosition(), expression->GetLength());
case ParsedExpressionKind ::LiteralFloat:
return new BoundLiteralFloatExpression(((LiteralFloatExpression*)expression)->GetValue(), expression->GetStartPosition(), expression->GetLength());
case ParsedExpressionKind ::LiteralString:
return new BoundLiteralStringExpression(((LiteralStringExpression*)expression)->GetValue(), expression->GetStartPosition(), expression->GetLength());
case ParsedExpressionKind ::LiteralBool:
return new BoundLiteralBoolExpression(((LiteralBoolExpression*)expression)->GetValue(), expression->GetStartPosition(), expression->GetLength());
case ParsedExpressionKind ::Variable:
return this -> BindVariableExpression((VariableExpression*)expression);
case ParsedExpressionKind ::Binary:
return this -> BindBinaryOperator((BinaryExpression*)expression);
case ParsedExpressionKind ::Unary:
return this -> BindUnaryOperator((UnaryExpression*)expression);
case ParsedExpressionKind ::Parenthesized:
return BindExpression(((ParenthesizedExpression*)expression)->GetInnerExpression());
case ParsedExpressionKind ::FunctionCall:
return this->BindFunctionCall((FunctionCallExpression*)expression);
case ParsedExpressionKind ::Indexer:
return this->BindIndexExpression((IndexExpression*)expression, false);
case ParsedExpressionKind::PeriodIndexer:
return this -> BindPeriodIndexExpression((PeriodIndexExpression*)expression, false);
case ParsedExpressionKind::NumericalTable:
return this -> BindNumericalTableExpression((ParsedNumericalTableExpression*)expression);
case ParsedExpressionKind ::Table:
return this -> BindTableExpression((ParsedTableExpression*)expression);
case ParsedExpressionKind ::Bad:
return new BoundBadExpression(expression->GetStartPosition(), expression-> GetLength());
} }
}
BoundExpression* Binder::BindVariableExpression(const VariableExpression* expression){ BoundExpression *Binder::BindExpression(const ParsedExpression *expression) {
switch (expression->GetKind()) {
case ParsedExpressionKind::LiteralInteger:
return new BoundLiteralIntegerExpression(((LiteralIntegerExpression *) expression)->GetValue(),
expression->GetStartPosition(), expression->GetLength());
case ParsedExpressionKind::LiteralFloat:
return new BoundLiteralFloatExpression(((LiteralFloatExpression *) expression)->GetValue(),
expression->GetStartPosition(), expression->GetLength());
case ParsedExpressionKind::LiteralString:
return new BoundLiteralStringExpression(((LiteralStringExpression *) expression)->GetValue(),
expression->GetStartPosition(), expression->GetLength());
case ParsedExpressionKind::LiteralBool:
return new BoundLiteralBoolExpression(((LiteralBoolExpression *) expression)->GetValue(),
expression->GetStartPosition(), expression->GetLength());
case ParsedExpressionKind::Variable:
return this->BindVariableExpression((VariableExpression *) expression);
case ParsedExpressionKind::Binary:
return this->BindBinaryOperator((BinaryExpression *) expression);
case ParsedExpressionKind::Unary:
return this->BindUnaryOperator((UnaryExpression *) expression);
case ParsedExpressionKind::Parenthesized:
return BindExpression(((ParenthesizedExpression *) expression)->GetInnerExpression());
case ParsedExpressionKind::FunctionCall:
return this->BindFunctionCall((FunctionCallExpression *) expression);
case ParsedExpressionKind::Indexer:
return this->BindIndexExpression((IndexExpression *) expression, false);
case ParsedExpressionKind::PeriodIndexer:
return this->BindPeriodIndexExpression((PeriodIndexExpression *) expression, false);
case ParsedExpressionKind::NumericalTable:
return this->BindNumericalTableExpression((ParsedNumericalTableExpression *) expression);
case ParsedExpressionKind::Table:
return this->BindTableExpression((ParsedTableExpression *) expression);
case ParsedExpressionKind::Bad:
return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
}
}
BoundExpression *Binder::BindVariableExpression(const VariableExpression *expression) {
auto key = expression->GetValue(); auto key = expression->GetValue();
auto scope = this->_scope->Exists(key.GetHash()); auto scope = this->_scope->Exists(key.GetHash());
if (scope == -1){ if (scope == -1) {
this -> _scriptData -> Diagnostics->LogError(DiagnosticCode::VariableNotFound, expression->GetStartPosition(), expression->GetLength()); this->_scriptData->Diagnostics->LogError(DiagnosticCode::VariableNotFound, expression->GetStartPosition(),
expression->GetLength());
return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength()); return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
} }
auto var = this->_scope->GetVariable(scope, key.GetHash()); auto var = this->_scope->GetVariable(scope, key.GetHash());
auto type = var->GetType(); auto type = var->GetType();
return new BoundVariableExpression(new BoundVariableKey(key.GetHash(), scope, false), type, expression->GetStartPosition(), expression->GetLength()); return new BoundVariableExpression(new BoundVariableKey(key.GetHash(), scope, false), type,
} expression->GetStartPosition(), expression->GetLength());
}
BoundExpression* Binder::BindBinaryOperator(const BinaryExpression* expression){ BoundExpression *Binder::BindBinaryOperator(const BinaryExpression *expression) {
auto boundLeft = this -> BindExpression(expression->GetLeft()); auto boundLeft = this->BindExpression(expression->GetLeft());
auto boundRight = this -> BindExpression(expression->GetRight()); auto boundRight = this->BindExpression(expression->GetRight());
auto boundLeftType = boundLeft->GetType(); auto boundLeftType = boundLeft->GetType();
auto boundRightType = boundRight->GetType(); auto boundRightType = boundRight->GetType();
switch (expression->GetOperatorKind()){ switch (expression->GetOperatorKind()) {
case BinaryOperatorKind ::Addition: case BinaryOperatorKind::Addition:
if (boundLeftType->GetClass() == TypeClass::Number && boundRightType->GetClass() == TypeClass::Number){ if (boundLeftType->GetClass() == TypeClass::Number && boundRightType->GetClass() == TypeClass::Number) {
auto leftNumeric = std::dynamic_pointer_cast<NumericScriptType>(boundLeftType); auto leftNumeric = std::dynamic_pointer_cast<NumericScriptType>(boundLeftType);
auto rightNumeric = std::dynamic_pointer_cast<NumericScriptType>(boundRightType); auto rightNumeric = std::dynamic_pointer_cast<NumericScriptType>(boundRightType);
if (leftNumeric->IsAwareOfFloat() && rightNumeric->IsAwareOfFloat()){ if (leftNumeric->IsAwareOfFloat() && rightNumeric->IsAwareOfFloat()) {
return new BoundBinaryExpression(boundLeft, boundRight, return new BoundBinaryExpression(boundLeft, boundRight,
BoundBinaryOperation::Addition, BoundBinaryOperation::Addition,
std::make_shared<NumericScriptType>(true, leftNumeric->IsFloat() || rightNumeric->IsFloat()), std::make_shared<NumericScriptType>(true,
leftNumeric->IsFloat() ||
rightNumeric->IsFloat()),
expression->GetStartPosition(), expression->GetLength()); expression->GetStartPosition(), expression->GetLength());
} } else {
else{
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Addition, return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Addition,
std::make_shared<NumericScriptType>(false, false), std::make_shared<NumericScriptType>(false, false),
expression->GetStartPosition(), expression->GetLength()); expression->GetStartPosition(), expression->GetLength());
} }
} else if (boundLeftType->GetClass() == TypeClass::String){ } else if (boundLeftType->GetClass() == TypeClass::String) {
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Concatenation, std::make_shared<StringScriptType>(false, return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Concatenation,
std::make_shared<StringScriptType>(false,
0), 0),
expression->GetStartPosition(), expression->GetLength()); expression->GetStartPosition(), expression->GetLength());
} }
break; break;
case BinaryOperatorKind ::Subtraction: case BinaryOperatorKind::Subtraction:
if (boundLeftType->GetClass() == TypeClass::Number && boundRightType->GetClass() == TypeClass::Number){ if (boundLeftType->GetClass() == TypeClass::Number && boundRightType->GetClass() == TypeClass::Number) {
auto leftNumeric = std::dynamic_pointer_cast<NumericScriptType>(boundLeftType); auto leftNumeric = std::dynamic_pointer_cast<NumericScriptType>(boundLeftType);
auto rightNumeric = std::dynamic_pointer_cast<NumericScriptType>(boundRightType); auto rightNumeric = std::dynamic_pointer_cast<NumericScriptType>(boundRightType);
if (leftNumeric->IsAwareOfFloat() && rightNumeric->IsAwareOfFloat()){ if (leftNumeric->IsAwareOfFloat() && rightNumeric->IsAwareOfFloat()) {
return new BoundBinaryExpression(boundLeft, boundRight, return new BoundBinaryExpression(boundLeft, boundRight,
BoundBinaryOperation::Subtraction, BoundBinaryOperation::Subtraction,
std::make_shared<NumericScriptType>(true, leftNumeric->IsFloat() || rightNumeric->IsFloat()), std::make_shared<NumericScriptType>(true,
leftNumeric->IsFloat() ||
rightNumeric->IsFloat()),
expression->GetStartPosition(), expression->GetLength()); expression->GetStartPosition(), expression->GetLength());
} } else {
else{
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Subtraction, return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Subtraction,
std::make_shared<NumericScriptType>(false, false), std::make_shared<NumericScriptType>(false, false),
expression->GetStartPosition(), expression->GetLength()); expression->GetStartPosition(), expression->GetLength());
} }
} }
break; break;
case BinaryOperatorKind ::Multiplication: case BinaryOperatorKind::Multiplication:
if (boundLeftType->GetClass() == TypeClass::Number && boundRightType->GetClass() == TypeClass::Number){ if (boundLeftType->GetClass() == TypeClass::Number && boundRightType->GetClass() == TypeClass::Number) {
auto leftNumeric = std::dynamic_pointer_cast<NumericScriptType>(boundLeftType); auto leftNumeric = std::dynamic_pointer_cast<NumericScriptType>(boundLeftType);
auto rightNumeric = std::dynamic_pointer_cast<NumericScriptType>(boundRightType); auto rightNumeric = std::dynamic_pointer_cast<NumericScriptType>(boundRightType);
if (leftNumeric->IsAwareOfFloat() && rightNumeric->IsAwareOfFloat()){ if (leftNumeric->IsAwareOfFloat() && rightNumeric->IsAwareOfFloat()) {
return new BoundBinaryExpression(boundLeft, boundRight, return new BoundBinaryExpression(boundLeft, boundRight,
BoundBinaryOperation::Multiplication, BoundBinaryOperation::Multiplication,
std::make_shared<NumericScriptType>(true, leftNumeric->IsFloat() || rightNumeric->IsFloat()), std::make_shared<NumericScriptType>(true,
leftNumeric->IsFloat() ||
rightNumeric->IsFloat()),
expression->GetStartPosition(), expression->GetLength()); expression->GetStartPosition(), expression->GetLength());
} } else {
else{
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Multiplication, return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Multiplication,
std::make_shared<NumericScriptType>(false, false), std::make_shared<NumericScriptType>(false, false),
expression->GetStartPosition(), expression->GetLength()); expression->GetStartPosition(), expression->GetLength());
} }
} }
break; break;
case BinaryOperatorKind ::Division: case BinaryOperatorKind::Division:
if (boundLeftType->GetClass() == TypeClass::Number && boundRightType->GetClass() == TypeClass::Number){ if (boundLeftType->GetClass() == TypeClass::Number && boundRightType->GetClass() == TypeClass::Number) {
auto leftNumeric = std::dynamic_pointer_cast<NumericScriptType>(boundLeftType); auto leftNumeric = std::dynamic_pointer_cast<NumericScriptType>(boundLeftType);
auto rightNumeric = std::dynamic_pointer_cast<NumericScriptType>(boundRightType); auto rightNumeric = std::dynamic_pointer_cast<NumericScriptType>(boundRightType);
if (leftNumeric->IsAwareOfFloat() && rightNumeric->IsAwareOfFloat()){ if (leftNumeric->IsAwareOfFloat() && rightNumeric->IsAwareOfFloat()) {
return new BoundBinaryExpression(boundLeft, boundRight, return new BoundBinaryExpression(boundLeft, boundRight,
BoundBinaryOperation::Division, BoundBinaryOperation::Division,
std::make_shared<NumericScriptType>(true, leftNumeric->IsFloat() || rightNumeric->IsFloat()), std::make_shared<NumericScriptType>(true,
leftNumeric->IsFloat() ||
rightNumeric->IsFloat()),
expression->GetStartPosition(), expression->GetLength()); expression->GetStartPosition(), expression->GetLength());
} } else {
else{
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Division, return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Division,
std::make_shared<NumericScriptType>(false, false), std::make_shared<NumericScriptType>(false, false),
expression->GetStartPosition(), expression->GetLength()); expression->GetStartPosition(), expression->GetLength());
} }
} }
break; break;
case BinaryOperatorKind ::Equality: case BinaryOperatorKind::Equality:
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Equality, std::make_shared<ScriptType>(TypeClass::Bool), return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Equality,
std::make_shared<ScriptType>(TypeClass::Bool),
expression->GetStartPosition(), expression->GetLength()); expression->GetStartPosition(), expression->GetLength());
case BinaryOperatorKind ::Inequality: case BinaryOperatorKind::Inequality:
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Inequality, std::make_shared<ScriptType>(TypeClass::Bool), return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Inequality,
std::make_shared<ScriptType>(TypeClass::Bool),
expression->GetStartPosition(), expression->GetLength()); expression->GetStartPosition(), expression->GetLength());
case BinaryOperatorKind ::Less: case BinaryOperatorKind::Less:
if (boundLeft->GetType()->GetClass() == TypeClass::Number && boundRight->GetType()->GetClass() == TypeClass::Number){ if (boundLeft->GetType()->GetClass() == TypeClass::Number &&
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::LessThan, std::make_shared<ScriptType>(TypeClass::Bool), boundRight->GetType()->GetClass() == TypeClass::Number) {
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::LessThan,
std::make_shared<ScriptType>(TypeClass::Bool),
expression->GetStartPosition(), expression->GetLength()); expression->GetStartPosition(), expression->GetLength());
} }
case BinaryOperatorKind ::LessOrEquals: case BinaryOperatorKind::LessOrEquals:
if (boundLeft->GetType()->GetClass() == TypeClass::Number && boundRight->GetType()->GetClass() == TypeClass::Number){ if (boundLeft->GetType()->GetClass() == TypeClass::Number &&
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::LessThanEquals, std::make_shared<ScriptType>(TypeClass::Bool), boundRight->GetType()->GetClass() == TypeClass::Number) {
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::LessThanEquals,
std::make_shared<ScriptType>(TypeClass::Bool),
expression->GetStartPosition(), expression->GetLength()); expression->GetStartPosition(), expression->GetLength());
} }
case BinaryOperatorKind ::Greater: case BinaryOperatorKind::Greater:
if (boundLeft->GetType()->GetClass() == TypeClass::Number && boundRight->GetType()->GetClass() == TypeClass::Number){ if (boundLeft->GetType()->GetClass() == TypeClass::Number &&
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::GreaterThan, std::make_shared<ScriptType>(TypeClass::Bool), boundRight->GetType()->GetClass() == TypeClass::Number) {
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::GreaterThan,
std::make_shared<ScriptType>(TypeClass::Bool),
expression->GetStartPosition(), expression->GetLength()); expression->GetStartPosition(), expression->GetLength());
} }
case BinaryOperatorKind ::GreaterOrEquals: case BinaryOperatorKind::GreaterOrEquals:
if (boundLeft->GetType()->GetClass() == TypeClass::Number && boundRight->GetType()->GetClass() == TypeClass::Number){ if (boundLeft->GetType()->GetClass() == TypeClass::Number &&
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::GreaterThanEquals, std::make_shared<ScriptType>(TypeClass::Bool), boundRight->GetType()->GetClass() == TypeClass::Number) {
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::GreaterThanEquals,
std::make_shared<ScriptType>(TypeClass::Bool),
expression->GetStartPosition(), expression->GetLength()); expression->GetStartPosition(), expression->GetLength());
} }
case BinaryOperatorKind ::LogicalAnd: case BinaryOperatorKind::LogicalAnd:
if (boundLeftType->GetClass() == TypeClass::Bool && boundRightType->GetClass() == TypeClass::Bool) if (boundLeftType->GetClass() == TypeClass::Bool && boundRightType->GetClass() == TypeClass::Bool)
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::LogicalAnd, std::make_shared<ScriptType>(TypeClass::Bool), return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::LogicalAnd,
std::make_shared<ScriptType>(TypeClass::Bool),
expression->GetStartPosition(), expression->GetLength()); expression->GetStartPosition(), expression->GetLength());
break; break;
case BinaryOperatorKind ::LogicalOr: case BinaryOperatorKind::LogicalOr:
if (boundLeftType->GetClass() == TypeClass::Bool && boundRightType->GetClass() == TypeClass::Bool) if (boundLeftType->GetClass() == TypeClass::Bool && boundRightType->GetClass() == TypeClass::Bool)
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::LogicalOr, std::make_shared<ScriptType>(TypeClass::Bool), return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::LogicalOr,
std::make_shared<ScriptType>(TypeClass::Bool),
expression->GetStartPosition(), expression->GetLength()); expression->GetStartPosition(), expression->GetLength());
break; break;
} }
this -> _scriptData -> Diagnostics->LogError(DiagnosticCode::NoBinaryOperationFound, expression->GetStartPosition(), expression->GetLength()); this->_scriptData->Diagnostics->LogError(DiagnosticCode::NoBinaryOperationFound, expression->GetStartPosition(),
expression->GetLength());
return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength()); return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
} }
BoundExpression* Binder::BindUnaryOperator(const UnaryExpression* expression){ BoundExpression *Binder::BindUnaryOperator(const UnaryExpression *expression) {
auto operand = this -> BindExpression(expression->GetOperand()); auto operand = this->BindExpression(expression->GetOperand());
auto operandType = operand -> GetType(); auto operandType = operand->GetType();
switch (expression->GetOperatorKind()){ switch (expression->GetOperatorKind()) {
case UnaryOperatorKind ::Identity: case UnaryOperatorKind::Identity:
if (operandType->GetClass() == TypeClass::Number){ if (operandType->GetClass() == TypeClass::Number) {
// Identity won't change anything during evaluation, so just return the inner operand. // Identity won't change anything during evaluation, so just return the inner operand.
return operand; return operand;
} }
break; break;
case UnaryOperatorKind ::Negation: case UnaryOperatorKind::Negation:
if (operandType->GetClass() == TypeClass::Number){ if (operandType->GetClass() == TypeClass::Number) {
auto innerType = std::dynamic_pointer_cast<NumericScriptType>(operandType); auto innerType = std::dynamic_pointer_cast<NumericScriptType>(operandType);
return new BoundUnaryExpression(operand, BoundUnaryOperation::Negation, return new BoundUnaryExpression(operand, BoundUnaryOperation::Negation,
std::make_shared<NumericScriptType>(innerType.get()->IsAwareOfFloat(), innerType.get()->IsFloat()), std::make_shared<NumericScriptType>(
innerType.get()->IsAwareOfFloat(),
innerType.get()->IsFloat()),
expression->GetStartPosition(), expression->GetLength()); expression->GetStartPosition(), expression->GetLength());
} }
break; break;
case UnaryOperatorKind ::LogicalNegation: case UnaryOperatorKind::LogicalNegation:
if (operandType->GetClass() == TypeClass::Bool){ if (operandType->GetClass() == TypeClass::Bool) {
return new BoundUnaryExpression(operand, BoundUnaryOperation::LogicalNegation, return new BoundUnaryExpression(operand, BoundUnaryOperation::LogicalNegation,
std::make_shared<ScriptType>(TypeClass::Bool), std::make_shared<ScriptType>(TypeClass::Bool),
expression->GetStartPosition(), expression->GetLength()); expression->GetStartPosition(), expression->GetLength());
@ -388,33 +435,37 @@ BoundExpression* Binder::BindUnaryOperator(const UnaryExpression* expression){
default: default:
break; break;
} }
this -> _scriptData -> Diagnostics->LogError(DiagnosticCode::NoUnaryOperationFound, expression->GetStartPosition(), expression->GetLength()); this->_scriptData->Diagnostics->LogError(DiagnosticCode::NoUnaryOperationFound, expression->GetStartPosition(),
expression->GetLength());
return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength()); return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
} }
BoundExpression* Binder::BindFunctionCall(const FunctionCallExpression* expression){ BoundExpression *Binder::BindFunctionCall(const FunctionCallExpression *expression) {
auto functionExpression = BindExpression(expression->GetFunction()); auto functionExpression = BindExpression(expression->GetFunction());
auto type = functionExpression->GetType(); auto type = functionExpression->GetType();
if (type->GetClass() != TypeClass::Function){ if (type->GetClass() != TypeClass::Function) {
this->_scriptData->Diagnostics->LogError(DiagnosticCode::ExpressionIsNotAFunction, expression->GetStartPosition(), this->_scriptData->Diagnostics->LogError(DiagnosticCode::ExpressionIsNotAFunction,
expression->GetStartPosition(),
expression->GetLength()); expression->GetLength());
return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength()); return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
} }
auto functionType = std::dynamic_pointer_cast<FunctionScriptType>(type); auto functionType = std::dynamic_pointer_cast<FunctionScriptType>(type);
auto parameterTypes = functionType->GetParameterTypes(); auto parameterTypes = functionType->GetParameterTypes();
auto givenParameters = expression->GetParameters(); auto givenParameters = expression->GetParameters();
if (parameterTypes.size() != givenParameters->size()){ if (parameterTypes.size() != givenParameters->size()) {
this->_scriptData->Diagnostics->LogError(DiagnosticCode::ParameterCountMismatch, expression->GetStartPosition(), this->_scriptData->Diagnostics->LogError(DiagnosticCode::ParameterCountMismatch,
expression->GetStartPosition(),
expression->GetLength()); expression->GetLength());
return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength()); return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
} }
vector<BoundExpression*> boundParameters = vector<BoundExpression*>(givenParameters->size()); vector<BoundExpression *> boundParameters = vector<BoundExpression *>(givenParameters->size());
for (int i = 0; i < givenParameters->size(); i++){ for (int i = 0; i < givenParameters->size(); i++) {
auto parameter = givenParameters -> at(i); auto parameter = givenParameters->at(i);
auto boundParameter = this -> BindExpression(parameter); auto boundParameter = this->BindExpression(parameter);
if (boundParameter->GetType().get()->operator!=(parameterTypes.at(i).get())){ if (boundParameter->GetType().get()->operator!=(parameterTypes.at(i).get())) {
this->_scriptData->Diagnostics->LogError(DiagnosticCode::ParameterTypeMismatch, parameter->GetStartPosition(), this->_scriptData->Diagnostics->LogError(DiagnosticCode::ParameterTypeMismatch,
parameter->GetStartPosition(),
parameter->GetLength()); parameter->GetLength());
return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength()); return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
} }
@ -423,30 +474,32 @@ BoundExpression* Binder::BindFunctionCall(const FunctionCallExpression* expressi
return new BoundFunctionCallExpression(functionExpression, boundParameters, functionType.get()->GetReturnType(), return new BoundFunctionCallExpression(functionExpression, boundParameters, functionType.get()->GetReturnType(),
expression->GetStartPosition(), expression->GetLength()); expression->GetStartPosition(), expression->GetLength());
} }
BoundExpression *Binder::BindIndexExpression(const IndexExpression *expression, bool setter) { BoundExpression *Binder::BindIndexExpression(const IndexExpression *expression, bool setter) {
auto indexer = this->BindExpression(expression->GetIndexer()); auto indexer = this->BindExpression(expression->GetIndexer());
auto index = this->BindExpression(expression->GetIndex()); auto index = this->BindExpression(expression->GetIndex());
auto indexerType = indexer -> GetType(); auto indexerType = indexer->GetType();
if (!indexerType->CanBeIndexedWith(index->GetType().get())){ if (!indexerType->CanBeIndexedWith(index->GetType().get())) {
this->_scriptData->Diagnostics->LogError(DiagnosticCode::CantIndex, index->GetStartPosition(), this->_scriptData->Diagnostics->LogError(DiagnosticCode::CantIndex, index->GetStartPosition(),
index->GetLength()); index->GetLength());
return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength()); return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
} }
if (indexerType -> GetClass() == TypeClass::UserData){ if (indexerType->GetClass() == TypeClass::UserData) {
auto stringKey = dynamic_pointer_cast<StringScriptType>(index -> GetType()); auto stringKey = dynamic_pointer_cast<StringScriptType>(index->GetType());
auto field = dynamic_pointer_cast<UserDataScriptType>(indexerType) -> GetField(stringKey->GetHashValue()); auto field = dynamic_pointer_cast<UserData::UserDataScriptType>(indexerType)->GetField(stringKey->GetHashValue());
if (!setter){ if (!setter) {
if (!field->HasGetter()){ if (!field->HasGetter()) {
this->_scriptData->Diagnostics->LogError(DiagnosticCode::UserDataFieldNoGetter, index->GetStartPosition(), this->_scriptData->Diagnostics->LogError(DiagnosticCode::UserDataFieldNoGetter,
index->GetStartPosition(),
index->GetLength()); index->GetLength());
return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength()); return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
} }
} else{ } else {
if (!field->HasSetter()){ if (!field->HasSetter()) {
this->_scriptData->Diagnostics->LogError(DiagnosticCode::UserDataFieldNoSetter, index->GetStartPosition(), this->_scriptData->Diagnostics->LogError(DiagnosticCode::UserDataFieldNoSetter,
index->GetStartPosition(),
index->GetLength()); index->GetLength());
return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength()); return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
} }
@ -454,73 +507,80 @@ BoundExpression *Binder::BindIndexExpression(const IndexExpression *expression,
} }
auto resultType = indexer->GetType()->GetIndexedType(index->GetType().get()); auto resultType = indexer->GetType()->GetIndexedType(index->GetType().get());
return new BoundIndexExpression(indexer, index, resultType, expression->GetStartPosition(), expression->GetLength()); return new BoundIndexExpression(indexer, index, resultType, expression->GetStartPosition(),
} expression->GetLength());
}
BoundExpression* Binder::BindPeriodIndexExpression(const PeriodIndexExpression* expression, bool setter){ BoundExpression *Binder::BindPeriodIndexExpression(const PeriodIndexExpression *expression, bool setter) {
auto indexer = this->BindExpression(expression->GetIndexer()); auto indexer = this->BindExpression(expression->GetIndexer());
const auto& identifier = expression->GetIndex(); const auto &identifier = expression->GetIndex();
const auto& indexerType = indexer -> GetType(); const auto &indexerType = indexer->GetType();
if (!indexerType -> CanBeIndexedWithIdentifier(identifier.GetHash())){ if (!indexerType->CanBeIndexedWithIdentifier(identifier.GetHash())) {
this->_scriptData->Diagnostics->LogError(DiagnosticCode::CantIndex, expression->GetStartPosition(), this->_scriptData->Diagnostics->LogError(DiagnosticCode::CantIndex, expression->GetStartPosition(),
expression->GetLength()); expression->GetLength());
return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength()); return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
} }
if (indexerType -> GetClass() == TypeClass::UserData){ if (indexerType->GetClass() == TypeClass::UserData) {
auto field = dynamic_pointer_cast<UserDataScriptType>(indexerType) -> GetField(identifier . GetHash()); auto field = dynamic_pointer_cast<UserData::UserDataScriptType>(indexerType)->GetField(identifier.GetHash());
if (!setter){ if (!setter) {
if (!field->HasGetter()){ if (!field->HasGetter()) {
this->_scriptData->Diagnostics->LogError(DiagnosticCode::UserDataFieldNoGetter, expression->GetStartPosition(), this->_scriptData->Diagnostics->LogError(DiagnosticCode::UserDataFieldNoGetter,
expression->GetStartPosition(),
expression->GetLength()); expression->GetLength());
return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength()); return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
} }
} else{ } else {
if (!field->HasSetter()){ if (!field->HasSetter()) {
this->_scriptData->Diagnostics->LogError(DiagnosticCode::UserDataFieldNoSetter, expression->GetStartPosition(), this->_scriptData->Diagnostics->LogError(DiagnosticCode::UserDataFieldNoSetter,
expression->GetStartPosition(),
expression->GetLength()); expression->GetLength());
return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength()); return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
} }
} }
} }
auto resultType = indexer->GetType()->GetIndexedType(identifier . GetHash()); auto resultType = indexer->GetType()->GetIndexedType(identifier.GetHash());
return new BoundPeriodIndexExpression(indexer, identifier, resultType, expression->GetStartPosition(), expression->GetLength()); return new BoundPeriodIndexExpression(indexer, identifier, resultType, expression->GetStartPosition(),
expression->GetLength());
} }
BoundExpression* Binder::BindNumericalTableExpression(const ParsedNumericalTableExpression* expression){ BoundExpression *Binder::BindNumericalTableExpression(const ParsedNumericalTableExpression *expression) {
auto expressions = expression->GetExpressions(); auto expressions = expression->GetExpressions();
auto boundExpressions = vector<const BoundExpression*>(expressions-> size()); auto boundExpressions = vector<const BoundExpression *>(expressions->size());
shared_ptr<ScriptType> valueType = nullptr; shared_ptr<ScriptType> valueType = nullptr;
if (!boundExpressions.empty()){ if (!boundExpressions.empty()) {
boundExpressions[0] = this -> BindExpression(expressions -> at(0)); boundExpressions[0] = this->BindExpression(expressions->at(0));
valueType = boundExpressions[0] -> GetType(); valueType = boundExpressions[0]->GetType();
for (int i = 1; i < expressions->size(); i++){ for (int i = 1; i < expressions->size(); i++) {
boundExpressions[i] = this -> BindExpression(expressions -> at(i)); boundExpressions[i] = this->BindExpression(expressions->at(i));
if (boundExpressions[i] -> GetType().get()->operator!=(valueType.get())){ if (boundExpressions[i]->GetType().get()->operator!=(valueType.get())) {
this->_scriptData->Diagnostics->LogError(DiagnosticCode::InvalidTableValueType, boundExpressions[i]->GetStartPosition(), this->_scriptData->Diagnostics->LogError(DiagnosticCode::InvalidTableValueType,
boundExpressions[i]->GetStartPosition(),
boundExpressions[i]->GetLength()); boundExpressions[i]->GetLength());
} }
} }
} }
if (valueType == nullptr){ if (valueType == nullptr) {
valueType = std::make_shared<ScriptType>(TypeClass::Nil); valueType = std::make_shared<ScriptType>(TypeClass::Nil);
} }
auto tableType = std::make_shared<NumericalTableScriptType>(valueType); auto tableType = std::make_shared<NumericalTableScriptType>(valueType);
return new BoundNumericalTableExpression(boundExpressions, tableType, expression->GetStartPosition(), expression->GetLength()); return new BoundNumericalTableExpression(boundExpressions, tableType, expression->GetStartPosition(),
} expression->GetLength());
}
BoundExpression *Binder::BindTableExpression(const ParsedTableExpression *expression) { BoundExpression *Binder::BindTableExpression(const ParsedTableExpression *expression) {
auto tableScope = new unordered_map<uint32_t, BoundVariable*>(); auto tableScope = new unordered_map<uint32_t, BoundVariable *>();
auto innerScope = new BoundScope(tableScope); auto innerScope = new BoundScope(tableScope);
auto currentScope = this -> _scope; auto currentScope = this->_scope;
this -> _scope = innerScope; this->_scope = innerScope;
auto block = this -> BindBlockStatement(expression -> GetBlock()); auto block = this->BindBlockStatement(expression->GetBlock());
this -> _scope = currentScope; this->_scope = currentScope;
auto tableType = std::make_shared<TableScriptType>(tableScope, innerScope->GetLocalVariableCount()); auto tableType = std::make_shared<TableScriptType>(tableScope, innerScope->GetLocalVariableCount());
delete innerScope; delete innerScope;
return new BoundTableExpression((BoundBlockStatement*)block, tableType, expression->GetStartPosition(), expression->GetLength()); return new BoundTableExpression((BoundBlockStatement *) block, tableType, expression->GetStartPosition(),
expression->GetLength());
}
} }

36
src/Binder/Binder.hpp
View File

@ -8,36 +8,54 @@
#include "../Parser/ParsedExpressions/ParsedTableExpression.hpp" #include "../Parser/ParsedExpressions/ParsedTableExpression.hpp"
using namespace std; using namespace std;
using namespace Porygon::Parser;
class Binder { namespace Porygon::Binder {
Script* _scriptData; class Binder {
BoundScope* _scope; Porygon::Script *_scriptData;
BoundScope *_scope;
shared_ptr<FunctionScriptType> _currentFunction; shared_ptr<FunctionScriptType> _currentFunction;
~Binder(); ~Binder();
BoundStatement *BindStatement(const ParsedStatement *statement); BoundStatement *BindStatement(const ParsedStatement *statement);
BoundStatement *BindBlockStatement(const ParsedStatement *statement); BoundStatement *BindBlockStatement(const ParsedStatement *statement);
BoundStatement *BindExpressionStatement(const ParsedStatement *statement); BoundStatement *BindExpressionStatement(const ParsedStatement *statement);
BoundStatement *BindAssignmentStatement(const ParsedStatement *statement); BoundStatement *BindAssignmentStatement(const ParsedStatement *statement);
BoundStatement *BindIndexAssignmentStatement(const ParsedStatement *statement); BoundStatement *BindIndexAssignmentStatement(const ParsedStatement *statement);
BoundStatement *BindFunctionDeclarationStatement(const ParsedStatement * statement);
BoundStatement *BindFunctionDeclarationStatement(const ParsedStatement *statement);
BoundStatement *BindReturnStatement(const ParsedStatement *statement); BoundStatement *BindReturnStatement(const ParsedStatement *statement);
BoundStatement *BindConditionalStatement(const ParsedStatement *statement); BoundStatement *BindConditionalStatement(const ParsedStatement *statement);
BoundExpression *BindExpression(const ParsedExpression *expression); BoundExpression *BindExpression(const ParsedExpression *expression);
BoundExpression *BindVariableExpression(const VariableExpression *expression); BoundExpression *BindVariableExpression(const VariableExpression *expression);
BoundExpression *BindBinaryOperator(const BinaryExpression *expression); BoundExpression *BindBinaryOperator(const BinaryExpression *expression);
BoundExpression *BindUnaryOperator(const UnaryExpression *expression); BoundExpression *BindUnaryOperator(const UnaryExpression *expression);
BoundExpression *BindFunctionCall(const FunctionCallExpression *expression); BoundExpression *BindFunctionCall(const FunctionCallExpression *expression);
BoundExpression *BindIndexExpression(const IndexExpression *expression, bool setter); BoundExpression *BindIndexExpression(const IndexExpression *expression, bool setter);
BoundExpression *BindNumericalTableExpression(const ParsedNumericalTableExpression *expression); BoundExpression *BindNumericalTableExpression(const ParsedNumericalTableExpression *expression);
BoundExpression *BindTableExpression(const ParsedTableExpression * expression);
public: BoundExpression *BindTableExpression(const ParsedTableExpression *expression);
static BoundScriptStatement* Bind(Script* script, const ParsedScriptStatement* s, BoundScope* scriptScope);
public:
static BoundScriptStatement *
Bind(Porygon::Script *script, const ParsedScriptStatement *s, BoundScope *scriptScope);
BoundExpression *BindPeriodIndexExpression(const PeriodIndexExpression *expression, bool setter); BoundExpression *BindPeriodIndexExpression(const PeriodIndexExpression *expression, bool setter);
}; };
}
#endif //PORYGONLANG_BINDER_HPP #endif //PORYGONLANG_BINDER_HPP

284
src/Binder/BoundExpressions/BoundExpression.hpp
View File

@ -10,7 +10,8 @@
using namespace std; using namespace std;
enum class BoundExpressionKind{ namespace Porygon::Binder {
enum class BoundExpressionKind {
Bad, Bad,
LiteralInteger, LiteralInteger,
@ -26,306 +27,313 @@ enum class BoundExpressionKind{
PeriodIndex, PeriodIndex,
NumericalTable, NumericalTable,
Table, Table,
}; };
class BoundExpression{ class BoundExpression {
const unsigned int _start; const unsigned int _start;
const unsigned int _length; const unsigned int _length;
const shared_ptr<ScriptType> _type; const shared_ptr<ScriptType> _type;
public: public:
BoundExpression(unsigned int start, unsigned int length, shared_ptr<ScriptType> type) BoundExpression(unsigned int start, unsigned int length, shared_ptr<ScriptType> type)
: _start(start), : _start(start),
_length(length), _length(length),
_type(std::move(type)) _type(std::move(type)) {
{
} }
virtual ~BoundExpression() = default; virtual ~BoundExpression() = default;
virtual const BoundExpressionKind GetKind() const = 0; virtual const BoundExpressionKind GetKind() const = 0;
virtual const std::shared_ptr<ScriptType>& GetType() const{
virtual const std::shared_ptr<ScriptType> &GetType() const {
return _type; return _type;
}; };
const unsigned int GetStartPosition() const{ const unsigned int GetStartPosition() const {
return _start; return _start;
} }
const unsigned int GetLength() const{
const unsigned int GetLength() const {
return _length; return _length;
} }
const unsigned int GetEndPosition() const{
const unsigned int GetEndPosition() const {
return _start + _length - 1; return _start + _length - 1;
} }
}; };
class BoundBadExpression : public BoundExpression{ class BoundBadExpression : public BoundExpression {
public: public:
BoundBadExpression(unsigned int start, unsigned int length) : BoundExpression(start, length, make_shared<ScriptType>(TypeClass::Error)){} BoundBadExpression(unsigned int start, unsigned int length) : BoundExpression(start, length,
make_shared<ScriptType>(
TypeClass::Error)) {}
const BoundExpressionKind GetKind() const final{ const BoundExpressionKind GetKind() const final {
return BoundExpressionKind ::Bad; return BoundExpressionKind::Bad;
} }
}; };
class BoundLiteralIntegerExpression : public BoundExpression{ class BoundLiteralIntegerExpression : public BoundExpression {
const long _value; const long _value;
public: public:
BoundLiteralIntegerExpression(long value, unsigned int start, unsigned int length) BoundLiteralIntegerExpression(long value, unsigned int start, unsigned int length)
: BoundExpression(start, length, make_shared<NumericScriptType>(true, false)), : BoundExpression(start, length, make_shared<NumericScriptType>(true, false)),
_value(value) _value(value) {
{
} }
const BoundExpressionKind GetKind() const final{ const BoundExpressionKind GetKind() const final {
return BoundExpressionKind ::LiteralInteger; return BoundExpressionKind::LiteralInteger;
} }
const long GetValue() const{ const long GetValue() const {
return _value; return _value;
} }
}; };
class BoundLiteralFloatExpression : public BoundExpression{ class BoundLiteralFloatExpression : public BoundExpression {
const double _value; const double _value;
public: public:
BoundLiteralFloatExpression(double value, unsigned int start, unsigned int length) BoundLiteralFloatExpression(double value, unsigned int start, unsigned int length)
: BoundExpression(start, length, make_shared<NumericScriptType>(true, true)), : BoundExpression(start, length, make_shared<NumericScriptType>(true, true)),
_value(value) _value(value) {
{
} }
const BoundExpressionKind GetKind() const final{ const BoundExpressionKind GetKind() const final {
return BoundExpressionKind ::LiteralFloat; return BoundExpressionKind::LiteralFloat;
} }
const double GetValue() const{ const double GetValue() const {
return _value; return _value;
} }
}; };
class BoundLiteralStringExpression : public BoundExpression{ class BoundLiteralStringExpression : public BoundExpression {
const u16string _value; const u16string _value;
public: public:
BoundLiteralStringExpression(const u16string& value, unsigned int start, unsigned int length) BoundLiteralStringExpression(const u16string &value, unsigned int start, unsigned int length)
: BoundExpression(start, length, make_shared<StringScriptType>(true, HashedString::ConstHash(value.c_str()))), : BoundExpression(start, length,
_value(value) make_shared<StringScriptType>(true, Utilities::HashedString::ConstHash(value.c_str()))),
{ _value(value) {
} }
const BoundExpressionKind GetKind() const final{ const BoundExpressionKind GetKind() const final {
return BoundExpressionKind ::LiteralString; return BoundExpressionKind::LiteralString;
} }
const u16string GetValue() const{ const u16string GetValue() const {
return _value; return _value;
} }
}; };
class BoundLiteralBoolExpression : public BoundExpression{ class BoundLiteralBoolExpression : public BoundExpression {
const bool _value; const bool _value;
public: public:
BoundLiteralBoolExpression(bool value, unsigned int start, unsigned int length) BoundLiteralBoolExpression(bool value, unsigned int start, unsigned int length)
: BoundExpression(start, length, make_shared<ScriptType>(TypeClass::Bool)), : BoundExpression(start, length, make_shared<ScriptType>(TypeClass::Bool)),
_value(value) _value(value) {
{
} }
const BoundExpressionKind GetKind() const final{ const BoundExpressionKind GetKind() const final {
return BoundExpressionKind ::LiteralBool; return BoundExpressionKind::LiteralBool;
} }
const bool GetValue() const{ const bool GetValue() const {
return _value; return _value;
} }
}; };
class BoundVariableExpression : public BoundExpression{ class BoundVariableExpression : public BoundExpression {
const BoundVariableKey* _key; const BoundVariableKey *_key;
public: public:
BoundVariableExpression(BoundVariableKey* key, shared_ptr<ScriptType> type, unsigned int start, unsigned int length) BoundVariableExpression(BoundVariableKey *key, shared_ptr<ScriptType> type, unsigned int start,
unsigned int length)
: BoundExpression(start, length, std::move(type)), : BoundExpression(start, length, std::move(type)),
_key(key) _key(key) {
{
} }
~BoundVariableExpression() override{ ~BoundVariableExpression() override {
delete _key; delete _key;
} }
const BoundExpressionKind GetKind() const final{ const BoundExpressionKind GetKind() const final {
return BoundExpressionKind ::Variable; return BoundExpressionKind::Variable;
} }
const BoundVariableKey* GetKey() const{ const BoundVariableKey *GetKey() const {
return _key; return _key;
} }
}; };
class BoundBinaryExpression : public BoundExpression { class BoundBinaryExpression : public BoundExpression {
const BoundExpression* _left; const BoundExpression *_left;
const BoundExpression* _right; const BoundExpression *_right;
const BoundBinaryOperation _operation; const BoundBinaryOperation _operation;
public: public:
BoundBinaryExpression(BoundExpression* left, BoundExpression* right, BoundBinaryOperation op, shared_ptr<ScriptType> result, BoundBinaryExpression(BoundExpression *left, BoundExpression *right, BoundBinaryOperation op,
shared_ptr<ScriptType> result,
unsigned int start, unsigned int length) unsigned int start, unsigned int length)
: BoundExpression(start, length, std::move(result)), : BoundExpression(start, length, std::move(result)),
_left(left), _left(left),
_right(right), _right(right),
_operation(op) _operation(op) {
{
} }
~BoundBinaryExpression() final{ ~BoundBinaryExpression() final {
delete _left; delete _left;
delete _right; delete _right;
} }
const BoundExpressionKind GetKind() const final{ const BoundExpressionKind GetKind() const final {
return BoundExpressionKind ::Binary; return BoundExpressionKind::Binary;
} }
const BoundExpression* GetLeft() const{ const BoundExpression *GetLeft() const {
return _left; return _left;
} }
const BoundExpression* GetRight() const{ const BoundExpression *GetRight() const {
return _right; return _right;
} }
const BoundBinaryOperation GetOperation() const{ const BoundBinaryOperation GetOperation() const {
return _operation; return _operation;
} }
}; };
class BoundUnaryExpression : public BoundExpression { class BoundUnaryExpression : public BoundExpression {
const BoundExpression* _operand; const BoundExpression *_operand;
const BoundUnaryOperation _operation; const BoundUnaryOperation _operation;
public: public:
BoundUnaryExpression(BoundExpression* operand, BoundUnaryOperation op, shared_ptr<ScriptType> result, unsigned int start, unsigned int length) BoundUnaryExpression(BoundExpression *operand, BoundUnaryOperation op, shared_ptr<ScriptType> result,
unsigned int start, unsigned int length)
: BoundExpression(start, length, std::move(result)), : BoundExpression(start, length, std::move(result)),
_operand(operand), _operand(operand),
_operation(op) _operation(op) {
{
} }
~BoundUnaryExpression() final{ ~BoundUnaryExpression() final {
delete _operand; delete _operand;
} }
const BoundExpressionKind GetKind() const final{ const BoundExpressionKind GetKind() const final {
return BoundExpressionKind ::Unary; return BoundExpressionKind::Unary;
} }
const BoundExpression* GetOperand() const{ const BoundExpression *GetOperand() const {
return _operand; return _operand;
} }
const BoundUnaryOperation GetOperation() const{ const BoundUnaryOperation GetOperation() const {
return _operation; return _operation;
} }
}; };
class BoundFunctionCallExpression : public BoundExpression { class BoundFunctionCallExpression : public BoundExpression {
const BoundExpression* _functionExpression; const BoundExpression *_functionExpression;
const vector<BoundExpression*> _parameters; const vector<BoundExpression *> _parameters;
public: public:
BoundFunctionCallExpression(BoundExpression *functionExpression, vector<BoundExpression *> parameters, shared_ptr<ScriptType> result, BoundFunctionCallExpression(BoundExpression *functionExpression, vector<BoundExpression *> parameters,
shared_ptr<ScriptType> result,
unsigned int start, unsigned int length) unsigned int start, unsigned int length)
: BoundExpression(start, length, std::move(result)), _functionExpression(functionExpression), _parameters(std::move(parameters)) {} : BoundExpression(start, length, std::move(result)), _functionExpression(functionExpression),
_parameters(std::move(parameters)) {}
~BoundFunctionCallExpression() final{ ~BoundFunctionCallExpression() final {
delete _functionExpression; delete _functionExpression;
for (auto p : _parameters){ for (auto p : _parameters) {
delete p; delete p;
} }
} }
const BoundExpressionKind GetKind() const final{ const BoundExpressionKind GetKind() const final {
return BoundExpressionKind ::FunctionCall; return BoundExpressionKind::FunctionCall;
} }
const BoundExpression* GetFunctionExpression() const{ const BoundExpression *GetFunctionExpression() const {
return _functionExpression; return _functionExpression;
} }
const vector<BoundExpression*>* GetParameters() const{ const vector<BoundExpression *> *GetParameters() const {
return &_parameters; return &_parameters;
} }
}; };
class BoundIndexExpression : public BoundExpression { class BoundIndexExpression : public BoundExpression {
const BoundExpression* _indexableExpression; const BoundExpression *_indexableExpression;
const BoundExpression* _indexExpression; const BoundExpression *_indexExpression;
public: public:
BoundIndexExpression(BoundExpression* indexableExpression, BoundExpression* indexExpression, shared_ptr<ScriptType> result, BoundIndexExpression(BoundExpression *indexableExpression, BoundExpression *indexExpression,
shared_ptr<ScriptType> result,
unsigned int start, unsigned int length) unsigned int start, unsigned int length)
: BoundExpression(start, length, std::move(result)), _indexableExpression(indexableExpression), _indexExpression(indexExpression) {} : BoundExpression(start, length, std::move(result)), _indexableExpression(indexableExpression),
_indexExpression(indexExpression) {}
~BoundIndexExpression() final{ ~BoundIndexExpression() final {
delete _indexableExpression; delete _indexableExpression;
delete _indexExpression; delete _indexExpression;
} }
const BoundExpressionKind GetKind() const final{ const BoundExpressionKind GetKind() const final {
return BoundExpressionKind ::Index; return BoundExpressionKind::Index;
} }
const BoundExpression* GetIndexableExpression() const{ const BoundExpression *GetIndexableExpression() const {
return _indexableExpression; return _indexableExpression;
} }
const BoundExpression* GetIndexExpression() const{ const BoundExpression *GetIndexExpression() const {
return _indexExpression; return _indexExpression;
} }
}; };
class BoundPeriodIndexExpression : public BoundExpression { class BoundPeriodIndexExpression : public BoundExpression {
const BoundExpression* _indexableExpression; const BoundExpression *_indexableExpression;
const HashedString _index; const Utilities::HashedString _index;
public: public:
BoundPeriodIndexExpression(BoundExpression* indexableExpression, HashedString index, shared_ptr<ScriptType> result, BoundPeriodIndexExpression(BoundExpression *indexableExpression, Utilities::HashedString index,
shared_ptr<ScriptType> result,
unsigned int start, unsigned int length) unsigned int start, unsigned int length)
: BoundExpression(start, length, std::move(result)), _indexableExpression(indexableExpression), _index(index) {} : BoundExpression(start, length, std::move(result)), _indexableExpression(indexableExpression),
_index(index) {}
~BoundPeriodIndexExpression() final{ ~BoundPeriodIndexExpression() final {
delete _indexableExpression; delete _indexableExpression;
} }
const BoundExpressionKind GetKind() const final{ const BoundExpressionKind GetKind() const final {
return BoundExpressionKind ::PeriodIndex; return BoundExpressionKind::PeriodIndex;
} }
const BoundExpression* GetIndexableExpression() const{ const BoundExpression *GetIndexableExpression() const {
return _indexableExpression; return _indexableExpression;
} }
const HashedString GetIndex() const{ const Utilities::HashedString GetIndex() const {
return _index; return _index;
} }
}; };
class BoundNumericalTableExpression : public BoundExpression{ class BoundNumericalTableExpression : public BoundExpression {
const vector<const BoundExpression*> _expressions; const vector<const BoundExpression *> _expressions;
public: public:
BoundNumericalTableExpression(vector<const BoundExpression*> expressions, shared_ptr<ScriptType> type, unsigned int start, unsigned int length) BoundNumericalTableExpression(vector<const BoundExpression *> expressions, shared_ptr<ScriptType> type,
unsigned int start, unsigned int length)
: BoundExpression(start, length, std::move(type)), : BoundExpression(start, length, std::move(type)),
_expressions(std::move(expressions)) _expressions(std::move(expressions)) {}
{}
~BoundNumericalTableExpression() final{ ~BoundNumericalTableExpression() final {
for (auto e: _expressions){ for (auto e: _expressions) {
delete e; delete e;
} }
} }
const BoundExpressionKind GetKind() const final{ const BoundExpressionKind GetKind() const final {
return BoundExpressionKind ::NumericalTable; return BoundExpressionKind::NumericalTable;
} }
const vector<const BoundExpression*>* GetExpressions() const{ const vector<const BoundExpression *> *GetExpressions() const {
return &_expressions; return &_expressions;
} }
}; };
}
#endif //PORYGONLANG_BOUNDEXPRESSION_HPP #endif //PORYGONLANG_BOUNDEXPRESSION_HPP

21
src/Binder/BoundExpressions/BoundTableExpression.hpp
View File

@ -6,26 +6,29 @@
#include "../BoundStatements/BoundStatement.hpp" #include "../BoundStatements/BoundStatement.hpp"
class BoundTableExpression : public BoundExpression{ namespace Porygon::Binder {
const BoundBlockStatement* _block; class BoundTableExpression : public BoundExpression {
public: const BoundBlockStatement *_block;
BoundTableExpression(BoundBlockStatement* block, shared_ptr<ScriptType> type, unsigned int start, unsigned int length) public:
: BoundExpression(start, length, std::move(type)){ BoundTableExpression(BoundBlockStatement *block, shared_ptr<ScriptType> type, unsigned int start,
unsigned int length)
: BoundExpression(start, length, std::move(type)) {
_block = block; _block = block;
} }
~BoundTableExpression() final{ ~BoundTableExpression() final {
delete _block; delete _block;
} }
const BoundExpressionKind GetKind() const final { const BoundExpressionKind GetKind() const final {
return BoundExpressionKind ::Table; return BoundExpressionKind::Table;
} }
const BoundBlockStatement* GetBlock() const { const BoundBlockStatement *GetBlock() const {
return _block; return _block;
} }
}; };
}
#include "BoundExpression.hpp" #include "BoundExpression.hpp"

10
src/Binder/BoundOperators.hpp
View File

@ -2,7 +2,8 @@
#ifndef PORYGONLANG_BOUNDOPERATORS_HPP #ifndef PORYGONLANG_BOUNDOPERATORS_HPP
#define PORYGONLANG_BOUNDOPERATORS_HPP #define PORYGONLANG_BOUNDOPERATORS_HPP
enum class BoundBinaryOperation{ namespace Porygon::Binder {
enum class BoundBinaryOperation {
Addition, Addition,
Subtraction, Subtraction,
Multiplication, Multiplication,
@ -17,11 +18,12 @@ enum class BoundBinaryOperation{
LogicalAnd, LogicalAnd,
LogicalOr, LogicalOr,
Concatenation Concatenation
}; };
enum class BoundUnaryOperation{ enum class BoundUnaryOperation {
Negation, Negation,
LogicalNegation, LogicalNegation,
}; };
}
#endif //PORYGONLANG_BOUNDOPERATORS_HPP #endif //PORYGONLANG_BOUNDOPERATORS_HPP

28
src/Binder/BoundStatements/BoundFunctionDeclarationStatement.hpp
View File

@ -7,36 +7,38 @@
#include <memory> #include <memory>
#include "BoundStatement.hpp" #include "BoundStatement.hpp"
class BoundFunctionDeclarationStatement : public BoundStatement{ namespace Porygon::Binder {
const BoundVariableKey* _key; class BoundFunctionDeclarationStatement : public BoundStatement {
const BoundVariableKey *_key;
const std::shared_ptr<BoundBlockStatement> _block; const std::shared_ptr<BoundBlockStatement> _block;
const std::shared_ptr<FunctionScriptType> _type; const std::shared_ptr<FunctionScriptType> _type;
public: public:
BoundFunctionDeclarationStatement(std::shared_ptr<FunctionScriptType> type, BoundVariableKey* key, BoundBlockStatement* block) BoundFunctionDeclarationStatement(std::shared_ptr<FunctionScriptType> type, BoundVariableKey *key,
:_key(key), _block(block), _type(std::move(type)) BoundBlockStatement *block)
{ : _key(key), _block(block), _type(std::move(type)) {
} }
~BoundFunctionDeclarationStatement() final{ ~BoundFunctionDeclarationStatement() final {
delete _key; delete _key;
} }
const BoundStatementKind GetKind() const final{ const BoundStatementKind GetKind() const final {
return BoundStatementKind ::FunctionDeclaration; return BoundStatementKind::FunctionDeclaration;
} }
const BoundVariableKey* GetKey() const{ const BoundVariableKey *GetKey() const {
return _key; return _key;
} }
const std::shared_ptr<BoundBlockStatement> GetBlock() const{ const std::shared_ptr<BoundBlockStatement> GetBlock() const {
return _block; return _block;
} }
const std::shared_ptr<FunctionScriptType> GetType() const{ const std::shared_ptr<FunctionScriptType> GetType() const {
return _type; return _type;
} }
}; };
}
#include "BoundStatement.hpp" #include "BoundStatement.hpp"

183
src/Binder/BoundStatements/BoundStatement.hpp
View File

@ -12,7 +12,8 @@
using namespace std; using namespace std;
enum class BoundStatementKind{ namespace Porygon::Binder {
enum class BoundStatementKind {
Bad, Bad,
Script, Script,
Block, Block,
@ -22,188 +23,186 @@ enum class BoundStatementKind{
FunctionDeclaration, FunctionDeclaration,
Return, Return,
Conditional, Conditional,
}; };
class BoundStatement{ class BoundStatement {
public: public:
virtual const BoundStatementKind GetKind() const = 0; virtual const BoundStatementKind GetKind() const = 0;
virtual ~BoundStatement() = default; virtual ~BoundStatement() = default;
}; };
class BoundBadStatement : public BoundStatement{ class BoundBadStatement : public BoundStatement {
public: public:
const BoundStatementKind GetKind() const final{ const BoundStatementKind GetKind() const final {
return BoundStatementKind ::Bad; return BoundStatementKind::Bad;
} }
}; };
class BoundBlockStatement : public BoundStatement{ class BoundBlockStatement : public BoundStatement {
const vector<BoundStatement*> _statements; const vector<BoundStatement *> _statements;
public: public:
explicit BoundBlockStatement(vector<BoundStatement*> statements) explicit BoundBlockStatement(vector<BoundStatement *> statements)
: _statements(std::move(statements)) : _statements(std::move(statements)) {
{
} }
~BoundBlockStatement() override { ~BoundBlockStatement() override {
for (auto s : _statements){ for (auto s : _statements) {
delete s; delete s;
} }
} }
const BoundStatementKind GetKind() const override { const BoundStatementKind GetKind() const override {
return BoundStatementKind ::Block; return BoundStatementKind::Block;
} }
const vector<BoundStatement*>* GetStatements() const{ const vector<BoundStatement *> *GetStatements() const {
return &_statements; return &_statements;
} }
}; };
class BoundScriptStatement : public BoundBlockStatement{ class BoundScriptStatement : public BoundBlockStatement {
const int _localVariableCount; const int _localVariableCount;
public: public:
explicit BoundScriptStatement(vector<BoundStatement*> statements, int localVariableCount) explicit BoundScriptStatement(vector<BoundStatement *> statements, int localVariableCount)
: BoundBlockStatement(std::move(statements)), : BoundBlockStatement(std::move(statements)),
_localVariableCount(localVariableCount) _localVariableCount(localVariableCount) {
{
} }
const BoundStatementKind GetKind() const final{ const BoundStatementKind GetKind() const final {
return BoundStatementKind ::Script; return BoundStatementKind::Script;
} }
const int GetLocalVariableCount() const{ const int GetLocalVariableCount() const {
return _localVariableCount; return _localVariableCount;
} }
}; };
class BoundExpressionStatement : public BoundStatement{ class BoundExpressionStatement : public BoundStatement {
const BoundExpression* _expression; const BoundExpression *_expression;
public: public:
explicit BoundExpressionStatement(BoundExpression* expression) explicit BoundExpressionStatement(BoundExpression *expression)
: _expression(expression) : _expression(expression) {
{
_expression = expression; _expression = expression;
} }
~BoundExpressionStatement() final{
~BoundExpressionStatement() final {
delete _expression; delete _expression;
} }
const BoundStatementKind GetKind() const final{ const BoundStatementKind GetKind() const final {
return BoundStatementKind ::Expression; return BoundStatementKind::Expression;
} }
const BoundExpression* GetExpression() const{ const BoundExpression *GetExpression() const {
return _expression; return _expression;
} }
}; };
class BoundAssignmentStatement : public BoundStatement{ class BoundAssignmentStatement : public BoundStatement {
const BoundVariableKey* _key; const BoundVariableKey *_key;
const BoundExpression* _expression; const BoundExpression *_expression;
public: public:
BoundAssignmentStatement(BoundVariableKey* key, BoundExpression* expression) BoundAssignmentStatement(BoundVariableKey *key, BoundExpression *expression)
: _key(key), _expression(expression) : _key(key), _expression(expression) {
{
} }
~BoundAssignmentStatement() final{ ~BoundAssignmentStatement() final {
delete _key; delete _key;
delete _expression; delete _expression;
} }
const BoundStatementKind GetKind() const final{ const BoundStatementKind GetKind() const final {
return BoundStatementKind ::Assignment; return BoundStatementKind::Assignment;
} }
const BoundVariableKey* GetKey() const { const BoundVariableKey *GetKey() const {
return _key; return _key;
} }
const BoundExpression* GetExpression() const { const BoundExpression *GetExpression() const {
return _expression; return _expression;
} }
}; };
class BoundIndexAssignmentStatement : public BoundStatement{ class BoundIndexAssignmentStatement : public BoundStatement {
const BoundExpression* _indexExpression; const BoundExpression *_indexExpression;
const BoundExpression* _valueExpression; const BoundExpression *_valueExpression;
public: public:
BoundIndexAssignmentStatement(const BoundExpression* index, BoundExpression* value) BoundIndexAssignmentStatement(const BoundExpression *index, BoundExpression *value)
: _indexExpression(index), _valueExpression(value) : _indexExpression(index), _valueExpression(value) {
{
} }
~BoundIndexAssignmentStatement() final{ ~BoundIndexAssignmentStatement() final {
delete _indexExpression; delete _indexExpression;
delete _valueExpression; delete _valueExpression;
} }
const BoundStatementKind GetKind() const final{ const BoundStatementKind GetKind() const final {
return BoundStatementKind ::IndexAssignment; return BoundStatementKind::IndexAssignment;
} }
const BoundExpression* GetIndexExpression() const { const BoundExpression *GetIndexExpression() const {
return _indexExpression; return _indexExpression;
} }
const BoundExpression* GetValueExpression() const { const BoundExpression *GetValueExpression() const {
return _valueExpression; return _valueExpression;
} }
}; };
class BoundReturnStatement : public BoundStatement{ class BoundReturnStatement : public BoundStatement {
const BoundExpression* _expression; const BoundExpression *_expression;
public: public:
explicit BoundReturnStatement(BoundExpression* expression) explicit BoundReturnStatement(BoundExpression *expression)
: _expression(expression) : _expression(expression) {
{
} }
~BoundReturnStatement() final{
~BoundReturnStatement() final {
delete _expression; delete _expression;
} }
const BoundStatementKind GetKind() const final{ const BoundStatementKind GetKind() const final {
return BoundStatementKind ::Return; return BoundStatementKind::Return;
} }
const BoundExpression* GetExpression() const{ const BoundExpression *GetExpression() const {
return _expression; return _expression;
} }
}; };
class BoundConditionalStatement : public BoundStatement{ class BoundConditionalStatement : public BoundStatement {
const BoundExpression* _condition; const BoundExpression *_condition;
const BoundStatement* _block; const BoundStatement *_block;
const BoundStatement* _elseStatement; const BoundStatement *_elseStatement;
public: public:
explicit BoundConditionalStatement(BoundExpression* condition, BoundStatement* block, BoundStatement* next) explicit BoundConditionalStatement(BoundExpression *condition, BoundStatement *block, BoundStatement *next)
:_condition(condition), _block(block), _elseStatement(next) : _condition(condition), _block(block), _elseStatement(next) {
{
} }
~BoundConditionalStatement() final{ ~BoundConditionalStatement() final {
delete _condition; delete _condition;
delete _block; delete _block;
delete _elseStatement; delete _elseStatement;
} }
const BoundStatementKind GetKind() const final{ const BoundStatementKind GetKind() const final {
return BoundStatementKind ::Conditional; return BoundStatementKind::Conditional;
} }
const BoundExpression* GetCondition() const{ const BoundExpression *GetCondition() const {
return _condition; return _condition;
} }
const BoundStatement* GetBlock() const{ const BoundStatement *GetBlock() const {
return _block; return _block;
} }
const BoundStatement* GetElseStatement() const{ const BoundStatement *GetElseStatement() const {
return _elseStatement; return _elseStatement;
} }
}; };
}
#include "BoundFunctionDeclarationStatement.hpp" #include "BoundFunctionDeclarationStatement.hpp"

83
src/Binder/BoundVariables/BoundScope.cpp
View File

@ -3,96 +3,99 @@
#include "BoundScope.hpp" #include "BoundScope.hpp"
BoundScope::BoundScope(unordered_map<uint32_t, BoundVariable *> *tableScope) { namespace Porygon::Binder {
BoundScope::BoundScope(unordered_map<uint32_t, BoundVariable *> *tableScope) {
_tableScope = tableScope; _tableScope = tableScope;
_currentScope = 1; _currentScope = 1;
_lastCreatedScope = 1; _lastCreatedScope = 1;
auto localUpmostScope = new unordered_map<uint32_t, BoundVariable*>(); auto localUpmostScope = new unordered_map<uint32_t, BoundVariable *>();
_localScope.push_back(localUpmostScope); _localScope.push_back(localUpmostScope);
} }
BoundScope::~BoundScope() { BoundScope::~BoundScope() {
for (auto scope : _localScope){ for (auto scope : _localScope) {
for (auto v : *scope){ for (auto v : *scope) {
delete v.second; delete v.second;
} }
delete scope; delete scope;
} }
} }
void BoundScope::GoInnerScope() { void BoundScope::GoInnerScope() {
_lastCreatedScope++; _lastCreatedScope++;
_currentScope = _lastCreatedScope; _currentScope = _lastCreatedScope;
if (_localScope.size() < _currentScope){ if (_localScope.size() < _currentScope) {
auto innerScope = new unordered_map<uint32_t, BoundVariable*>(); auto innerScope = new unordered_map<uint32_t, BoundVariable *>();
_localScope.push_back(innerScope); _localScope.push_back(innerScope);
} }
} }
void BoundScope::GoOuterScope() { void BoundScope::GoOuterScope() {
auto scope = _localScope[_currentScope - 1]; auto scope = _localScope[_currentScope - 1];
for (auto v : *scope){ for (auto v : *scope) {
delete v.second; delete v.second;
} }
scope->clear(); scope->clear();
_currentScope--; _currentScope--;
} }
int BoundScope::Exists(int key) { int BoundScope::Exists(int key) {
auto found = this -> _tableScope -> find(key); auto found = this->_tableScope->find(key);
if (found != _tableScope -> end()){ if (found != _tableScope->end()) {
return 0; return 0;
} }
for (int i = _currentScope - 1; i >= 0; i--){ for (int i = _currentScope - 1; i >= 0; i--) {
auto scope = _localScope.at(i); auto scope = _localScope.at(i);
found = scope -> find(key); found = scope->find(key);
if (found != scope -> end()){ if (found != scope->end()) {
return i + 1; return i + 1;
} }
} }
return -1; return -1;
} }
BoundVariable *BoundScope::GetVariable(uint32_t scope, uint32_t identifier) { BoundVariable *BoundScope::GetVariable(uint32_t scope, uint32_t identifier) {
if (scope == 0){ if (scope == 0) {
auto find = this -> _tableScope->find(identifier); auto find = this->_tableScope->find(identifier);
if (find != _tableScope->end()){ if (find != _tableScope->end()) {
return find -> second; return find->second;
} }
return nullptr; return nullptr;
} else{ } else {
auto s = this->_localScope.at(scope - 1); auto s = this->_localScope.at(scope - 1);
auto find = s -> find(identifier); auto find = s->find(identifier);
if (find != s -> end()){ if (find != s->end()) {
return find -> second; return find->second;
} }
return nullptr; return nullptr;
} }
} }
VariableAssignment BoundScope::CreateExplicitLocal(uint32_t identifier, std::shared_ptr<ScriptType> type) { VariableAssignment BoundScope::CreateExplicitLocal(uint32_t identifier, std::shared_ptr<ScriptType> type) {
auto scope = this->_localScope.at(this->_currentScope - 1); auto scope = this->_localScope.at(this->_currentScope - 1);
if (scope -> find(identifier) != scope -> end()){ if (scope->find(identifier) != scope->end()) {
return VariableAssignment(VariableAssignmentResult::ExplicitLocalVariableExists, nullptr); return VariableAssignment(VariableAssignmentResult::ExplicitLocalVariableExists, nullptr);
} }
scope -> insert({identifier, new BoundVariable(std::move(type))}); scope->insert({identifier, new BoundVariable(std::move(type))});
return VariableAssignment(VariableAssignmentResult::Ok, new BoundVariableKey(identifier, this->_currentScope, true)); return VariableAssignment(VariableAssignmentResult::Ok,
} new BoundVariableKey(identifier, this->_currentScope, true));
}
VariableAssignment BoundScope::AssignVariable(uint32_t identifier, const std::shared_ptr<ScriptType>& type) { VariableAssignment BoundScope::AssignVariable(uint32_t identifier, const std::shared_ptr<ScriptType> &type) {
int exists = this->Exists(identifier); int exists = this->Exists(identifier);
if (exists == -1){ if (exists == -1) {
// Creation // Creation
_tableScope->insert({identifier, new BoundVariable(type)}); _tableScope->insert({identifier, new BoundVariable(type)});
return VariableAssignment(VariableAssignmentResult::Ok, new BoundVariableKey(identifier, 0, true)); return VariableAssignment(VariableAssignmentResult::Ok, new BoundVariableKey(identifier, 0, true));
} else{ } else {
// Assigning // Assigning
auto var = this->GetVariable(exists, identifier); auto var = this->GetVariable(exists, identifier);
if (var->GetType().get()->operator!=(type.get())){ if (var->GetType().get()->operator!=(type.get())) {
return VariableAssignment(VariableAssignmentResult::VariableDefinedWithDifferentType, nullptr); return VariableAssignment(VariableAssignmentResult::VariableDefinedWithDifferentType, nullptr);
} }
return VariableAssignment(VariableAssignmentResult::Ok, new BoundVariableKey(identifier, exists, false)); return VariableAssignment(VariableAssignmentResult::Ok, new BoundVariableKey(identifier, exists, false));
} }
}
} }

29
src/Binder/BoundVariables/BoundScope.hpp
View File

@ -13,31 +13,38 @@
using namespace std; using namespace std;
class BoundScope { namespace Porygon::Binder {
unordered_map<uint32_t, BoundVariable*>* _tableScope; class BoundScope {
vector<unordered_map<uint32_t, BoundVariable*>*> _localScope; unordered_map<uint32_t, BoundVariable *> *_tableScope;
vector<unordered_map<uint32_t, BoundVariable *> *> _localScope;
int _currentScope; int _currentScope;
int _lastCreatedScope; int _lastCreatedScope;
public: public:
explicit BoundScope(unordered_map<uint32_t, BoundVariable*> *tableScope); explicit BoundScope(unordered_map<uint32_t, BoundVariable *> *tableScope);
~BoundScope(); ~BoundScope();
void GoInnerScope(); void GoInnerScope();
void GoOuterScope(); void GoOuterScope();
int Exists(int key); int Exists(int key);
BoundVariable* GetVariable(uint32_t scope, uint32_t identifier);
VariableAssignment CreateExplicitLocal(uint32_t identifier, std::shared_ptr<ScriptType> type);
VariableAssignment AssignVariable(uint32_t identifier, const std::shared_ptr<ScriptType>& type);
size_t GetLocalVariableCount(){ BoundVariable *GetVariable(uint32_t scope, uint32_t identifier);
VariableAssignment CreateExplicitLocal(uint32_t identifier, std::shared_ptr<ScriptType> type);
VariableAssignment AssignVariable(uint32_t identifier, const std::shared_ptr<ScriptType> &type);
size_t GetLocalVariableCount() {
return _localScope.size(); return _localScope.size();
} }
int GetCurrentScope(){ int GetCurrentScope() {
return _currentScope; return _currentScope;
} }
}; };
}
#endif //PORYGONLANG_BOUNDSCOPE_HPP #endif //PORYGONLANG_BOUNDSCOPE_HPP

12
src/Binder/BoundVariables/BoundVariable.hpp
View File

@ -9,15 +9,17 @@
using namespace std; using namespace std;
class BoundVariable{ namespace Porygon::Binder {
class BoundVariable {
std::shared_ptr<ScriptType> _type; std::shared_ptr<ScriptType> _type;
public: public:
explicit BoundVariable(std::shared_ptr<ScriptType> type) : _type(std::move(type)){ explicit BoundVariable(std::shared_ptr<ScriptType> type) : _type(std::move(type)) {
} }
std::shared_ptr<ScriptType> GetType(){ std::shared_ptr<ScriptType> GetType() {
return _type; return _type;
} }
}; };
}
#endif //PORYGONLANG_BOUNDVARIABLE_HPP #endif //PORYGONLANG_BOUNDVARIABLE_HPP

23
src/Binder/BoundVariables/BoundVariableKey.hpp
View File

@ -4,42 +4,43 @@
#include <string> #include <string>
class BoundVariableKey{ namespace Porygon::Binder {
class BoundVariableKey {
const int _identifier; const int _identifier;
const unsigned int _scopeId; const unsigned int _scopeId;
const bool _isCreation; const bool _isCreation;
const uint64_t _hash; const uint64_t _hash;
static uint64_t KnuthsHash(unsigned int i1, unsigned int i2) static uint64_t KnuthsHash(unsigned int i1, unsigned int i2) {
{
uint64_t ret = i1; uint64_t ret = i1;
ret *= 2654435761U; ret *= 2654435761U;
return ret ^ i2; return ret ^ i2;
} }
public:
public:
BoundVariableKey(int id, unsigned int scope, bool creation) BoundVariableKey(int id, unsigned int scope, bool creation)
: _identifier(id), : _identifier(id),
_scopeId(scope), _scopeId(scope),
_isCreation(creation), _isCreation(creation),
_hash(KnuthsHash(id, scope)) _hash(KnuthsHash(id, scope)) {}
{}
const int GetIdentifier() const{ const int GetIdentifier() const {
return _identifier; return _identifier;
} }
const unsigned int GetScopeId() const{ const unsigned int GetScopeId() const {
return _scopeId; return _scopeId;
} }
const bool IsCreation() const{ const bool IsCreation() const {
return _isCreation; return _isCreation;
} }
const uint64_t GetHash() const{ const uint64_t GetHash() const {
return _hash; return _hash;
} }
}; };
}
#endif //PORYGONLANG_BOUNDVARIABLEKEY_HPP #endif //PORYGONLANG_BOUNDVARIABLEKEY_HPP

18
src/Binder/BoundVariables/VariableAssigmentResult.hpp
View File

@ -4,28 +4,30 @@
#include "BoundVariableKey.hpp" #include "BoundVariableKey.hpp"
enum class VariableAssignmentResult{ namespace Porygon::Binder {
enum class VariableAssignmentResult {
Ok, Ok,
ExplicitLocalVariableExists, ExplicitLocalVariableExists,
VariableDefinedWithDifferentType VariableDefinedWithDifferentType
}; };
class VariableAssignment{ class VariableAssignment {
VariableAssignmentResult _result; VariableAssignmentResult _result;
BoundVariableKey* _key; BoundVariableKey *_key;
public: public:
VariableAssignment(VariableAssignmentResult result, BoundVariableKey *key) { VariableAssignment(VariableAssignmentResult result, BoundVariableKey *key) {
_result = result; _result = result;
_key = key; _key = key;
} }
VariableAssignmentResult GetResult(){ VariableAssignmentResult GetResult() {
return _result; return _result;
} }
BoundVariableKey* GetKey(){ BoundVariableKey *GetKey() {
return _key; return _key;
} }
}; };
}
#endif //PORYGONLANG_VARIABLEASSIGMENTRESULT_HPP #endif //PORYGONLANG_VARIABLEASSIGMENTRESULT_HPP

94
src/Evaluator/BinaryEvaluation.cpp
View File

@ -5,91 +5,87 @@
#include "EvalValues/NumericEvalValue.hpp" #include "EvalValues/NumericEvalValue.hpp"
#include "EvalValues/StringEvalValue.hpp" #include "EvalValues/StringEvalValue.hpp"
const shared_ptr<NumericEvalValue> Evaluator::EvaluateIntegerBinary(const BoundBinaryExpression *expression) { using namespace Porygon::Binder;
auto leftValue = this -> EvaluateIntegerExpression(expression->GetLeft());
auto rightValue = this -> EvaluateIntegerExpression(expression->GetRight());
switch (expression->GetOperation()){ namespace Porygon::Evaluation {
case BoundBinaryOperation ::Addition: const shared_ptr<NumericEvalValue> Evaluator::EvaluateIntegerBinary(const BoundBinaryExpression *expression) {
return leftValue.get() -> operator+ (rightValue); auto leftValue = this->EvaluateIntegerExpression(expression->GetLeft());
auto rightValue = this->EvaluateIntegerExpression(expression->GetRight());
switch (expression->GetOperation()) {
case BoundBinaryOperation::Addition:
return leftValue.get()->operator+(rightValue);
case BoundBinaryOperation::Subtraction: case BoundBinaryOperation::Subtraction:
return leftValue.get() -> operator- (rightValue); return leftValue.get()->operator-(rightValue);
case BoundBinaryOperation::Multiplication: case BoundBinaryOperation::Multiplication:
return leftValue.get() -> operator* (rightValue); return leftValue.get()->operator*(rightValue);
case BoundBinaryOperation::Division: case BoundBinaryOperation::Division:
return leftValue.get() -> operator/ (rightValue); return leftValue.get()->operator/(rightValue);
default: default:
throw EvaluationException("Can't evaluate operation to numeric"); throw EvaluationException("Can't evaluate operation to numeric");
} }
} }
const shared_ptr<BooleanEvalValue> Evaluator::EvaluateBooleanBinary(const BoundBinaryExpression *expression){ const shared_ptr<BooleanEvalValue> Evaluator::EvaluateBooleanBinary(const BoundBinaryExpression *expression) {
switch (expression->GetOperation()){ switch (expression->GetOperation()) {
case BoundBinaryOperation::Equality: case BoundBinaryOperation::Equality: {
{ auto leftValue = this->EvaluateExpression(expression->GetLeft());
auto leftValue = this -> EvaluateExpression(expression->GetLeft()); auto rightValue = this->EvaluateExpression(expression->GetRight());
auto rightValue = this -> EvaluateExpression(expression->GetRight());
bool equals = leftValue.get()->operator==(rightValue.get()); bool equals = leftValue.get()->operator==(rightValue.get());
return make_shared<BooleanEvalValue>(equals); return make_shared<BooleanEvalValue>(equals);
} }
case BoundBinaryOperation::Inequality: case BoundBinaryOperation::Inequality: {
{ auto leftValue = this->EvaluateExpression(expression->GetLeft());
auto leftValue = this -> EvaluateExpression(expression->GetLeft()); auto rightValue = this->EvaluateExpression(expression->GetRight());
auto rightValue = this -> EvaluateExpression(expression->GetRight());
bool equals = leftValue.get()->operator!=(rightValue.get()); bool equals = leftValue.get()->operator!=(rightValue.get());
return make_shared<BooleanEvalValue>(equals); return make_shared<BooleanEvalValue>(equals);
} }
case BoundBinaryOperation ::LessThan: case BoundBinaryOperation::LessThan: {
{ auto leftValue = this->EvaluateIntegerExpression(expression->GetLeft());
auto leftValue = this -> EvaluateIntegerExpression(expression->GetLeft()); auto rightValue = this->EvaluateIntegerExpression(expression->GetRight());
auto rightValue = this -> EvaluateIntegerExpression(expression->GetRight());
return leftValue->operator<(rightValue); return leftValue->operator<(rightValue);
} }
case BoundBinaryOperation ::LessThanEquals: case BoundBinaryOperation::LessThanEquals: {
{ auto leftValue = this->EvaluateIntegerExpression(expression->GetLeft());
auto leftValue = this -> EvaluateIntegerExpression(expression->GetLeft()); auto rightValue = this->EvaluateIntegerExpression(expression->GetRight());
auto rightValue = this -> EvaluateIntegerExpression(expression->GetRight());
return leftValue->operator<=(rightValue); return leftValue->operator<=(rightValue);
} }
case BoundBinaryOperation ::GreaterThan: case BoundBinaryOperation::GreaterThan: {
{ auto leftValue = this->EvaluateIntegerExpression(expression->GetLeft());
auto leftValue = this -> EvaluateIntegerExpression(expression->GetLeft()); auto rightValue = this->EvaluateIntegerExpression(expression->GetRight());
auto rightValue = this -> EvaluateIntegerExpression(expression->GetRight());
return leftValue->operator>(rightValue); return leftValue->operator>(rightValue);
} }
case BoundBinaryOperation ::GreaterThanEquals: case BoundBinaryOperation::GreaterThanEquals: {
{ auto leftValue = this->EvaluateIntegerExpression(expression->GetLeft());
auto leftValue = this -> EvaluateIntegerExpression(expression->GetLeft()); auto rightValue = this->EvaluateIntegerExpression(expression->GetRight());
auto rightValue = this -> EvaluateIntegerExpression(expression->GetRight());
return leftValue->operator>=(rightValue); return leftValue->operator>=(rightValue);
} }
case BoundBinaryOperation::LogicalAnd: case BoundBinaryOperation::LogicalAnd: {
{ auto leftValue = this->EvaluateBoolExpression(expression->GetLeft());
auto leftValue = this -> EvaluateBoolExpression(expression->GetLeft());
if (!leftValue->EvaluateBool()) return leftValue; if (!leftValue->EvaluateBool()) return leftValue;
auto rightValue = this -> EvaluateBoolExpression(expression->GetRight()); auto rightValue = this->EvaluateBoolExpression(expression->GetRight());
return rightValue; return rightValue;
} }
case BoundBinaryOperation::LogicalOr: case BoundBinaryOperation::LogicalOr: {
{ auto leftValue = this->EvaluateBoolExpression(expression->GetLeft());
auto leftValue = this -> EvaluateBoolExpression(expression->GetLeft());
if (leftValue->EvaluateBool()) return leftValue; if (leftValue->EvaluateBool()) return leftValue;
auto rightValue = this -> EvaluateBoolExpression(expression->GetRight()); auto rightValue = this->EvaluateBoolExpression(expression->GetRight());
return rightValue; return rightValue;
} }
default: default:
throw EvaluationException("Can't evaluate operation to boolean"); throw EvaluationException("Can't evaluate operation to boolean");
} }
} }
const shared_ptr<StringEvalValue> Evaluator::EvaluateStringBinary(const BoundBinaryExpression *expression){ const shared_ptr<StringEvalValue> Evaluator::EvaluateStringBinary(const BoundBinaryExpression *expression) {
if (expression->GetOperation() != BoundBinaryOperation::Concatenation) if (expression->GetOperation() != BoundBinaryOperation::Concatenation)
throw; throw;
std::basic_ostringstream<char16_t > stringStream; std::basic_ostringstream<char16_t> stringStream;
auto left = this -> EvaluateStringExpression(expression->GetLeft()); auto left = this->EvaluateStringExpression(expression->GetLeft());
stringStream << *left->EvaluateString(); stringStream << *left->EvaluateString();
auto right = this -> EvaluateExpression(expression->GetRight()); auto right = this->EvaluateExpression(expression->GetRight());
stringStream << *right->EvaluateString(); stringStream << *right->EvaluateString();
return make_shared<StringEvalValue>(stringStream.str()); return make_shared<StringEvalValue>(stringStream.str());
}
} }

27
src/Evaluator/EvalValues/EvalValue.cpp
View File

@ -3,42 +3,45 @@
#include "StringEvalValue.hpp" #include "StringEvalValue.hpp"
#include <cstring> #include <cstring>
extern "C" { namespace Porygon::Evaluation {
TypeClass GetEvalValueTypeClass(EvalValue* v){
extern "C" {
Porygon::TypeClass GetEvalValueTypeClass(EvalValue *v) {
return v->GetTypeClass(); return v->GetTypeClass();
} }
int64_t EvaluateEvalValueInteger(EvalValue* v){ int64_t EvaluateEvalValueInteger(EvalValue *v) {
return v->EvaluateInteger(); return v->EvaluateInteger();
} }
double EvaluateEvalValueFloat(EvalValue* v){ double EvaluateEvalValueFloat(EvalValue *v) {
return v->EvaluateFloat(); return v->EvaluateFloat();
} }
bool EvaluateEvalValueBool(EvalValue* v){ bool EvaluateEvalValueBool(EvalValue *v) {
return v->EvaluateBool(); return v->EvaluateBool();
} }
const char16_t * EvaluateEvalValueString(EvalValue* v){ const char16_t *EvaluateEvalValueString(EvalValue *v) {
return v->EvaluateString() -> c_str(); return v->EvaluateString()->c_str();
} }
EvalValue* CreateIntegerEvalValue(long l){ EvalValue *CreateIntegerEvalValue(long l) {
return new IntegerEvalValue(l); return new IntegerEvalValue(l);
} }
EvalValue* CreateFloatEvalValue(double d){ EvalValue *CreateFloatEvalValue(double d) {
return new FloatEvalValue(d); return new FloatEvalValue(d);
} }
EvalValue* CreateBoolEvalValue(bool b){ EvalValue *CreateBoolEvalValue(bool b) {
return new BooleanEvalValue(b); return new BooleanEvalValue(b);
} }
EvalValue* CreateStringEvalValue(const char16_t * s){ EvalValue *CreateStringEvalValue(const char16_t *s) {
return new StringEvalValue(s); return new StringEvalValue(s);
} }
}
} }
#ifdef TESTS_BUILD #ifdef TESTS_BUILD
@ -47,7 +50,7 @@ extern "C" {
TEST_CASE( "Evaluate String", "[integration]" ) { TEST_CASE( "Evaluate String", "[integration]" ) {
auto script = Script::Create(u"\"foo bar\""); auto script = Porygon::Script::Create(u"\"foo bar\"");
REQUIRE(!script->Diagnostics -> HasErrors()); REQUIRE(!script->Diagnostics -> HasErrors());
script->Evaluate(); script->Evaluate();
auto lastValue = script->GetLastValue(); auto lastValue = script->GetLastValue();

54
src/Evaluator/EvalValues/EvalValue.hpp
View File

@ -8,77 +8,83 @@
#include <sstream> #include <sstream>
#include <memory> #include <memory>
class EvalValue{ namespace Porygon::Evaluation {
public: class EvalValue {
public:
EvalValue() = default; EvalValue() = default;
virtual ~EvalValue() = default; virtual ~EvalValue() = default;
virtual const TypeClass GetTypeClass() const = 0; virtual const TypeClass GetTypeClass() const = 0;
virtual const bool operator ==(EvalValue* b) const = 0; virtual const bool operator==(EvalValue *b) const = 0;
virtual const bool operator !=(EvalValue*b) const{ virtual const bool operator!=(EvalValue *b) const {
return ! (this->operator==(b)); return !(this->operator==(b));
} }
virtual const shared_ptr<EvalValue> Clone() const = 0; virtual const shared_ptr<EvalValue> Clone() const = 0;
virtual const long EvaluateInteger() const{ virtual const long EvaluateInteger() const {
throw EvaluationException("Can't evaluate this EvalValue as integer."); throw EvaluationException("Can't evaluate this EvalValue as integer.");
} }
virtual const double EvaluateFloat() const{
virtual const double EvaluateFloat() const {
throw EvaluationException("Can't evaluate this EvalValue as float."); throw EvaluationException("Can't evaluate this EvalValue as float.");
} }
virtual const bool EvaluateBool() const{
virtual const bool EvaluateBool() const {
throw EvaluationException("Can't evaluate this EvalValue as bool."); throw EvaluationException("Can't evaluate this EvalValue as bool.");
} }
virtual const std::u16string* EvaluateString() const {
virtual const std::u16string *EvaluateString() const {
throw EvaluationException("Can't evaluate this EvalValue as string."); throw EvaluationException("Can't evaluate this EvalValue as string.");
} }
virtual const std::size_t GetHashCode() const = 0; virtual const std::size_t GetHashCode() const = 0;
virtual const shared_ptr<EvalValue> IndexValue(EvalValue* val) const{ virtual const shared_ptr<EvalValue> IndexValue(EvalValue *val) const {
throw EvaluationException("Can't index this EvalValue"); throw EvaluationException("Can't index this EvalValue");
} }
virtual const shared_ptr<EvalValue> IndexValue(uint32_t hash) const{ virtual const shared_ptr<EvalValue> IndexValue(uint32_t hash) const {
throw EvaluationException("Can't index this EvalValue"); throw EvaluationException("Can't index this EvalValue");
} }
virtual void SetIndexValue(EvalValue *key, const shared_ptr<EvalValue>& value) const{ virtual void SetIndexValue(EvalValue *key, const shared_ptr<EvalValue> &value) const {
throw EvaluationException("Can't index this EvalValue"); throw EvaluationException("Can't index this EvalValue");
} }
}; };
class BooleanEvalValue : public EvalValue{ class BooleanEvalValue : public EvalValue {
const bool _value; const bool _value;
public: public:
explicit BooleanEvalValue(bool val) explicit BooleanEvalValue(bool val)
: _value(val) : _value(val) {
{
} }
const shared_ptr<EvalValue> Clone() const final{ const shared_ptr<EvalValue> Clone() const final {
return make_shared<BooleanEvalValue>(_value); return make_shared<BooleanEvalValue>(_value);
} }
const TypeClass GetTypeClass() const final{ const TypeClass GetTypeClass() const final {
return TypeClass ::Bool; return TypeClass::Bool;
} }
const bool EvaluateBool() const final{ const bool EvaluateBool() const final {
return _value; return _value;
} }
const bool operator ==(EvalValue* b) const final{ const bool operator==(EvalValue *b) const final {
if (b->GetTypeClass() != TypeClass::Bool) if (b->GetTypeClass() != TypeClass::Bool)
return false; return false;
return this->EvaluateBool() == b->EvaluateBool(); return this->EvaluateBool() == b->EvaluateBool();
}; };
const std::size_t GetHashCode() const final{ const std::size_t GetHashCode() const final {
return _value; return _value;
} }
}; };
}
#endif //PORYGONLANG_EVALVALUE_HPP #endif //PORYGONLANG_EVALVALUE_HPP

122
src/Evaluator/EvalValues/NumericEvalValue.cpp
View File

@ -1,144 +1,146 @@
#include "NumericEvalValue.hpp" #include "NumericEvalValue.hpp"
const shared_ptr<NumericEvalValue> NumericEvalValue::operator+(const shared_ptr<NumericEvalValue>& b) const { namespace Porygon::Evaluation {
if (this->IsFloat()){ const shared_ptr<NumericEvalValue> NumericEvalValue::operator+(const shared_ptr<NumericEvalValue> &b) const {
if (b->IsFloat()){ if (this->IsFloat()) {
if (b->IsFloat()) {
return make_shared<FloatEvalValue>(this->GetFloatValue() + b->GetFloatValue()); return make_shared<FloatEvalValue>(this->GetFloatValue() + b->GetFloatValue());
} else{ } else {
return make_shared<FloatEvalValue>(this->GetFloatValue() + b->GetIntegerValue()); return make_shared<FloatEvalValue>(this->GetFloatValue() + b->GetIntegerValue());
} }
} else { } else {
if (b->IsFloat()){ if (b->IsFloat()) {
return make_shared<FloatEvalValue>(this->GetIntegerValue() + b->GetFloatValue()); return make_shared<FloatEvalValue>(this->GetIntegerValue() + b->GetFloatValue());
} else{ } else {
return make_shared<IntegerEvalValue>(this->GetIntegerValue() + b->GetIntegerValue()); return make_shared<IntegerEvalValue>(this->GetIntegerValue() + b->GetIntegerValue());
} }
} }
} }
const shared_ptr<NumericEvalValue> NumericEvalValue::operator-(const shared_ptr<NumericEvalValue>& b) const { const shared_ptr<NumericEvalValue> NumericEvalValue::operator-(const shared_ptr<NumericEvalValue> &b) const {
if (this->IsFloat()){ if (this->IsFloat()) {
if (b->IsFloat()){ if (b->IsFloat()) {
return make_shared<FloatEvalValue>(this->GetFloatValue() - b->GetFloatValue()); return make_shared<FloatEvalValue>(this->GetFloatValue() - b->GetFloatValue());
} else{ } else {
return make_shared<FloatEvalValue>(this->GetFloatValue() - b->GetIntegerValue()); return make_shared<FloatEvalValue>(this->GetFloatValue() - b->GetIntegerValue());
} }
} else { } else {
if (b->IsFloat()){ if (b->IsFloat()) {
return make_shared<FloatEvalValue>(this->GetIntegerValue() - b->GetFloatValue()); return make_shared<FloatEvalValue>(this->GetIntegerValue() - b->GetFloatValue());
} else{ } else {
return make_shared<IntegerEvalValue>(this->GetIntegerValue() - b->GetIntegerValue()); return make_shared<IntegerEvalValue>(this->GetIntegerValue() - b->GetIntegerValue());
} }
} }
} }
const shared_ptr<NumericEvalValue> NumericEvalValue::operator*(const shared_ptr<NumericEvalValue>& b) const { const shared_ptr<NumericEvalValue> NumericEvalValue::operator*(const shared_ptr<NumericEvalValue> &b) const {
if (this->IsFloat()){ if (this->IsFloat()) {
if (b->IsFloat()){ if (b->IsFloat()) {
return make_shared<FloatEvalValue>(this->GetFloatValue() * b->GetFloatValue()); return make_shared<FloatEvalValue>(this->GetFloatValue() * b->GetFloatValue());
} else{ } else {
return make_shared<FloatEvalValue>(this->GetFloatValue() * b->GetIntegerValue()); return make_shared<FloatEvalValue>(this->GetFloatValue() * b->GetIntegerValue());
} }
} else { } else {
if (b->IsFloat()){ if (b->IsFloat()) {
return make_shared<FloatEvalValue>(this->GetIntegerValue() * b->GetFloatValue()); return make_shared<FloatEvalValue>(this->GetIntegerValue() * b->GetFloatValue());
} else{ } else {
return make_shared<IntegerEvalValue>(this->GetIntegerValue() * b->GetIntegerValue()); return make_shared<IntegerEvalValue>(this->GetIntegerValue() * b->GetIntegerValue());
} }
} }
} }
const shared_ptr<NumericEvalValue> NumericEvalValue::operator/(const shared_ptr<NumericEvalValue>& b) const { const shared_ptr<NumericEvalValue> NumericEvalValue::operator/(const shared_ptr<NumericEvalValue> &b) const {
if (this->IsFloat()){ if (this->IsFloat()) {
if (b->IsFloat()){ if (b->IsFloat()) {
return make_shared<FloatEvalValue>(this->GetFloatValue() / b->GetFloatValue()); return make_shared<FloatEvalValue>(this->GetFloatValue() / b->GetFloatValue());
} else{ } else {
return make_shared<FloatEvalValue>(this->GetFloatValue() / b->GetIntegerValue()); return make_shared<FloatEvalValue>(this->GetFloatValue() / b->GetIntegerValue());
} }
} else { } else {
if (b->IsFloat()){ if (b->IsFloat()) {
return make_shared<FloatEvalValue>(this->GetIntegerValue() / b->GetFloatValue()); return make_shared<FloatEvalValue>(this->GetIntegerValue() / b->GetFloatValue());
} else{ } else {
return make_shared<IntegerEvalValue>(this->GetIntegerValue() / b->GetIntegerValue()); return make_shared<IntegerEvalValue>(this->GetIntegerValue() / b->GetIntegerValue());
} }
} }
} }
const bool NumericEvalValue::operator==(EvalValue *b) const { const bool NumericEvalValue::operator==(EvalValue *b) const {
if (b->GetTypeClass() != TypeClass::Number) if (b->GetTypeClass() != TypeClass::Number)
return false; return false;
auto numVal = (NumericEvalValue*)b; auto numVal = (NumericEvalValue *) b;
if (this->IsFloat() != numVal->IsFloat()) if (this->IsFloat() != numVal->IsFloat())
return false; return false;
if (this->IsFloat()){ if (this->IsFloat()) {
return this->EvaluateFloat() == numVal->EvaluateFloat(); return this->EvaluateFloat() == numVal->EvaluateFloat();
} else{ } else {
return this->EvaluateInteger() == numVal->EvaluateInteger(); return this->EvaluateInteger() == numVal->EvaluateInteger();
} }
} }
const shared_ptr<BooleanEvalValue> NumericEvalValue::operator<(const shared_ptr<NumericEvalValue>& b) const { const shared_ptr<BooleanEvalValue> NumericEvalValue::operator<(const shared_ptr<NumericEvalValue> &b) const {
if (this->IsFloat()){ if (this->IsFloat()) {
if (b->IsFloat()){ if (b->IsFloat()) {
return make_shared<BooleanEvalValue>(this->GetFloatValue() < b->GetFloatValue()); return make_shared<BooleanEvalValue>(this->GetFloatValue() < b->GetFloatValue());
} else{ } else {
return make_shared<BooleanEvalValue>(this->GetFloatValue() < b->GetIntegerValue()); return make_shared<BooleanEvalValue>(this->GetFloatValue() < b->GetIntegerValue());
} }
} else { } else {
if (b->IsFloat()){ if (b->IsFloat()) {
return make_shared<BooleanEvalValue>(this->GetIntegerValue() < b->GetFloatValue()); return make_shared<BooleanEvalValue>(this->GetIntegerValue() < b->GetFloatValue());
} else{ } else {
return make_shared<BooleanEvalValue>(this->GetIntegerValue() < b->GetIntegerValue()); return make_shared<BooleanEvalValue>(this->GetIntegerValue() < b->GetIntegerValue());
} }
} }
} }
const shared_ptr<BooleanEvalValue> NumericEvalValue::operator<=(const shared_ptr<NumericEvalValue>& b) const { const shared_ptr<BooleanEvalValue> NumericEvalValue::operator<=(const shared_ptr<NumericEvalValue> &b) const {
if (this->IsFloat()){ if (this->IsFloat()) {
if (b->IsFloat()){ if (b->IsFloat()) {
return make_shared<BooleanEvalValue>(this->GetFloatValue() <= b->GetFloatValue()); return make_shared<BooleanEvalValue>(this->GetFloatValue() <= b->GetFloatValue());
} else{ } else {
return make_shared<BooleanEvalValue>(this->GetFloatValue() <= b->GetIntegerValue()); return make_shared<BooleanEvalValue>(this->GetFloatValue() <= b->GetIntegerValue());
} }
} else { } else {
if (b->IsFloat()){ if (b->IsFloat()) {
return make_shared<BooleanEvalValue>(this->GetIntegerValue() <= b->GetFloatValue()); return make_shared<BooleanEvalValue>(this->GetIntegerValue() <= b->GetFloatValue());
} else{ } else {
return make_shared<BooleanEvalValue>(this->GetIntegerValue() <= b->GetIntegerValue()); return make_shared<BooleanEvalValue>(this->GetIntegerValue() <= b->GetIntegerValue());
} }
} }
} }
const shared_ptr<BooleanEvalValue> NumericEvalValue::operator>(const shared_ptr<NumericEvalValue>& b) const { const shared_ptr<BooleanEvalValue> NumericEvalValue::operator>(const shared_ptr<NumericEvalValue> &b) const {
if (this->IsFloat()){ if (this->IsFloat()) {
if (b->IsFloat()){ if (b->IsFloat()) {
return make_shared<BooleanEvalValue>(this->GetFloatValue() > b->GetFloatValue()); return make_shared<BooleanEvalValue>(this->GetFloatValue() > b->GetFloatValue());
} else{ } else {
return make_shared<BooleanEvalValue>(this->GetFloatValue() > b->GetIntegerValue()); return make_shared<BooleanEvalValue>(this->GetFloatValue() > b->GetIntegerValue());
} }
} else { } else {
if (b->IsFloat()){ if (b->IsFloat()) {
return make_shared<BooleanEvalValue>(this->GetIntegerValue() > b->GetFloatValue()); return make_shared<BooleanEvalValue>(this->GetIntegerValue() > b->GetFloatValue());
} else{ } else {
return make_shared<BooleanEvalValue>(this->GetIntegerValue() > b->GetIntegerValue()); return make_shared<BooleanEvalValue>(this->GetIntegerValue() > b->GetIntegerValue());
} }
} }
} }
const shared_ptr<BooleanEvalValue> NumericEvalValue::operator>=(const shared_ptr<NumericEvalValue>& b) const { const shared_ptr<BooleanEvalValue> NumericEvalValue::operator>=(const shared_ptr<NumericEvalValue> &b) const {
if (this->IsFloat()){ if (this->IsFloat()) {
if (b->IsFloat()){ if (b->IsFloat()) {
return make_shared<BooleanEvalValue>(this->GetFloatValue() >= b->GetFloatValue()); return make_shared<BooleanEvalValue>(this->GetFloatValue() >= b->GetFloatValue());
} else{ } else {
return make_shared<BooleanEvalValue>(this->GetFloatValue() >= b->GetIntegerValue()); return make_shared<BooleanEvalValue>(this->GetFloatValue() >= b->GetIntegerValue());
} }
} else { } else {
if (b->IsFloat()){ if (b->IsFloat()) {
return make_shared<BooleanEvalValue>(this->GetIntegerValue() >= b->GetFloatValue()); return make_shared<BooleanEvalValue>(this->GetIntegerValue() >= b->GetFloatValue());
} else{ } else {
return make_shared<BooleanEvalValue>(this->GetIntegerValue() >= b->GetIntegerValue()); return make_shared<BooleanEvalValue>(this->GetIntegerValue() >= b->GetIntegerValue());
} }
} }
}
} }

94
src/Evaluator/EvalValues/NumericEvalValue.hpp
View File

@ -4,76 +4,98 @@
#include <sstream> #include <sstream>
#include "EvalValue.hpp" #include "EvalValue.hpp"
namespace Porygon::Evaluation {
class NumericEvalValue : public EvalValue{ class NumericEvalValue : public EvalValue {
virtual const long GetIntegerValue() const = 0; virtual const long GetIntegerValue() const = 0;
virtual const double GetFloatValue() const = 0; virtual const double GetFloatValue() const = 0;
public: public:
virtual const bool IsFloat() const = 0; virtual const bool IsFloat() const = 0;
const TypeClass GetTypeClass() const final{ const TypeClass GetTypeClass() const final {
return TypeClass ::Number; return TypeClass::Number;
} }
const shared_ptr<NumericEvalValue> operator +(const shared_ptr<NumericEvalValue>& b) const; const shared_ptr<NumericEvalValue> operator+(const shared_ptr<NumericEvalValue> &b) const;
const shared_ptr<NumericEvalValue> operator -(const shared_ptr<NumericEvalValue>& b) const ;
const shared_ptr<NumericEvalValue> operator *(const shared_ptr<NumericEvalValue>& b) const ;
const shared_ptr<NumericEvalValue> operator /(const shared_ptr<NumericEvalValue>& b) const ;
const shared_ptr<BooleanEvalValue> operator <(const shared_ptr<NumericEvalValue>& b) const ;
const shared_ptr<BooleanEvalValue> operator <=(const shared_ptr<NumericEvalValue>& b)const ;
const shared_ptr<BooleanEvalValue> operator >(const shared_ptr<NumericEvalValue>& b) const ;
const shared_ptr<BooleanEvalValue> operator >=(const shared_ptr<NumericEvalValue>& b) const ;
const bool operator ==(EvalValue* b) const final;
};
class IntegerEvalValue : public NumericEvalValue{ const shared_ptr<NumericEvalValue> operator-(const shared_ptr<NumericEvalValue> &b) const;
const shared_ptr<NumericEvalValue> operator*(const shared_ptr<NumericEvalValue> &b) const;
const shared_ptr<NumericEvalValue> operator/(const shared_ptr<NumericEvalValue> &b) const;
const shared_ptr<BooleanEvalValue> operator<(const shared_ptr<NumericEvalValue> &b) const;
const shared_ptr<BooleanEvalValue> operator<=(const shared_ptr<NumericEvalValue> &b) const;
const shared_ptr<BooleanEvalValue> operator>(const shared_ptr<NumericEvalValue> &b) const;
const shared_ptr<BooleanEvalValue> operator>=(const shared_ptr<NumericEvalValue> &b) const;
const bool operator==(EvalValue *b) const final;
};
class IntegerEvalValue : public NumericEvalValue {
const long _value; const long _value;
const long GetIntegerValue() const final{return _value;}
const double GetFloatValue() const final{ throw EvaluationException("Attempting to retrieve float from int eval value."); } const long GetIntegerValue() const final { return _value; }
public:
explicit IntegerEvalValue(long value) :_value(value){ const double GetFloatValue() const final {
throw EvaluationException("Attempting to retrieve float from int eval value.");
} }
const bool IsFloat() const final{
public:
explicit IntegerEvalValue(long value) : _value(value) {
}
const bool IsFloat() const final {
return false; return false;
} }
const long EvaluateInteger() const final{ const long EvaluateInteger() const final {
return _value; return _value;
} }
const shared_ptr<EvalValue> Clone() const final{ const shared_ptr<EvalValue> Clone() const final {
return make_shared<IntegerEvalValue>(_value); return make_shared<IntegerEvalValue>(_value);
} }
const std::size_t GetHashCode() const final{ const std::size_t GetHashCode() const final {
return std::hash<long>{}(_value); return std::hash<long>{}(_value);
} }
}; };
class FloatEvalValue : public NumericEvalValue{ class FloatEvalValue : public NumericEvalValue {
const double _value; const double _value;
const long GetIntegerValue() const final{ throw EvaluationException("Attempting to retrieve float from int eval value."); }
const double GetFloatValue() const final{return _value;} const long GetIntegerValue() const final {
public: throw EvaluationException("Attempting to retrieve float from int eval value.");
explicit FloatEvalValue(double value) :_value(value){
} }
const bool IsFloat() const final{
const double GetFloatValue() const final { return _value; }
public:
explicit FloatEvalValue(double value) : _value(value) {
}
const bool IsFloat() const final {
return true; return true;
} }
const double EvaluateFloat() const final{ const double EvaluateFloat() const final {
return _value; return _value;
} }
const shared_ptr<EvalValue> Clone() const final{ const shared_ptr<EvalValue> Clone() const final {
return make_shared<FloatEvalValue>(_value); return make_shared<FloatEvalValue>(_value);
} }
const std::size_t GetHashCode() const final{ const std::size_t GetHashCode() const final {
return std::hash<double >{}(_value); return std::hash<double>{}(_value);
} }
}; };
}
#endif //PORYGONLANG_NUMERICEVALVALUE_HPP #endif //PORYGONLANG_NUMERICEVALVALUE_HPP

40
src/Evaluator/EvalValues/ScriptFunctionEvalValue.hpp
View File

@ -11,63 +11,65 @@
#include "../Evaluator.hpp" #include "../Evaluator.hpp"
#include "../EvaluationScope/EvaluationScope.hpp" #include "../EvaluationScope/EvaluationScope.hpp"
namespace Porygon::Evaluation {
class ScriptFunctionEvalValue : public EvalValue{ class ScriptFunctionEvalValue : public EvalValue {
const std::shared_ptr<BoundBlockStatement> _innerBlock; const std::shared_ptr<BoundBlockStatement> _innerBlock;
const std::shared_ptr<FunctionScriptType> _type; const std::shared_ptr<FunctionScriptType> _type;
const std::shared_ptr<EvaluationScope> _scope; const std::shared_ptr<EvaluationScope> _scope;
const std::size_t _hash; const std::size_t _hash;
explicit ScriptFunctionEvalValue(std::shared_ptr<BoundBlockStatement> innerBlock, std::shared_ptr<EvaluationScope> scope,
explicit ScriptFunctionEvalValue(std::shared_ptr<BoundBlockStatement> innerBlock,
std::shared_ptr<EvaluationScope> scope,
std::shared_ptr<FunctionScriptType> type, size_t hash) std::shared_ptr<FunctionScriptType> type, size_t hash)
: _type(std::move(type)), : _type(std::move(type)),
_innerBlock(std::move(innerBlock)), _innerBlock(std::move(innerBlock)),
_scope(std::move(scope)), _scope(std::move(scope)),
_hash(hash) _hash(hash) {
{
} }
public: public:
explicit ScriptFunctionEvalValue(std::shared_ptr<BoundBlockStatement> innerBlock, std::shared_ptr<EvaluationScope> scope, explicit ScriptFunctionEvalValue(std::shared_ptr<BoundBlockStatement> innerBlock,
std::shared_ptr<EvaluationScope> scope,
std::shared_ptr<FunctionScriptType> type) std::shared_ptr<FunctionScriptType> type)
: _type(std::move(type)), : _type(std::move(type)),
_innerBlock(std::move(innerBlock)), _innerBlock(std::move(innerBlock)),
_scope(std::move(scope)), _scope(std::move(scope)),
_hash(rand()) _hash(rand()) {
{
} }
const std::shared_ptr<ScriptType> GetType() const{ const std::shared_ptr<ScriptType> GetType() const {
return _type; return _type;
} }
const TypeClass GetTypeClass() const final{ const TypeClass GetTypeClass() const final {
return TypeClass ::Function; return TypeClass::Function;
} }
const shared_ptr<EvalValue> Clone() const final{ const shared_ptr<EvalValue> Clone() const final {
// We don't run make_shared here as it can't call private constructors // We don't run make_shared here as it can't call private constructors
return shared_ptr<ScriptFunctionEvalValue>(new ScriptFunctionEvalValue(_innerBlock, _scope, _type, _hash)); return shared_ptr<ScriptFunctionEvalValue>(new ScriptFunctionEvalValue(_innerBlock, _scope, _type, _hash));
} }
const bool operator ==(EvalValue* b) const final{ const bool operator==(EvalValue *b) const final {
if (b->GetTypeClass() != TypeClass::Function) if (b->GetTypeClass() != TypeClass::Function)
return false; return false;
return this->_hash == ((ScriptFunctionEvalValue*)b)->_hash; return this->_hash == ((ScriptFunctionEvalValue *) b)->_hash;
}; };
const std::shared_ptr<BoundBlockStatement>& GetInnerBlock() const{ const std::shared_ptr<BoundBlockStatement> &GetInnerBlock() const {
return _innerBlock; return _innerBlock;
} }
const std::size_t GetHashCode() const final{ const std::size_t GetHashCode() const final {
return _hash; return _hash;
} }
const std::shared_ptr<EvaluationScope>& GetScope() const{ const std::shared_ptr<EvaluationScope> &GetScope() const {
return _scope; return _scope;
} }
}; };
}
#endif //PORYGONLANG_SCRIPTFUNCTIONEVALVALUE_HPP #endif //PORYGONLANG_SCRIPTFUNCTIONEVALVALUE_HPP

27
src/Evaluator/EvalValues/StringEvalValue.hpp
View File

@ -8,43 +8,44 @@
using namespace std; using namespace std;
class StringEvalValue : public EvalValue{ namespace Porygon::Evaluation {
class StringEvalValue : public EvalValue {
u16string _value; u16string _value;
size_t _hash; size_t _hash;
public: public:
explicit StringEvalValue(u16string s){ explicit StringEvalValue(u16string s) {
_value = move(s); _value = move(s);
_hash = HashedString::ConstHash (_value.c_str()); _hash = Utilities::HashedString::ConstHash(_value.c_str());
} }
const TypeClass GetTypeClass() const final{ const TypeClass GetTypeClass() const final {
return TypeClass ::String; return TypeClass::String;
} }
const bool operator ==(EvalValue* b) const final{ const bool operator==(EvalValue *b) const final {
if (b->GetTypeClass() != TypeClass::String) if (b->GetTypeClass() != TypeClass::String)
return false; return false;
return this->_hash == b->GetHashCode(); return this->_hash == b->GetHashCode();
}; };
const u16string* EvaluateString() const final{ const u16string *EvaluateString() const final {
return &_value; return &_value;
} }
const shared_ptr<EvalValue> Clone() const final{ const shared_ptr<EvalValue> Clone() const final {
return make_shared<StringEvalValue>(_value); return make_shared<StringEvalValue>(_value);
} }
const shared_ptr<EvalValue> IndexValue(EvalValue* val) const final{ const shared_ptr<EvalValue> IndexValue(EvalValue *val) const final {
// Porygon is 1-indexed, so we convert to that. // Porygon is 1-indexed, so we convert to that.
auto l = val->EvaluateInteger() - 1; auto l = val->EvaluateInteger() - 1;
return make_shared<StringEvalValue>(u16string(1, _value[l])); return make_shared<StringEvalValue>(u16string(1, _value[l]));
} }
const std::size_t GetHashCode() const final{ const std::size_t GetHashCode() const final {
return _hash; return _hash;
} }
}; };
}
#endif //PORYGONLANG_STRINGEVALVALUE_HPP #endif //PORYGONLANG_STRINGEVALVALUE_HPP

44
src/Evaluator/EvalValues/TableEvalValue.hpp
View File

@ -6,55 +6,57 @@
using namespace std; using namespace std;
class TableEvalValue : public EvalValue { namespace Porygon::Evaluation {
class TableEvalValue : public EvalValue {
shared_ptr<unordered_map<uint32_t, shared_ptr<EvalValue>>> _table; shared_ptr<unordered_map<uint32_t, shared_ptr<EvalValue>>> _table;
size_t _hash; size_t _hash;
explicit TableEvalValue(shared_ptr<unordered_map<uint32_t, shared_ptr<EvalValue>>> table, size_t hash){ explicit TableEvalValue(shared_ptr<unordered_map<uint32_t, shared_ptr<EvalValue>>> table, size_t hash) {
_table = std::move(table); _table = std::move(table);
_hash = hash; _hash = hash;
} }
public:
explicit TableEvalValue(shared_ptr<unordered_map<uint32_t, shared_ptr<EvalValue>>> table){ public:
explicit TableEvalValue(shared_ptr<unordered_map<uint32_t, shared_ptr<EvalValue>>> table) {
_table = std::move(table); _table = std::move(table);
_hash = rand(); _hash = rand();
} }
const TypeClass GetTypeClass() const final{ const TypeClass GetTypeClass() const final {
return TypeClass ::Table; return TypeClass::Table;
} }
const size_t GetHashCode() const final{ const size_t GetHashCode() const final {
return _hash; return _hash;
} }
const bool operator ==(EvalValue* b) const final{ const bool operator==(EvalValue *b) const final {
return this -> _hash == b->GetHashCode(); return this->_hash == b->GetHashCode();
} }
const shared_ptr<EvalValue> Clone() const final{ const shared_ptr<EvalValue> Clone() const final {
return shared_ptr<EvalValue>(new TableEvalValue(_table, _hash)); return shared_ptr<EvalValue>(new TableEvalValue(_table, _hash));
} }
const shared_ptr<EvalValue> IndexValue(EvalValue* val) const final{ const shared_ptr<EvalValue> IndexValue(EvalValue *val) const final {
auto hash = val->GetHashCode(); auto hash = val->GetHashCode();
return this -> _table->at(hash); return this->_table->at(hash);
} }
const shared_ptr<EvalValue> IndexValue(uint32_t hash) const final{ const shared_ptr<EvalValue> IndexValue(uint32_t hash) const final {
return this -> _table->at(hash); return this->_table->at(hash);
} }
const shared_ptr<EvalValue> IndexValue(const char* val) const { const shared_ptr<EvalValue> IndexValue(const char *val) const {
auto hash = HashedString::ConstHash(val); auto hash = Utilities::HashedString::ConstHash(val);
return this -> _table -> at(hash); return this->_table->at(hash);
} }
void SetIndexValue(EvalValue *key, const shared_ptr<EvalValue>& value) const final{ void SetIndexValue(EvalValue *key, const shared_ptr<EvalValue> &value) const final {
auto hash = key->GetHashCode(); auto hash = key->GetHashCode();
this -> _table->at(hash) = value; this->_table->at(hash) = value;
} }
}; };
}
#endif //PORYGONLANG_TABLEEVALVALUE_HPP #endif //PORYGONLANG_TABLEEVALVALUE_HPP

14
src/Evaluator/EvaluationException.hpp
View File

@ -7,18 +7,20 @@
#include <string> #include <string>
using namespace std; using namespace std;
class EvaluationException : public std::exception { namespace Porygon::Evaluation {
class EvaluationException : public std::exception {
string _message; string _message;
public: public:
explicit EvaluationException(string message){ explicit EvaluationException(string message) {
_message = std::move(message); _message = std::move(message);
} }
const string defaultErrorText = "An evaluation exception occurred: "; const string defaultErrorText = "An evaluation exception occurred: ";
const char* what() const noexcept final{
const char *what() const noexcept final {
return (defaultErrorText + _message).c_str(); return (defaultErrorText + _message).c_str();
} }
}; };
}
#endif //PORYGONLANG_EVALUATIONEXCEPTION_HPP #endif //PORYGONLANG_EVALUATIONEXCEPTION_HPP

37
src/Evaluator/EvaluationScope/EvaluationScope.cpp
View File

@ -2,34 +2,37 @@
#include "EvaluationScope.hpp" #include "EvaluationScope.hpp"
#include <memory> #include <memory>
EvaluationScope::EvaluationScope(unordered_map<uint32_t, shared_ptr<EvalValue>> *scriptVariables, int localVariableCount) { namespace Porygon::Evaluation {
EvaluationScope::EvaluationScope(unordered_map<uint32_t, shared_ptr<EvalValue>> *scriptVariables,
int localVariableCount) {
_scriptScope = scriptVariables; _scriptScope = scriptVariables;
_localScope = unordered_map<uint64_t, shared_ptr<EvalValue>>(localVariableCount); _localScope = unordered_map<uint64_t, shared_ptr<EvalValue>>(localVariableCount);
} }
void EvaluationScope::CreateVariable(const BoundVariableKey* key, const shared_ptr<EvalValue> &value) { void EvaluationScope::CreateVariable(const BoundVariableKey *key, const shared_ptr<EvalValue> &value) {
if (key->GetScopeId() == 0){ if (key->GetScopeId() == 0) {
_scriptScope -> at(key->GetIdentifier()) = value; _scriptScope->at(key->GetIdentifier()) = value;
} else{ } else {
auto insert = _localScope.insert({key->GetHash(), value}); auto insert = _localScope.insert({key->GetHash(), value});
if (!insert.second){ if (!insert.second) {
_localScope[key->GetHash()] = value; _localScope[key->GetHash()] = value;
} }
} }
} }
void EvaluationScope::SetVariable(const BoundVariableKey* key, const shared_ptr<EvalValue> &value) { void EvaluationScope::SetVariable(const BoundVariableKey *key, const shared_ptr<EvalValue> &value) {
if (key->GetScopeId() == 0){ if (key->GetScopeId() == 0) {
_scriptScope -> at(key->GetIdentifier()) = value; _scriptScope->at(key->GetIdentifier()) = value;
} else{ } else {
_localScope[key->GetHash()] = value; _localScope[key->GetHash()] = value;
} }
} }
shared_ptr<EvalValue> EvaluationScope::GetVariable(const BoundVariableKey* key) { shared_ptr<EvalValue> EvaluationScope::GetVariable(const BoundVariableKey *key) {
if (key->GetScopeId() == 0){ if (key->GetScopeId() == 0) {
return _scriptScope -> at(key->GetIdentifier()); return _scriptScope->at(key->GetIdentifier());
} else{ } else {
return _localScope[key->GetHash()]; return _localScope[key->GetHash()];
} }
}
} }

22
src/Evaluator/EvaluationScope/EvaluationScope.hpp
View File

@ -5,18 +5,24 @@
#include <unordered_map> #include <unordered_map>
#include <vector> #include <vector>
#include "../EvalValues/EvalValue.hpp" #include "../EvalValues/EvalValue.hpp"
using namespace Porygon::Binder;
class EvaluationScope { namespace Porygon::Evaluation {
unordered_map<uint32_t, shared_ptr<EvalValue>>* _scriptScope; class EvaluationScope {
unordered_map<uint32_t, shared_ptr<EvalValue>> *_scriptScope;
unordered_map<uint64_t, shared_ptr<EvalValue>> _localScope; unordered_map<uint64_t, shared_ptr<EvalValue>> _localScope;
public: public:
explicit EvaluationScope(unordered_map<uint32_t, shared_ptr<EvalValue>>* scriptVariables, int deepestScope); explicit EvaluationScope(unordered_map<uint32_t, shared_ptr<EvalValue>> *scriptVariables, int deepestScope);
~EvaluationScope() = default; ~EvaluationScope() = default;
void CreateVariable(const BoundVariableKey* key, const shared_ptr<EvalValue>& value); void CreateVariable(const BoundVariableKey *key, const shared_ptr<EvalValue> &value);
void SetVariable(const BoundVariableKey* key, const shared_ptr<EvalValue>& value);
shared_ptr<EvalValue> GetVariable(const BoundVariableKey* key); void SetVariable(const BoundVariableKey *key, const shared_ptr<EvalValue> &value);
};
shared_ptr<EvalValue> GetVariable(const BoundVariableKey *key);
};
}
#endif //PORYGONLANG_EVALUATIONSCOPE_HPP #endif //PORYGONLANG_EVALUATIONSCOPE_HPP

388
src/Evaluator/Evaluator.cpp
View File

@ -11,150 +11,185 @@
#include "../TableScriptType.hpp" #include "../TableScriptType.hpp"
using namespace std; using namespace std;
using namespace Porygon::Binder;
EvalValue* Evaluator::Evaluate(const BoundScriptStatement *statement) { namespace Porygon::Evaluation {
this->_evaluationScope = make_shared<EvaluationScope>(this->_scriptData->_scriptVariables, statement->GetLocalVariableCount()); EvalValue *Evaluator::Evaluate(const BoundScriptStatement *statement) {
this->_evaluationScope = make_shared<EvaluationScope>(this->_scriptVariables,
statement->GetLocalVariableCount());
EvaluateBlockStatement(statement); EvaluateBlockStatement(statement);
return this -> _returnValue.get(); return this->_returnValue.get();
} }
void Evaluator::EvaluateStatement(const BoundStatement *statement) { void Evaluator::EvaluateStatement(const BoundStatement *statement) {
if (this->_hasReturned) if (this->_hasReturned)
return; return;
switch (statement->GetKind()){ switch (statement->GetKind()) {
case BoundStatementKind ::Script: throw; // Should never happen case BoundStatementKind::Script:
case BoundStatementKind ::Block: return this->EvaluateBlockStatement((BoundBlockStatement *) statement); throw; // Should never happen
case BoundStatementKind ::Expression: return this -> EvaluateExpressionStatement((BoundExpressionStatement*)statement); case BoundStatementKind::Block:
case BoundStatementKind ::Assignment: return this -> EvaluateAssignmentStatement((BoundAssignmentStatement*)statement); return this->EvaluateBlockStatement((BoundBlockStatement *) statement);
case BoundStatementKind::Expression:
return this->EvaluateExpressionStatement((BoundExpressionStatement *) statement);
case BoundStatementKind::Assignment:
return this->EvaluateAssignmentStatement((BoundAssignmentStatement *) statement);
case BoundStatementKind::IndexAssignment: case BoundStatementKind::IndexAssignment:
return this -> EvaluateIndexAssignmentStatement((BoundIndexAssignmentStatement*)statement); return this->EvaluateIndexAssignmentStatement((BoundIndexAssignmentStatement *) statement);
case BoundStatementKind ::FunctionDeclaration: return this->EvaluateFunctionDeclarationStatement((BoundFunctionDeclarationStatement*)statement); case BoundStatementKind::FunctionDeclaration:
case BoundStatementKind::Return: return this -> EvaluateReturnStatement((BoundReturnStatement*)statement); return this->EvaluateFunctionDeclarationStatement((BoundFunctionDeclarationStatement *) statement);
case BoundStatementKind::Conditional: return this -> EvaluateConditionalStatement((BoundConditionalStatement*)statement); case BoundStatementKind::Return:
return this->EvaluateReturnStatement((BoundReturnStatement *) statement);
case BoundStatementKind::Conditional:
return this->EvaluateConditionalStatement((BoundConditionalStatement *) statement);
case BoundStatementKind::Bad: case BoundStatementKind::Bad:
throw; throw;
} }
} }
void Evaluator::EvaluateBlockStatement(const BoundBlockStatement *statement) { void Evaluator::EvaluateBlockStatement(const BoundBlockStatement *statement) {
for (auto s: *statement->GetStatements()){ for (auto s: *statement->GetStatements()) {
this -> EvaluateStatement(s); this->EvaluateStatement(s);
if (this->_hasReturned) if (this->_hasReturned)
break; break;
} }
} }
void Evaluator::EvaluateExpressionStatement(const BoundExpressionStatement *statement) { void Evaluator::EvaluateExpressionStatement(const BoundExpressionStatement *statement) {
// Save new value // Save new value
this->_lastValue = this -> EvaluateExpression(statement->GetExpression()); this->_lastValue = this->EvaluateExpression(statement->GetExpression());
} }
void Evaluator::EvaluateAssignmentStatement(const BoundAssignmentStatement *statement) { void Evaluator::EvaluateAssignmentStatement(const BoundAssignmentStatement *statement) {
auto value = this -> EvaluateExpression(statement->GetExpression()); auto value = this->EvaluateExpression(statement->GetExpression());
auto key = statement->GetKey(); auto key = statement->GetKey();
if (key->IsCreation()){ if (key->IsCreation()) {
this->_evaluationScope->CreateVariable(key, value); this->_evaluationScope->CreateVariable(key, value);
} else{ } else {
this->_evaluationScope->SetVariable(key, value); this->_evaluationScope->SetVariable(key, value);
} }
} }
void Evaluator::EvaluateIndexAssignmentStatement(const BoundIndexAssignmentStatement *statement) { void Evaluator::EvaluateIndexAssignmentStatement(const BoundIndexAssignmentStatement *statement) {
auto indexExpression = statement -> GetIndexExpression(); auto indexExpression = statement->GetIndexExpression();
auto value = this -> EvaluateExpression(statement -> GetValueExpression()); auto value = this->EvaluateExpression(statement->GetValueExpression());
auto index = ((BoundIndexExpression*)indexExpression); auto index = ((BoundIndexExpression *) indexExpression);
auto table = this -> EvaluateExpression(index -> GetIndexableExpression()); auto table = this->EvaluateExpression(index->GetIndexableExpression());
auto key = this -> EvaluateExpression(index->GetIndexExpression()); auto key = this->EvaluateExpression(index->GetIndexExpression());
table -> SetIndexValue(key.get(), value); table->SetIndexValue(key.get(), value);
} }
void Evaluator::EvaluateFunctionDeclarationStatement(const BoundFunctionDeclarationStatement *statement) { void Evaluator::EvaluateFunctionDeclarationStatement(const BoundFunctionDeclarationStatement *statement) {
auto type = statement->GetType(); auto type = statement->GetType();
auto key = statement->GetKey(); auto key = statement->GetKey();
auto block = statement->GetBlock(); auto block = statement->GetBlock();
auto value = make_shared<ScriptFunctionEvalValue>(block, this->_evaluationScope, type); auto value = make_shared<ScriptFunctionEvalValue>(block, this->_evaluationScope, type);
if (key->IsCreation()){ if (key->IsCreation()) {
this->_evaluationScope->CreateVariable(key, value); this->_evaluationScope->CreateVariable(key, value);
} else{ } else {
this->_evaluationScope->SetVariable(key, value); this->_evaluationScope->SetVariable(key, value);
} }
} }
void Evaluator::EvaluateReturnStatement(const BoundReturnStatement* statement){ void Evaluator::EvaluateReturnStatement(const BoundReturnStatement *statement) {
auto expression = statement->GetExpression(); auto expression = statement->GetExpression();
if (expression == nullptr){ if (expression == nullptr) {
this->_hasReturned = true; this->_hasReturned = true;
return; return;
} }
auto value = this -> EvaluateExpression(expression); auto value = this->EvaluateExpression(expression);
this->_hasReturned = true; this->_hasReturned = true;
this -> _returnValue = value; this->_returnValue = value;
} }
void Evaluator::EvaluateConditionalStatement(const BoundConditionalStatement *statement) { void Evaluator::EvaluateConditionalStatement(const BoundConditionalStatement *statement) {
auto condition = statement->GetCondition(); auto condition = statement->GetCondition();
if (EvaluateBoolExpression(condition) -> EvaluateBool()){ if (EvaluateBoolExpression(condition)->EvaluateBool()) {
this -> EvaluateStatement(statement->GetBlock()); this->EvaluateStatement(statement->GetBlock());
} else{ } else {
auto elseStatement = statement -> GetElseStatement(); auto elseStatement = statement->GetElseStatement();
if (elseStatement != nullptr){ if (elseStatement != nullptr) {
this->EvaluateStatement(elseStatement); this->EvaluateStatement(elseStatement);
} }
} }
}
const shared_ptr<EvalValue> Evaluator::EvaluateExpression(const BoundExpression *expression) {
auto type = expression -> GetType();
switch (type->GetClass()){
case TypeClass ::Number: return this -> EvaluateIntegerExpression(expression);
case TypeClass ::Bool: return this -> EvaluateBoolExpression(expression);
case TypeClass ::String: return this -> EvaluateStringExpression(expression);
case TypeClass ::Function: return this->EvaluateFunctionExpression(expression);
case TypeClass ::Nil: return this->EvaluateNilExpression(expression);
case TypeClass ::Table: return this-> EvaluateTableExpression(expression);
case TypeClass ::UserData: return this -> EvaluateUserDataExpression(expression);
default: throw;
} }
}
const shared_ptr<EvalValue> Evaluator::GetVariable(const BoundVariableExpression *expression){ const shared_ptr<EvalValue> Evaluator::EvaluateExpression(const BoundExpression *expression) {
auto type = expression->GetType();
switch (type->GetClass()) {
case TypeClass::Number:
return this->EvaluateIntegerExpression(expression);
case TypeClass::Bool:
return this->EvaluateBoolExpression(expression);
case TypeClass::String:
return this->EvaluateStringExpression(expression);
case TypeClass::Function:
return this->EvaluateFunctionExpression(expression);
case TypeClass::Nil:
return this->EvaluateNilExpression(expression);
case TypeClass::Table:
return this->EvaluateTableExpression(expression);
case TypeClass::UserData:
return this->EvaluateUserDataExpression(expression);
default:
throw;
}
}
const shared_ptr<EvalValue> Evaluator::GetVariable(const BoundVariableExpression *expression) {
auto variable = this->_evaluationScope->GetVariable(expression->GetKey()); auto variable = this->_evaluationScope->GetVariable(expression->GetKey());
if (variable == nullptr){ if (variable == nullptr) {
throw EvaluationException("Variable not found"); throw EvaluationException("Variable not found");
} }
return variable->Clone(); return variable->Clone();
} }
const shared_ptr<NumericEvalValue> Evaluator::EvaluateIntegerExpression(const BoundExpression *expression) { const shared_ptr<NumericEvalValue> Evaluator::EvaluateIntegerExpression(const BoundExpression *expression) {
switch (expression->GetKind()){ switch (expression->GetKind()) {
case BoundExpressionKind ::LiteralInteger: return make_shared<IntegerEvalValue>(((BoundLiteralIntegerExpression*)expression)->GetValue()); case BoundExpressionKind::LiteralInteger:
case BoundExpressionKind ::LiteralFloat: return make_shared<FloatEvalValue>(((BoundLiteralFloatExpression*)expression)->GetValue()); return make_shared<IntegerEvalValue>(((BoundLiteralIntegerExpression *) expression)->GetValue());
case BoundExpressionKind::Unary: return this -> EvaluateIntegerUnary((BoundUnaryExpression*)expression); case BoundExpressionKind::LiteralFloat:
case BoundExpressionKind ::Binary: return this -> EvaluateIntegerBinary((BoundBinaryExpression*)expression); return make_shared<FloatEvalValue>(((BoundLiteralFloatExpression *) expression)->GetValue());
case BoundExpressionKind::Variable: return dynamic_pointer_cast<NumericEvalValue>(this->GetVariable((BoundVariableExpression*)expression)); case BoundExpressionKind::Unary:
case BoundExpressionKind ::FunctionCall: return dynamic_pointer_cast<NumericEvalValue>(this->EvaluateFunctionCallExpression(expression)); return this->EvaluateIntegerUnary((BoundUnaryExpression *) expression);
case BoundExpressionKind ::Index: return dynamic_pointer_cast<NumericEvalValue>(this->EvaluateIndexExpression(expression)); case BoundExpressionKind::Binary:
case BoundExpressionKind ::PeriodIndex: return dynamic_pointer_cast<NumericEvalValue>(this->EvaluatePeriodIndexExpression(expression)); return this->EvaluateIntegerBinary((BoundBinaryExpression *) expression);
case BoundExpressionKind::Variable:
return dynamic_pointer_cast<NumericEvalValue>(
this->GetVariable((BoundVariableExpression *) expression));
case BoundExpressionKind::FunctionCall:
return dynamic_pointer_cast<NumericEvalValue>(this->EvaluateFunctionCallExpression(expression));
case BoundExpressionKind::Index:
return dynamic_pointer_cast<NumericEvalValue>(this->EvaluateIndexExpression(expression));
case BoundExpressionKind::PeriodIndex:
return dynamic_pointer_cast<NumericEvalValue>(this->EvaluatePeriodIndexExpression(expression));
case BoundExpressionKind ::LiteralString: case BoundExpressionKind::LiteralString:
case BoundExpressionKind ::LiteralBool: case BoundExpressionKind::LiteralBool:
case BoundExpressionKind ::Bad: case BoundExpressionKind::Bad:
case BoundExpressionKind::NumericalTable: case BoundExpressionKind::NumericalTable:
case BoundExpressionKind::Table: case BoundExpressionKind::Table:
throw; throw;
} }
} }
const shared_ptr<BooleanEvalValue> Evaluator::EvaluateBoolExpression(const BoundExpression *expression) { const shared_ptr<BooleanEvalValue> Evaluator::EvaluateBoolExpression(const BoundExpression *expression) {
switch (expression->GetKind()) { switch (expression->GetKind()) {
case BoundExpressionKind ::LiteralBool: return make_shared<BooleanEvalValue>(((BoundLiteralBoolExpression*)expression)->GetValue()); case BoundExpressionKind::LiteralBool:
case BoundExpressionKind::Unary: return this -> EvaluateBooleanUnary((BoundUnaryExpression*)expression); return make_shared<BooleanEvalValue>(((BoundLiteralBoolExpression *) expression)->GetValue());
case BoundExpressionKind::Binary: return this -> EvaluateBooleanBinary((BoundBinaryExpression*)expression); case BoundExpressionKind::Unary:
case BoundExpressionKind::Variable: return dynamic_pointer_cast<BooleanEvalValue>(this->GetVariable((BoundVariableExpression*)expression)); return this->EvaluateBooleanUnary((BoundUnaryExpression *) expression);
case BoundExpressionKind ::FunctionCall: return dynamic_pointer_cast<BooleanEvalValue>(this->EvaluateFunctionCallExpression(expression)); case BoundExpressionKind::Binary:
case BoundExpressionKind ::Index: return dynamic_pointer_cast<BooleanEvalValue>(this->EvaluateIndexExpression(expression)); return this->EvaluateBooleanBinary((BoundBinaryExpression *) expression);
case BoundExpressionKind ::PeriodIndex: return dynamic_pointer_cast<BooleanEvalValue>(this->EvaluatePeriodIndexExpression(expression)); case BoundExpressionKind::Variable:
return dynamic_pointer_cast<BooleanEvalValue>(
this->GetVariable((BoundVariableExpression *) expression));
case BoundExpressionKind::FunctionCall:
return dynamic_pointer_cast<BooleanEvalValue>(this->EvaluateFunctionCallExpression(expression));
case BoundExpressionKind::Index:
return dynamic_pointer_cast<BooleanEvalValue>(this->EvaluateIndexExpression(expression));
case BoundExpressionKind::PeriodIndex:
return dynamic_pointer_cast<BooleanEvalValue>(this->EvaluatePeriodIndexExpression(expression));
case BoundExpressionKind::Bad: case BoundExpressionKind::Bad:
case BoundExpressionKind::LiteralInteger: case BoundExpressionKind::LiteralInteger:
@ -165,18 +200,22 @@ const shared_ptr<BooleanEvalValue> Evaluator::EvaluateBoolExpression(const Bound
throw; throw;
} }
} }
const shared_ptr<StringEvalValue> Evaluator::EvaluateStringExpression(const BoundExpression *expression) { const shared_ptr<StringEvalValue> Evaluator::EvaluateStringExpression(const BoundExpression *expression) {
switch (expression->GetKind()) { switch (expression->GetKind()) {
case BoundExpressionKind ::LiteralString: case BoundExpressionKind::LiteralString:
return make_shared<StringEvalValue>(((BoundLiteralStringExpression*)expression)->GetValue()); return make_shared<StringEvalValue>(((BoundLiteralStringExpression *) expression)->GetValue());
case BoundExpressionKind::Binary: case BoundExpressionKind::Binary:
return this -> EvaluateStringBinary((BoundBinaryExpression*)expression); return this->EvaluateStringBinary((BoundBinaryExpression *) expression);
case BoundExpressionKind::Variable: return dynamic_pointer_cast<StringEvalValue>(this->GetVariable((BoundVariableExpression*)expression)); case BoundExpressionKind::Variable:
case BoundExpressionKind ::FunctionCall: return dynamic_pointer_cast<StringEvalValue>(this->EvaluateFunctionCallExpression(expression)); return dynamic_pointer_cast<StringEvalValue>(this->GetVariable((BoundVariableExpression *) expression));
case BoundExpressionKind ::Index: return dynamic_pointer_cast<StringEvalValue>(this->EvaluateIndexExpression(expression)); case BoundExpressionKind::FunctionCall:
case BoundExpressionKind ::PeriodIndex: return dynamic_pointer_cast<StringEvalValue>(this->EvaluatePeriodIndexExpression(expression)); return dynamic_pointer_cast<StringEvalValue>(this->EvaluateFunctionCallExpression(expression));
case BoundExpressionKind::Index:
return dynamic_pointer_cast<StringEvalValue>(this->EvaluateIndexExpression(expression));
case BoundExpressionKind::PeriodIndex:
return dynamic_pointer_cast<StringEvalValue>(this->EvaluatePeriodIndexExpression(expression));
case BoundExpressionKind::Bad: case BoundExpressionKind::Bad:
case BoundExpressionKind::LiteralInteger: case BoundExpressionKind::LiteralInteger:
@ -188,48 +227,58 @@ const shared_ptr<StringEvalValue> Evaluator::EvaluateStringExpression(const Boun
throw; throw;
} }
}
const shared_ptr<EvalValue> Evaluator::EvaluateFunctionExpression(const BoundExpression *expression){
switch (expression->GetKind()){
case BoundExpressionKind ::Variable: return this->GetVariable((BoundVariableExpression*)expression);
case BoundExpressionKind ::Index: return this->EvaluateIndexExpression(expression);
case BoundExpressionKind ::PeriodIndex: return this->EvaluatePeriodIndexExpression(expression);
default: throw;
} }
}
const shared_ptr<EvalValue> Evaluator::EvaluateNilExpression(const BoundExpression *expression){ const shared_ptr<EvalValue> Evaluator::EvaluateFunctionExpression(const BoundExpression *expression) {
switch (expression->GetKind()){ switch (expression->GetKind()) {
case BoundExpressionKind ::FunctionCall: case BoundExpressionKind::Variable:
return this->GetVariable((BoundVariableExpression *) expression);
case BoundExpressionKind::Index:
return this->EvaluateIndexExpression(expression);
case BoundExpressionKind::PeriodIndex:
return this->EvaluatePeriodIndexExpression(expression);
default:
throw;
}
}
const shared_ptr<EvalValue> Evaluator::EvaluateNilExpression(const BoundExpression *expression) {
switch (expression->GetKind()) {
case BoundExpressionKind::FunctionCall:
return this->EvaluateFunctionCallExpression(expression); return this->EvaluateFunctionCallExpression(expression);
default: default:
return nullptr; return nullptr;
} }
} }
const shared_ptr<EvalValue> Evaluator::EvaluateTableExpression(const BoundExpression *expression){
switch (expression->GetKind()){ const shared_ptr<EvalValue> Evaluator::EvaluateTableExpression(const BoundExpression *expression) {
case BoundExpressionKind ::FunctionCall: switch (expression->GetKind()) {
case BoundExpressionKind::FunctionCall:
return this->EvaluateFunctionCallExpression(expression); return this->EvaluateFunctionCallExpression(expression);
case BoundExpressionKind ::Variable: return this->GetVariable((BoundVariableExpression*)expression); case BoundExpressionKind::Variable:
case BoundExpressionKind ::Index: return this->EvaluateIndexExpression(expression); return this->GetVariable((BoundVariableExpression *) expression);
case BoundExpressionKind ::NumericalTable: return this-> EvaluateNumericTableExpression(expression); case BoundExpressionKind::Index:
case BoundExpressionKind ::Table: return this -> EvaluateComplexTableExpression(expression); return this->EvaluateIndexExpression(expression);
case BoundExpressionKind ::PeriodIndex: return this->EvaluatePeriodIndexExpression(expression); case BoundExpressionKind::NumericalTable:
return this->EvaluateNumericTableExpression(expression);
case BoundExpressionKind::Table:
return this->EvaluateComplexTableExpression(expression);
case BoundExpressionKind::PeriodIndex:
return this->EvaluatePeriodIndexExpression(expression);
default: default:
throw; throw;
} }
} }
const shared_ptr<EvalValue> Evaluator::EvaluateFunctionCallExpression(const BoundExpression *expression) {
auto functionCall = (BoundFunctionCallExpression *) expression;
const shared_ptr<EvalValue> Evaluator::EvaluateFunctionCallExpression(const BoundExpression *expression){ auto function = dynamic_pointer_cast<ScriptFunctionEvalValue>(
auto functionCall = (BoundFunctionCallExpression*)expression; this->EvaluateExpression(functionCall->GetFunctionExpression()));
auto function = dynamic_pointer_cast<ScriptFunctionEvalValue>(this->EvaluateExpression(functionCall->GetFunctionExpression()));
auto boundParameters = functionCall->GetParameters(); auto boundParameters = functionCall->GetParameters();
auto parameters = vector<shared_ptr<EvalValue>>(boundParameters->size()); auto parameters = vector<shared_ptr<EvalValue>>(boundParameters->size());
for (int i = 0; i < boundParameters->size(); i++){ for (int i = 0; i < boundParameters->size(); i++) {
parameters[i] = this->EvaluateExpression(boundParameters->at(i)); parameters[i] = this->EvaluateExpression(boundParameters->at(i));
} }
@ -239,7 +288,7 @@ const shared_ptr<EvalValue> Evaluator::EvaluateFunctionCallExpression(const Boun
auto originalScope = this->_evaluationScope; auto originalScope = this->_evaluationScope;
this->_evaluationScope = function->GetScope(); this->_evaluationScope = function->GetScope();
for (int i = 0; i < parameterTypes.size() && i < parameterKeys.size() && i < parameters.size(); i++){ for (int i = 0; i < parameterTypes.size() && i < parameterKeys.size() && i < parameters.size(); i++) {
auto parameter = parameters[i]; auto parameter = parameters[i];
auto key = parameterKeys.at(i); auto key = parameterKeys.at(i);
this->_evaluationScope->CreateVariable(key.get(), parameter->Clone()); this->_evaluationScope->CreateVariable(key.get(), parameter->Clone());
@ -248,12 +297,12 @@ const shared_ptr<EvalValue> Evaluator::EvaluateFunctionCallExpression(const Boun
this->_evaluationScope = originalScope; this->_evaluationScope = originalScope;
this->_hasReturned = false; this->_hasReturned = false;
auto r = this -> _returnValue; auto r = this->_returnValue;
this -> _returnValue = nullptr; this->_returnValue = nullptr;
return r; return r;
} }
const shared_ptr<EvalValue> Evaluator::EvaluateFunction(const ScriptFunctionEvalValue *function, const shared_ptr<EvalValue> Evaluator::EvaluateFunction(const ScriptFunctionEvalValue *function,
const vector<EvalValue *> &parameters) { const vector<EvalValue *> &parameters) {
auto type = std::dynamic_pointer_cast<FunctionScriptType>(function->GetType()); auto type = std::dynamic_pointer_cast<FunctionScriptType>(function->GetType());
auto parameterTypes = type->GetParameterTypes(); auto parameterTypes = type->GetParameterTypes();
@ -262,7 +311,7 @@ const shared_ptr<EvalValue> Evaluator::EvaluateFunction(const ScriptFunctionEval
auto originalScope = this->_evaluationScope; auto originalScope = this->_evaluationScope;
this->_evaluationScope = function->GetScope(); this->_evaluationScope = function->GetScope();
for (int i = 0; i < parameterTypes.size() && i < parameterKeys.size() && i < parameters.size(); i++){ for (int i = 0; i < parameterTypes.size() && i < parameterKeys.size() && i < parameters.size(); i++) {
auto parameter = parameters[i]; auto parameter = parameters[i];
auto key = parameterKeys.at(i); auto key = parameterKeys.at(i);
this->_evaluationScope->CreateVariable(key.get(), parameter->Clone()); this->_evaluationScope->CreateVariable(key.get(), parameter->Clone());
@ -270,58 +319,61 @@ const shared_ptr<EvalValue> Evaluator::EvaluateFunction(const ScriptFunctionEval
this->EvaluateBlockStatement(function->GetInnerBlock().get()); this->EvaluateBlockStatement(function->GetInnerBlock().get());
this->_evaluationScope = originalScope; this->_evaluationScope = originalScope;
this->_hasReturned = false; this->_hasReturned = false;
auto r = this -> _returnValue; auto r = this->_returnValue;
this -> _returnValue = nullptr; this->_returnValue = nullptr;
return r; return r;
} }
const shared_ptr<EvalValue> Evaluator::EvaluateIndexExpression(const BoundExpression *expression) { const shared_ptr<EvalValue> Evaluator::EvaluateIndexExpression(const BoundExpression *expression) {
auto indexExpression = (BoundIndexExpression*)expression; auto indexExpression = (BoundIndexExpression *) expression;
auto index = this -> EvaluateExpression(indexExpression->GetIndexExpression()); auto index = this->EvaluateExpression(indexExpression->GetIndexExpression());
auto indexable = this -> EvaluateExpression(indexExpression->GetIndexableExpression()); auto indexable = this->EvaluateExpression(indexExpression->GetIndexableExpression());
return indexable -> IndexValue(index.get()) -> Clone(); return indexable->IndexValue(index.get())->Clone();
} }
const shared_ptr<EvalValue> Evaluator::EvaluatePeriodIndexExpression(const BoundExpression *expression) { const shared_ptr<EvalValue> Evaluator::EvaluatePeriodIndexExpression(const BoundExpression *expression) {
auto indexExpression = (BoundPeriodIndexExpression*)expression; auto indexExpression = (BoundPeriodIndexExpression *) expression;
auto index = indexExpression -> GetIndex().GetHash(); auto index = indexExpression->GetIndex().GetHash();
auto indexable = this -> EvaluateExpression(indexExpression->GetIndexableExpression()); auto indexable = this->EvaluateExpression(indexExpression->GetIndexableExpression());
return indexable -> IndexValue(index) -> Clone(); return indexable->IndexValue(index)->Clone();
} }
const shared_ptr<EvalValue> Evaluator::EvaluateNumericTableExpression(const BoundExpression *expression) { const shared_ptr<EvalValue> Evaluator::EvaluateNumericTableExpression(const BoundExpression *expression) {
auto tableExpression = (BoundNumericalTableExpression*)expression; auto tableExpression = (BoundNumericalTableExpression *) expression;
auto valueExpressions = tableExpression->GetExpressions(); auto valueExpressions = tableExpression->GetExpressions();
auto values = new unordered_map<uint32_t, shared_ptr<EvalValue>>(valueExpressions->size()); auto values = new unordered_map<uint32_t, shared_ptr<EvalValue>>(valueExpressions->size());
for (int i = 0; i < valueExpressions->size(); i++){ for (int i = 0; i < valueExpressions->size(); i++) {
auto val = this -> EvaluateExpression(valueExpressions -> at(i)); auto val = this->EvaluateExpression(valueExpressions->at(i));
values -> insert({i + 1, val}); values->insert({i + 1, val});
} }
auto valuesPointer = shared_ptr<unordered_map<uint32_t, shared_ptr<EvalValue>>>(values); auto valuesPointer = shared_ptr<unordered_map<uint32_t, shared_ptr<EvalValue>>>(values);
return make_shared<TableEvalValue>(valuesPointer); return make_shared<TableEvalValue>(valuesPointer);
} }
const shared_ptr<EvalValue> Evaluator::EvaluateComplexTableExpression(const BoundExpression *expression) { const shared_ptr<EvalValue> Evaluator::EvaluateComplexTableExpression(const BoundExpression *expression) {
auto tableExpression = (BoundTableExpression*)expression; auto tableExpression = (BoundTableExpression *) expression;
auto type = dynamic_pointer_cast<TableScriptType>(tableExpression->GetType()); auto type = dynamic_pointer_cast<TableScriptType>(tableExpression->GetType());
auto declaredVars = type -> GetValues(); auto declaredVars = type->GetValues();
auto variables = make_shared<unordered_map<uint32_t, shared_ptr<EvalValue>>>(declaredVars->size()); auto variables = make_shared<unordered_map<uint32_t, shared_ptr<EvalValue>>>(declaredVars->size());
for (auto i : *declaredVars){ for (auto i : *declaredVars) {
variables->insert({i.first, nullptr}); variables->insert({i.first, nullptr});
} }
auto evaluator = make_shared<EvaluationScope>(variables.get(), type -> GetLocalVariableCount()); auto evaluator = make_shared<EvaluationScope>(variables.get(), type->GetLocalVariableCount());
auto currentEvaluator = this -> _evaluationScope; auto currentEvaluator = this->_evaluationScope;
this -> _evaluationScope = evaluator; this->_evaluationScope = evaluator;
this->EvaluateBlockStatement(tableExpression->GetBlock()); this->EvaluateBlockStatement(tableExpression->GetBlock());
this -> _evaluationScope = currentEvaluator; this->_evaluationScope = currentEvaluator;
return make_shared<TableEvalValue>(variables); return make_shared<TableEvalValue>(variables);
} }
const shared_ptr<EvalValue> Evaluator::EvaluateUserDataExpression(const BoundExpression *expression) { const shared_ptr<EvalValue> Evaluator::EvaluateUserDataExpression(const BoundExpression *expression) {
switch (expression->GetKind()){ switch (expression->GetKind()) {
case BoundExpressionKind ::Variable: return this->GetVariable((BoundVariableExpression*)expression); case BoundExpressionKind::Variable:
case BoundExpressionKind ::Index: return this -> EvaluateIndexExpression(expression); return this->GetVariable((BoundVariableExpression *) expression);
default: throw; case BoundExpressionKind::Index:
return this->EvaluateIndexExpression(expression);
default:
throw;
}
} }
} }

16
src/Evaluator/Evaluator.hpp
View File

@ -4,7 +4,6 @@
#include <string> #include <string>
#include "../Binder/BoundStatements/BoundStatement.hpp" #include "../Binder/BoundStatements/BoundStatement.hpp"
#include "../Script.hpp"
#include "EvalValues/EvalValue.hpp" #include "EvalValues/EvalValue.hpp"
#include "EvalValues/NumericEvalValue.hpp" #include "EvalValues/NumericEvalValue.hpp"
#include "EvalValues/StringEvalValue.hpp" #include "EvalValues/StringEvalValue.hpp"
@ -14,12 +13,14 @@
using namespace std; using namespace std;
class Evaluator { namespace Porygon::Evaluation{
class Evaluator {
shared_ptr<EvalValue> _returnValue; shared_ptr<EvalValue> _returnValue;
unordered_map<uint32_t, shared_ptr<EvalValue>>* _scriptVariables;
bool _hasReturned; bool _hasReturned;
shared_ptr<EvalValue> _lastValue; shared_ptr<EvalValue> _lastValue;
Script* _scriptData; //Porygon::Script* _scriptData;
shared_ptr<EvaluationScope> _evaluationScope; shared_ptr<EvaluationScope> _evaluationScope;
void EvaluateStatement(const BoundStatement* statement); void EvaluateStatement(const BoundStatement* statement);
@ -53,9 +54,9 @@ class Evaluator {
const shared_ptr<EvalValue> EvaluateUserDataExpression(const BoundExpression *expression); const shared_ptr<EvalValue> EvaluateUserDataExpression(const BoundExpression *expression);
const shared_ptr<EvalValue> GetVariable(const BoundVariableExpression *expression); const shared_ptr<EvalValue> GetVariable(const BoundVariableExpression *expression);
public: public:
explicit Evaluator(Script* script){ explicit Evaluator(unordered_map<uint32_t, shared_ptr<EvalValue>>* scriptVariables){
_scriptData = script; _scriptVariables = scriptVariables;
_hasReturned = false; _hasReturned = false;
_returnValue = nullptr; _returnValue = nullptr;
_evaluationScope = nullptr; _evaluationScope = nullptr;
@ -69,7 +70,8 @@ public:
return _lastValue.get(); return _lastValue.get();
} }
}; };
}

22
src/Evaluator/UnaryEvaluation.cpp
View File

@ -4,15 +4,15 @@
#include "EvaluationException.hpp" #include "EvaluationException.hpp"
#include "../Script.hpp" #include "../Script.hpp"
const shared_ptr<NumericEvalValue> Evaluator::EvaluateIntegerUnary(const BoundUnaryExpression *expression) { namespace Porygon::Evaluation {
switch (expression->GetOperation()){ const shared_ptr<NumericEvalValue> Evaluator::EvaluateIntegerUnary(const BoundUnaryExpression *expression) {
case BoundUnaryOperation::Negation: switch (expression->GetOperation()) {
{ case BoundUnaryOperation::Negation: {
auto operandValue = EvaluateIntegerExpression(expression->GetOperand()); auto operandValue = EvaluateIntegerExpression(expression->GetOperand());
if (operandValue->IsFloat()){ if (operandValue->IsFloat()) {
double f = operandValue->EvaluateFloat(); double f = operandValue->EvaluateFloat();
return make_shared<FloatEvalValue>(-f); return make_shared<FloatEvalValue>(-f);
} else{ } else {
long l = operandValue->EvaluateInteger(); long l = operandValue->EvaluateInteger();
return make_shared<IntegerEvalValue>(-l); return make_shared<IntegerEvalValue>(-l);
} }
@ -20,12 +20,11 @@ const shared_ptr<NumericEvalValue> Evaluator::EvaluateIntegerUnary(const BoundUn
case BoundUnaryOperation::LogicalNegation: case BoundUnaryOperation::LogicalNegation:
throw; throw;
} }
} }
const shared_ptr<BooleanEvalValue> Evaluator::EvaluateBooleanUnary(const BoundUnaryExpression *expression) { const shared_ptr<BooleanEvalValue> Evaluator::EvaluateBooleanUnary(const BoundUnaryExpression *expression) {
switch (expression->GetOperation()){ switch (expression->GetOperation()) {
case BoundUnaryOperation::LogicalNegation: case BoundUnaryOperation::LogicalNegation: {
{
auto val = EvaluateBoolExpression(expression->GetOperand()); auto val = EvaluateBoolExpression(expression->GetOperand());
bool b = val->EvaluateBool(); bool b = val->EvaluateBool();
return make_shared<BooleanEvalValue>(!b); return make_shared<BooleanEvalValue>(!b);
@ -33,4 +32,5 @@ const shared_ptr<BooleanEvalValue> Evaluator::EvaluateBooleanUnary(const BoundUn
case BoundUnaryOperation::Negation: case BoundUnaryOperation::Negation:
throw; throw;
} }
}
} }

7
src/Parser/BinaryOperatorKind.hpp
View File

@ -1,7 +1,9 @@
#ifndef PORYGONLANG_BINARYOPERATORKIND_HPP #ifndef PORYGONLANG_BINARYOPERATORKIND_HPP
#define PORYGONLANG_BINARYOPERATORKIND_HPP #define PORYGONLANG_BINARYOPERATORKIND_HPP
enum class BinaryOperatorKind{
namespace Porygon::Parser {
enum class BinaryOperatorKind {
// Math // Math
Addition, Addition,
Subtraction, Subtraction,
@ -19,5 +21,6 @@ enum class BinaryOperatorKind{
// Logical // Logical
LogicalAnd, LogicalAnd,
LogicalOr, LogicalOr,
}; };
}
#endif //PORYGONLANG_BINARYOPERATORKIND_HPP #endif //PORYGONLANG_BINARYOPERATORKIND_HPP

321
src/Parser/Lexer.cpp
View File

@ -5,20 +5,20 @@
#include "Lexer.hpp" #include "Lexer.hpp"
Lexer::Lexer(const u16string& scriptString, class Script* script) namespace Porygon::Parser {
: _scriptString(scriptString) Lexer::Lexer(const u16string &scriptString, Porygon::Script *script)
{ : _scriptString(scriptString) {
this->_scriptSize = scriptString.size(); this->_scriptSize = scriptString.size();
this -> ScriptData = script; this->ScriptData = script;
this -> _position = 0; this->_position = 0;
} }
vector<const IToken*> Lexer::Lex() { vector<const IToken *> Lexer::Lex() {
vector<const IToken*> tokens; vector<const IToken *> tokens;
while (true){ while (true) {
IToken* next = this -> LexNext(this -> Next()); IToken *next = this->LexNext(this->Next());
auto nextKind = next -> GetKind(); auto nextKind = next->GetKind();
if (nextKind != TokenKind::WhiteSpace) if (nextKind != TokenKind::WhiteSpace)
tokens.push_back(next); tokens.push_back(next);
else else
@ -27,76 +27,90 @@ vector<const IToken*> Lexer::Lex() {
break; break;
} }
return tokens; return tokens;
} }
char16_t Lexer::Peek(){ char16_t Lexer::Peek() {
if (Lexer::_position >= this -> _scriptSize) if (Lexer::_position >= this->_scriptSize)
return '\0'; return '\0';
return this -> _scriptString.at(Lexer::_position); return this->_scriptString.at(Lexer::_position);
} }
char16_t Lexer::Next(){ char16_t Lexer::Next() {
char16_t next = Peek(); char16_t next = Peek();
Lexer::_position++; Lexer::_position++;
return next; return next;
} }
IToken* Lexer::LexNext(char16_t c){ IToken *Lexer::LexNext(char16_t c) {
switch (c) { switch (c) {
case '\0': case '\0':
return new SimpleToken(TokenKind::EndOfFile, this -> _position - 1, 1); return new SimpleToken(TokenKind::EndOfFile, this->_position - 1, 1);
case ' ': case '\t': case '\n': case '\r': case '\v': case '\f': case ' ':
return new SimpleToken(TokenKind::WhiteSpace, this -> _position - 1, 1); case '\t':
case '\n':
case '\r':
case '\v':
case '\f':
return new SimpleToken(TokenKind::WhiteSpace, this->_position - 1, 1);
case '+': case '+':
return new SimpleToken(TokenKind::PlusToken, this -> _position - 1, 1); return new SimpleToken(TokenKind::PlusToken, this->_position - 1, 1);
case '-': case '-':
return new SimpleToken(TokenKind::MinusToken, this -> _position - 1, 1); return new SimpleToken(TokenKind::MinusToken, this->_position - 1, 1);
case '/': case '/':
return new SimpleToken(TokenKind::SlashToken, this -> _position - 1, 1); return new SimpleToken(TokenKind::SlashToken, this->_position - 1, 1);
case '*': case '*':
return new SimpleToken(TokenKind::StarToken, this -> _position - 1, 1); return new SimpleToken(TokenKind::StarToken, this->_position - 1, 1);
case '(': case '(':
return new SimpleToken(TokenKind::OpenParenthesis, this -> _position - 1, 1); return new SimpleToken(TokenKind::OpenParenthesis, this->_position - 1, 1);
case ')': case ')':
return new SimpleToken(TokenKind::CloseParenthesis, this -> _position - 1, 1); return new SimpleToken(TokenKind::CloseParenthesis, this->_position - 1, 1);
case '[': case '[':
return new SimpleToken(TokenKind::OpenSquareBracket, this -> _position - 1, 1); return new SimpleToken(TokenKind::OpenSquareBracket, this->_position - 1, 1);
case ']': case ']':
return new SimpleToken(TokenKind::CloseSquareBracket, this -> _position - 1, 1); return new SimpleToken(TokenKind::CloseSquareBracket, this->_position - 1, 1);
case '{': case '{':
return new SimpleToken(TokenKind::OpenCurlyBracket, this -> _position - 1, 1); return new SimpleToken(TokenKind::OpenCurlyBracket, this->_position - 1, 1);
case '}': case '}':
return new SimpleToken(TokenKind::CloseCurlyBracket, this -> _position - 1, 1); return new SimpleToken(TokenKind::CloseCurlyBracket, this->_position - 1, 1);
case ',': case ',':
return new SimpleToken(TokenKind::CommaToken, this -> _position - 1, 1); return new SimpleToken(TokenKind::CommaToken, this->_position - 1, 1);
case '.': case '.':
return new SimpleToken(TokenKind::PeriodToken, this -> _position - 1, 1); return new SimpleToken(TokenKind::PeriodToken, this->_position - 1, 1);
case '=': case '=':
if (Lexer::Peek() == '='){ if (Lexer::Peek() == '=') {
Lexer::Next(); Lexer::Next();
return new SimpleToken(TokenKind::EqualityToken, this -> _position - 2, 2); return new SimpleToken(TokenKind::EqualityToken, this->_position - 2, 2);
} }
return new SimpleToken(TokenKind::AssignmentToken, this -> _position - 1, 1); return new SimpleToken(TokenKind::AssignmentToken, this->_position - 1, 1);
case '<': case '<':
if (Lexer::Peek() == '='){ if (Lexer::Peek() == '=') {
Lexer::Next(); Lexer::Next();
return new SimpleToken(TokenKind::LessEquals, this -> _position - 2, 2); return new SimpleToken(TokenKind::LessEquals, this->_position - 2, 2);
} }
return new SimpleToken(TokenKind::Less, this -> _position - 1, 1); return new SimpleToken(TokenKind::Less, this->_position - 1, 1);
case '>': case '>':
if (Lexer::Peek() == '='){ if (Lexer::Peek() == '=') {
Lexer::Next(); Lexer::Next();
return new SimpleToken(TokenKind::GreaterEquals, this -> _position - 2, 2); return new SimpleToken(TokenKind::GreaterEquals, this->_position - 2, 2);
} }
return new SimpleToken(TokenKind::Greater, this -> _position - 1, 1); return new SimpleToken(TokenKind::Greater, this->_position - 1, 1);
case '~': case '~':
if (Lexer::Peek() == '='){ if (Lexer::Peek() == '=') {
Lexer::Next(); Lexer::Next();
return new SimpleToken(TokenKind::InequalityToken, this -> _position - 2, 2); return new SimpleToken(TokenKind::InequalityToken, this->_position - 2, 2);
} }
this -> ScriptData -> Diagnostics -> LogError(DiagnosticCode::UnexpectedCharacter, this -> _position - 1, 1); this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedCharacter, this->_position - 1, 1);
return new SimpleToken(TokenKind::BadToken, this -> _position - 1, 1); return new SimpleToken(TokenKind::BadToken, this->_position - 1, 1);
case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
return LexNumber(c); return LexNumber(c);
case '"': case '"':
return LexString(c); return LexString(c);
@ -105,49 +119,60 @@ IToken* Lexer::LexNext(char16_t c){
case '_': case '_':
return LexIdentifierOrKeyword(); return LexIdentifierOrKeyword();
default: default:
if (isalpha(c) || c > 255){ if (isalpha(c) || c > 255) {
return LexIdentifierOrKeyword(); return LexIdentifierOrKeyword();
} }
this -> ScriptData -> Diagnostics -> LogError(DiagnosticCode::UnexpectedCharacter, this -> _position - 1, 1); this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedCharacter, this->_position - 1, 1);
return new SimpleToken(TokenKind::BadToken, this -> _position - 1, 1); return new SimpleToken(TokenKind::BadToken, this->_position - 1, 1);
} }
}
int CharToInt(char16_t c){
switch (c){
case '0': return 0;
case '1': return 1;
case '2': return 2;
case '3': return 3;
case '4': return 4;
case '5': return 5;
case '6': return 6;
case '7': return 7;
case '8': return 8;
case '9': return 9;
default: return -1;
} }
}
IToken* Lexer::LexNumber(char16_t c){ int CharToInt(char16_t c) {
switch (c) {
case '0':
return 0;
case '1':
return 1;
case '2':
return 2;
case '3':
return 3;
case '4':
return 4;
case '5':
return 5;
case '6':
return 6;
case '7':
return 7;
case '8':
return 8;
case '9':
return 9;
default:
return -1;
}
}
IToken *Lexer::LexNumber(char16_t c) {
long int_value = CharToInt(c); long int_value = CharToInt(c);
double float_value = 0; double float_value = 0;
short decimal_index = 0; short decimal_index = 0;
bool has_point = false; bool has_point = false;
bool is_searching = true; bool is_searching = true;
unsigned int start = this -> _position - 1; unsigned int start = this->_position - 1;
unsigned int length = 1; unsigned int length = 1;
while (is_searching){ while (is_searching) {
char16_t next = this -> Peek(); char16_t next = this->Peek();
int next_val = CharToInt(next); int next_val = CharToInt(next);
if (next_val == -1){ if (next_val == -1) {
switch (next){ switch (next) {
case '_': case '_':
this -> Next(); this->Next();
length++; length++;
continue; continue;
case '.': case '.':
this -> Next(); this->Next();
has_point = true; has_point = true;
decimal_index = 0; decimal_index = 0;
float_value = int_value; float_value = int_value;
@ -157,69 +182,85 @@ IToken* Lexer::LexNumber(char16_t c){
is_searching = false; is_searching = false;
continue; continue;
} }
} } else {
else{ this->Next();
this -> Next();
length++; length++;
if (has_point){ if (has_point) {
decimal_index++; decimal_index++;
float_value += next_val / pow(10, decimal_index); float_value += next_val / pow(10, decimal_index);
} } else {
else {
int_value *= 10; int_value *= 10;
int_value += next_val; int_value += next_val;
} }
} }
} }
if (has_point){ if (has_point) {
return new FloatToken(float_value, start, length); return new FloatToken(float_value, start, length);
} } else {
else{
return new IntegerToken(int_value, start, length); return new IntegerToken(int_value, start, length);
} }
}
IToken * Lexer::LexIdentifierOrKeyword() {
auto start = this -> _position - 1;
auto end = start;
while (true){
char16_t next = this -> Peek();
if (next == '\0') break;
if (isalpha(next) || next == '_' || next > 255){
this -> Next();
end++;
} }
else{
IToken *Lexer::LexIdentifierOrKeyword() {
auto start = this->_position - 1;
auto end = start;
while (true) {
char16_t next = this->Peek();
if (next == '\0') break;
if (isalpha(next) || next == '_' || next > 255) {
this->Next();
end++;
} else {
break; break;
} }
} }
u16string s = this -> _scriptString.substr(start, end - start + 1); u16string s = this->_scriptString.substr(start, end - start + 1);
switch (HashedString::ConstHash(s.c_str())){ switch (HashedString::ConstHash(s.c_str())) {
case HashedString::ConstHash("and"): return new SimpleToken(TokenKind::AndKeyword, start, 3); case HashedString::ConstHash("and"):
case HashedString::ConstHash("break"): return new SimpleToken(TokenKind::BreakKeyword, start, 5); return new SimpleToken(TokenKind::AndKeyword, start, 3);
case HashedString::ConstHash("do"): return new SimpleToken(TokenKind::DoKeyword, start, 2); case HashedString::ConstHash("break"):
case HashedString::ConstHash("else"): return new SimpleToken(TokenKind::ElseKeyword, start, 4); return new SimpleToken(TokenKind::BreakKeyword, start, 5);
case HashedString::ConstHash("elseif"): return new SimpleToken(TokenKind::ElseIfKeyword, start, 6); case HashedString::ConstHash("do"):
case HashedString::ConstHash("end"): return new SimpleToken(TokenKind::EndKeyword, start, 3); return new SimpleToken(TokenKind::DoKeyword, start, 2);
case HashedString::ConstHash("false"): return new SimpleToken(TokenKind::FalseKeyword, start, 5); case HashedString::ConstHash("else"):
case HashedString::ConstHash("for"): return new SimpleToken(TokenKind::ForKeyword, start, 3); return new SimpleToken(TokenKind::ElseKeyword, start, 4);
case HashedString::ConstHash("function"): return new SimpleToken(TokenKind::FunctionKeyword, start, 8); case HashedString::ConstHash("elseif"):
case HashedString::ConstHash("if"): return new SimpleToken(TokenKind::IfKeyword, start, 2); return new SimpleToken(TokenKind::ElseIfKeyword, start, 6);
case HashedString::ConstHash("in"): return new SimpleToken(TokenKind::InKeyword, start, 2); case HashedString::ConstHash("end"):
case HashedString::ConstHash("local"): return new SimpleToken(TokenKind::LocalKeyword, start, 5); return new SimpleToken(TokenKind::EndKeyword, start, 3);
case HashedString::ConstHash("nil"): return new SimpleToken(TokenKind::NilKeyword, start, 3); case HashedString::ConstHash("false"):
case HashedString::ConstHash("not"): return new SimpleToken(TokenKind::NotKeyword, start, 3); return new SimpleToken(TokenKind::FalseKeyword, start, 5);
case HashedString::ConstHash("or"): return new SimpleToken(TokenKind::OrKeyword, start, 2); case HashedString::ConstHash("for"):
case HashedString::ConstHash("return"): return new SimpleToken(TokenKind::ReturnKeyword, start, 6); return new SimpleToken(TokenKind::ForKeyword, start, 3);
case HashedString::ConstHash("then"): return new SimpleToken(TokenKind::ThenKeyword, start, 4); case HashedString::ConstHash("function"):
case HashedString::ConstHash("true"): return new SimpleToken(TokenKind::TrueKeyword, start, 4); return new SimpleToken(TokenKind::FunctionKeyword, start, 8);
case HashedString::ConstHash("while"): return new SimpleToken(TokenKind::WhileKeyword, start, 5); case HashedString::ConstHash("if"):
default: return new IdentifierToken(HashedString(s), start, s.length()); return new SimpleToken(TokenKind::IfKeyword, start, 2);
case HashedString::ConstHash("in"):
return new SimpleToken(TokenKind::InKeyword, start, 2);
case HashedString::ConstHash("local"):
return new SimpleToken(TokenKind::LocalKeyword, start, 5);
case HashedString::ConstHash("nil"):
return new SimpleToken(TokenKind::NilKeyword, start, 3);
case HashedString::ConstHash("not"):
return new SimpleToken(TokenKind::NotKeyword, start, 3);
case HashedString::ConstHash("or"):
return new SimpleToken(TokenKind::OrKeyword, start, 2);
case HashedString::ConstHash("return"):
return new SimpleToken(TokenKind::ReturnKeyword, start, 6);
case HashedString::ConstHash("then"):
return new SimpleToken(TokenKind::ThenKeyword, start, 4);
case HashedString::ConstHash("true"):
return new SimpleToken(TokenKind::TrueKeyword, start, 4);
case HashedString::ConstHash("while"):
return new SimpleToken(TokenKind::WhileKeyword, start, 5);
default:
return new IdentifierToken(HashedString(s), start, s.length());
}
} }
}
const unordered_map<char16_t, char16_t> ControlCharacters{ // NOLINT(cert-err58-cpp) const unordered_map<char16_t, char16_t> ControlCharacters{ // NOLINT(cert-err58-cpp)
{'0', '\0'}, {'0', '\0'},
{'a', '\a'}, {'a', '\a'},
{'b', '\b'}, {'b', '\b'},
@ -232,43 +273,45 @@ const unordered_map<char16_t, char16_t> ControlCharacters{ // NOLINT(cert-err58-
{'\'', '\''}, {'\'', '\''},
{'\?', '\?'}, {'\?', '\?'},
{'\\', '\\'}, {'\\', '\\'},
}; };
IToken* Lexer::LexString(char16_t c){ IToken *Lexer::LexString(char16_t c) {
auto start = this -> _position - 1; auto start = this->_position - 1;
auto end = start; auto end = start;
char16_t last = c; char16_t last = c;
while (true){ while (true) {
char16_t next = this -> Peek(); char16_t next = this->Peek();
if (next == '\0') break; if (next == '\0') break;
if (next == c && last != '\\') break; if (next == c && last != '\\') break;
this -> Next(); this->Next();
end++; end++;
last = next; last = next;
} }
auto closeToken = this -> Next(); auto closeToken = this->Next();
if (closeToken != c){ if (closeToken != c) {
this -> ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedCharacter, this->_position - 1, 1); this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedCharacter, this->_position - 1, 1);
return new SimpleToken(TokenKind::BadToken, start, end -start + 1); return new SimpleToken(TokenKind::BadToken, start, end - start + 1);
} }
u16string s = this -> _scriptString.substr(start + 1, end - start); u16string s = this->_scriptString.substr(start + 1, end - start);
std::basic_ostringstream<char16_t > stream; std::basic_ostringstream<char16_t> stream;
for (int i = 0; i < s.size(); i++){ for (int i = 0; i < s.size(); i++) {
c = s[i]; c = s[i];
if (c == '\\'){ if (c == '\\') {
i++; i++;
c = s[i]; c = s[i];
if (ControlCharacters.find(c) != ControlCharacters.end()) { if (ControlCharacters.find(c) != ControlCharacters.end()) {
stream << ControlCharacters.at(c); stream << ControlCharacters.at(c);
} else{ } else {
this -> ScriptData->Diagnostics->LogError(DiagnosticCode::InvalidStringControlCharacter, start + 1 + i, 1); this->ScriptData->Diagnostics->LogError(DiagnosticCode::InvalidStringControlCharacter,
start + 1 + i, 1);
stream << c; stream << c;
} }
} else{ } else {
stream << c; stream << c;
} }
} }
return new StringToken(stream.str(), start, end - start ); return new StringToken(stream.str(), start, end - start);
} }
}

14
src/Parser/Lexer.hpp
View File

@ -7,10 +7,11 @@
using namespace std; using namespace std;
class Lexer { namespace Porygon::Parser{
class Lexer {
const u16string& _scriptString; const u16string& _scriptString;
#ifdef TESTS_BUILD #ifdef TESTS_BUILD
public: public:
#endif #endif
unsigned int _position; unsigned int _position;
unsigned int _scriptSize; unsigned int _scriptSize;
@ -20,13 +21,14 @@ public:
IToken* LexNumber(char16_t c); IToken* LexNumber(char16_t c);
IToken* LexIdentifierOrKeyword(); IToken* LexIdentifierOrKeyword();
IToken* LexString(char16_t c); IToken* LexString(char16_t c);
public: public:
Script* ScriptData; Porygon::Script* ScriptData;
vector<const IToken*> Lex(); vector<const IToken*> Lex();
explicit Lexer(const u16string& scriptString, class Script* script); explicit Lexer(const u16string& scriptString, Porygon::Script* script);
}; };
}
#endif //PORYGONLANG_LEXER_HPP #endif //PORYGONLANG_LEXER_HPP

271
src/Parser/ParsedExpressions/ParsedExpression.hpp
View File

@ -11,7 +11,8 @@
#include "../BinaryOperatorKind.hpp" #include "../BinaryOperatorKind.hpp"
#include "../../Utilities/HashedString.hpp" #include "../../Utilities/HashedString.hpp"
enum class ParsedExpressionKind{ namespace Porygon::Parser {
enum class ParsedExpressionKind {
Bad, Bad,
LiteralInteger, LiteralInteger,
@ -28,316 +29,314 @@ enum class ParsedExpressionKind{
PeriodIndexer, PeriodIndexer,
NumericalTable, NumericalTable,
Table, Table,
}; };
class ParsedExpression { class ParsedExpression {
const unsigned int _position; const unsigned int _position;
const unsigned int _length; const unsigned int _length;
public: public:
ParsedExpression(unsigned int position, unsigned int length) ParsedExpression(unsigned int position, unsigned int length)
: _position(position), : _position(position),
_length(length) _length(length) {
{
} }
virtual ~ParsedExpression() = default; virtual ~ParsedExpression() = default;
virtual const ParsedExpressionKind GetKind() const = 0; virtual const ParsedExpressionKind GetKind() const = 0;
const unsigned int GetStartPosition() const{ const unsigned int GetStartPosition() const {
return _position; return _position;
} }
const unsigned int GetEndPosition() const{ const unsigned int GetEndPosition() const {
return _position + _length - 1; return _position + _length - 1;
} }
const unsigned int GetLength() const{ const unsigned int GetLength() const {
return _length; return _length;
} }
}; };
class BadExpression : public ParsedExpression{ class BadExpression : public ParsedExpression {
public: public:
BadExpression(unsigned int position, unsigned int length) : ParsedExpression(position, length){} BadExpression(unsigned int position, unsigned int length) : ParsedExpression(position, length) {}
const ParsedExpressionKind GetKind() const final { const ParsedExpressionKind GetKind() const final {
return ParsedExpressionKind::Bad; return ParsedExpressionKind::Bad;
} }
}; };
class LiteralIntegerExpression : public ParsedExpression{ class LiteralIntegerExpression : public ParsedExpression {
const long _value; const long _value;
public: public:
const ParsedExpressionKind GetKind() const final{ const ParsedExpressionKind GetKind() const final {
return ParsedExpressionKind::LiteralInteger; return ParsedExpressionKind::LiteralInteger;
} }
explicit LiteralIntegerExpression(IntegerToken* token)
: ParsedExpression(token -> GetStartPosition(), token -> GetLength()), explicit LiteralIntegerExpression(IntegerToken *token)
_value(token -> GetValue()) : ParsedExpression(token->GetStartPosition(), token->GetLength()),
{ _value(token->GetValue()) {
} }
const long GetValue() const{ const long GetValue() const {
return _value; return _value;
} }
}; };
class LiteralFloatExpression : public ParsedExpression{ class LiteralFloatExpression : public ParsedExpression {
const double _value; const double _value;
public: public:
const ParsedExpressionKind GetKind() const final{ const ParsedExpressionKind GetKind() const final {
return ParsedExpressionKind::LiteralFloat; return ParsedExpressionKind::LiteralFloat;
} }
explicit LiteralFloatExpression(FloatToken* token)
: ParsedExpression(token -> GetStartPosition(), token -> GetLength()), explicit LiteralFloatExpression(FloatToken *token)
_value(token -> GetValue()) : ParsedExpression(token->GetStartPosition(), token->GetLength()),
{ _value(token->GetValue()) {
} }
const double GetValue() const{ const double GetValue() const {
return _value; return _value;
} }
}; };
class LiteralStringExpression : public ParsedExpression{ class LiteralStringExpression : public ParsedExpression {
const u16string _value; const u16string _value;
public: public:
const ParsedExpressionKind GetKind() const final{ const ParsedExpressionKind GetKind() const final {
return ParsedExpressionKind::LiteralString; return ParsedExpressionKind::LiteralString;
} }
explicit LiteralStringExpression(StringToken* token)
: ParsedExpression(token -> GetStartPosition(), token -> GetLength()), explicit LiteralStringExpression(StringToken *token)
_value(std::move(token -> GetValue())) : ParsedExpression(token->GetStartPosition(), token->GetLength()),
{ _value(std::move(token->GetValue())) {
} }
const u16string& GetValue() const{ const u16string &GetValue() const {
return _value; return _value;
} }
}; };
class LiteralBoolExpression : public ParsedExpression{ class LiteralBoolExpression : public ParsedExpression {
const bool _value; const bool _value;
public: public:
const ParsedExpressionKind GetKind() const final{ const ParsedExpressionKind GetKind() const final {
return ParsedExpressionKind::LiteralBool; return ParsedExpressionKind::LiteralBool;
} }
explicit LiteralBoolExpression(const IToken* token)
: ParsedExpression(token -> GetStartPosition(), token -> GetLength()), explicit LiteralBoolExpression(const IToken *token)
_value(token -> GetKind() == TokenKind::TrueKeyword) : ParsedExpression(token->GetStartPosition(), token->GetLength()),
{ _value(token->GetKind() == TokenKind::TrueKeyword) {
} }
const bool GetValue() const{ const bool GetValue() const {
return _value; return _value;
} }
}; };
class VariableExpression : public ParsedExpression{ class VariableExpression : public ParsedExpression {
const HashedString _value; const HashedString _value;
public: public:
const ParsedExpressionKind GetKind() const final{ const ParsedExpressionKind GetKind() const final {
return ParsedExpressionKind::Variable; return ParsedExpressionKind::Variable;
} }
explicit VariableExpression(IdentifierToken* token) : ParsedExpression(token -> GetStartPosition(), token -> GetLength())
, _value(HashedString(token -> GetValue())) explicit VariableExpression(IdentifierToken *token) : ParsedExpression(token->GetStartPosition(),
{ token->GetLength()),
_value(HashedString(token->GetValue())) {
} }
const HashedString GetValue() const{ const HashedString GetValue() const {
return _value; return _value;
} }
}; };
class ParenthesizedExpression : public ParsedExpression{ class ParenthesizedExpression : public ParsedExpression {
const ParsedExpression* _expression; const ParsedExpression *_expression;
public: public:
~ParenthesizedExpression() override { ~ParenthesizedExpression() override {
delete _expression; delete _expression;
} }
const ParsedExpressionKind GetKind() const final{ const ParsedExpressionKind GetKind() const final {
return ParsedExpressionKind::Parenthesized; return ParsedExpressionKind::Parenthesized;
} }
explicit ParenthesizedExpression(ParsedExpression* innerExpression, unsigned int start, unsigned int length) explicit ParenthesizedExpression(ParsedExpression *innerExpression, unsigned int start, unsigned int length)
: ParsedExpression(start, length), _expression(innerExpression){ : ParsedExpression(start, length), _expression(innerExpression) {
} }
const ParsedExpression* GetInnerExpression() const{ const ParsedExpression *GetInnerExpression() const {
return _expression; return _expression;
} }
}; };
class UnaryExpression : public ParsedExpression{ class UnaryExpression : public ParsedExpression {
const UnaryOperatorKind _kind; const UnaryOperatorKind _kind;
const ParsedExpression* _operand; const ParsedExpression *_operand;
public: public:
~UnaryExpression() override { ~UnaryExpression() override {
delete _operand; delete _operand;
} }
const ParsedExpressionKind GetKind() const final{ const ParsedExpressionKind GetKind() const final {
return ParsedExpressionKind::Unary; return ParsedExpressionKind::Unary;
} }
UnaryExpression(UnaryOperatorKind kind, ParsedExpression* operand, unsigned int start, unsigned int length) UnaryExpression(UnaryOperatorKind kind, ParsedExpression *operand, unsigned int start, unsigned int length)
: ParsedExpression(start, length), : ParsedExpression(start, length),
_kind(kind), _operand(operand) _kind(kind), _operand(operand) {
{
} }
const UnaryOperatorKind GetOperatorKind() const{ const UnaryOperatorKind GetOperatorKind() const {
return _kind; return _kind;
} }
const ParsedExpression* GetOperand() const{ const ParsedExpression *GetOperand() const {
return _operand; return _operand;
} }
}; };
class BinaryExpression : public ParsedExpression{ class BinaryExpression : public ParsedExpression {
const BinaryOperatorKind _kind; const BinaryOperatorKind _kind;
const ParsedExpression* _left; const ParsedExpression *_left;
const ParsedExpression* _right; const ParsedExpression *_right;
public: public:
~BinaryExpression() override { ~BinaryExpression() override {
delete _left; delete _left;
delete _right; delete _right;
} }
const ParsedExpressionKind GetKind() const final{ const ParsedExpressionKind GetKind() const final {
return ParsedExpressionKind::Binary; return ParsedExpressionKind::Binary;
} }
BinaryExpression(BinaryOperatorKind kind, ParsedExpression* left, ParsedExpression* right, unsigned int start, BinaryExpression(BinaryOperatorKind kind, ParsedExpression *left, ParsedExpression *right, unsigned int start,
unsigned int length) unsigned int length)
: ParsedExpression(start, length), : ParsedExpression(start, length),
_kind(kind), _left(left), _right(right) _kind(kind), _left(left), _right(right) {
{
} }
const BinaryOperatorKind GetOperatorKind() const{ const BinaryOperatorKind GetOperatorKind() const {
return _kind; return _kind;
} }
const ParsedExpression* GetLeft() const{ const ParsedExpression *GetLeft() const {
return _left; return _left;
} }
const ParsedExpression* GetRight() const{ const ParsedExpression *GetRight() const {
return _right; return _right;
} }
}; };
class FunctionCallExpression : public ParsedExpression{ class FunctionCallExpression : public ParsedExpression {
const std::unique_ptr<ParsedExpression> _function; const std::unique_ptr<ParsedExpression> _function;
const vector<const ParsedExpression*> _parameters; const vector<const ParsedExpression *> _parameters;
public: public:
FunctionCallExpression(ParsedExpression* function, vector<const ParsedExpression*> parameters, unsigned int start, unsigned int length) FunctionCallExpression(ParsedExpression *function, vector<const ParsedExpression *> parameters,
unsigned int start, unsigned int length)
: ParsedExpression(start, length), : ParsedExpression(start, length),
_function(function), _parameters(std::move(parameters)) _function(function), _parameters(std::move(parameters)) {
{
} }
~FunctionCallExpression() final{ ~FunctionCallExpression() final {
for (auto p : _parameters){ for (auto p : _parameters) {
delete p; delete p;
} }
} }
const ParsedExpressionKind GetKind() const final{ const ParsedExpressionKind GetKind() const final {
return ParsedExpressionKind::FunctionCall; return ParsedExpressionKind::FunctionCall;
} }
const ParsedExpression* GetFunction() const{ const ParsedExpression *GetFunction() const {
return _function.get(); return _function.get();
} }
const vector<const ParsedExpression*>* GetParameters() const{
const vector<const ParsedExpression *> *GetParameters() const {
return &_parameters; return &_parameters;
} }
}; };
class IndexExpression : public ParsedExpression{ class IndexExpression : public ParsedExpression {
const ParsedExpression* _indexerExpression; const ParsedExpression *_indexerExpression;
const ParsedExpression* _indexExpression; const ParsedExpression *_indexExpression;
public: public:
IndexExpression(ParsedExpression* indexer, ParsedExpression* index, unsigned int start, unsigned int length) IndexExpression(ParsedExpression *indexer, ParsedExpression *index, unsigned int start, unsigned int length)
:ParsedExpression(start, length), : ParsedExpression(start, length),
_indexerExpression(indexer), _indexExpression(index) _indexerExpression(indexer), _indexExpression(index) {
{
} }
~IndexExpression() final{ ~IndexExpression() final {
delete _indexerExpression; delete _indexerExpression;
delete _indexExpression; delete _indexExpression;
} }
const ParsedExpressionKind GetKind() const final{ const ParsedExpressionKind GetKind() const final {
return ParsedExpressionKind::Indexer; return ParsedExpressionKind::Indexer;
} }
const ParsedExpression* GetIndexer() const{ const ParsedExpression *GetIndexer() const {
return _indexerExpression; return _indexerExpression;
} }
const ParsedExpression* GetIndex() const{ const ParsedExpression *GetIndex() const {
return _indexExpression; return _indexExpression;
} }
}; };
class PeriodIndexExpression : public ParsedExpression{ class PeriodIndexExpression : public ParsedExpression {
const ParsedExpression* _indexerExpression; const ParsedExpression *_indexerExpression;
const HashedString _index; const HashedString _index;
public: public:
PeriodIndexExpression(ParsedExpression* indexer, HashedString index, unsigned int start, unsigned int length) PeriodIndexExpression(ParsedExpression *indexer, HashedString index, unsigned int start, unsigned int length)
:ParsedExpression(start, length), : ParsedExpression(start, length),
_indexerExpression(indexer), _index(index) _indexerExpression(indexer), _index(index) {
{
} }
~PeriodIndexExpression() final{ ~PeriodIndexExpression() final {
delete _indexerExpression; delete _indexerExpression;
} }
const ParsedExpressionKind GetKind() const final{ const ParsedExpressionKind GetKind() const final {
return ParsedExpressionKind::PeriodIndexer; return ParsedExpressionKind::PeriodIndexer;
} }
const ParsedExpression* GetIndexer() const{ const ParsedExpression *GetIndexer() const {
return _indexerExpression; return _indexerExpression;
} }
const HashedString& GetIndex() const{ const HashedString &GetIndex() const {
return _index; return _index;
} }
}; };
class ParsedNumericalTableExpression : public ParsedExpression{ class ParsedNumericalTableExpression : public ParsedExpression {
vector<const ParsedExpression*> _expressions; vector<const ParsedExpression *> _expressions;
public: public:
ParsedNumericalTableExpression(vector<const ParsedExpression*> expressions, unsigned int start, unsigned int length) ParsedNumericalTableExpression(vector<const ParsedExpression *> expressions, unsigned int start,
: ParsedExpression(start, length){ unsigned int length)
: ParsedExpression(start, length) {
_expressions = std::move(expressions); _expressions = std::move(expressions);
} }
~ParsedNumericalTableExpression() final{ ~ParsedNumericalTableExpression() final {
for (auto s: _expressions){ for (auto s: _expressions) {
delete s; delete s;
} }
} }
const vector<const ParsedExpression*>* GetExpressions() const{ const vector<const ParsedExpression *> *GetExpressions() const {
return &_expressions; return &_expressions;
} }
const ParsedExpressionKind GetKind() const final{ const ParsedExpressionKind GetKind() const final {
return ParsedExpressionKind::NumericalTable; return ParsedExpressionKind::NumericalTable;
} }
}; };
}
#endif //PORYGONLANG_PARSEDEXPRESSION_HPP #endif //PORYGONLANG_PARSEDEXPRESSION_HPP

22
src/Parser/ParsedExpressions/ParsedTableExpression.hpp
View File

@ -5,27 +5,27 @@
#include "ParsedExpression.hpp" #include "ParsedExpression.hpp"
#include "../ParsedStatements/ParsedStatement.hpp" #include "../ParsedStatements/ParsedStatement.hpp"
class ParsedTableExpression : public ParsedExpression{ namespace Porygon::Parser {
const ParsedBlockStatement* _block; class ParsedTableExpression : public ParsedExpression {
public: const ParsedBlockStatement *_block;
ParsedTableExpression(ParsedBlockStatement* block, unsigned int start, unsigned int length) public:
: ParsedExpression(start, length), _block(block) ParsedTableExpression(ParsedBlockStatement *block, unsigned int start, unsigned int length)
{ : ParsedExpression(start, length), _block(block) {
} }
~ParsedTableExpression() final{ ~ParsedTableExpression() final {
delete _block; delete _block;
} }
const ParsedBlockStatement* GetBlock() const{ const ParsedBlockStatement *GetBlock() const {
return _block; return _block;
} }
const ParsedExpressionKind GetKind() const final{ const ParsedExpressionKind GetKind() const final {
return ParsedExpressionKind::Table; return ParsedExpressionKind::Table;
} }
}; };
}
#include "ParsedExpression.hpp" #include "ParsedExpression.hpp"
#endif //PORYGONLANG_PARSEDTABLEEXPRESSION_HPP #endif //PORYGONLANG_PARSEDTABLEEXPRESSION_HPP

229
src/Parser/ParsedStatements/ParsedStatement.hpp
View File

@ -13,7 +13,8 @@
#include "../../Utilities/HashedString.hpp" #include "../../Utilities/HashedString.hpp"
#include "../TypedVariableIdentifier.hpp" #include "../TypedVariableIdentifier.hpp"
enum class ParsedStatementKind{ namespace Porygon::Parser {
enum class ParsedStatementKind {
Bad, Bad,
Script, Script,
Block, Block,
@ -23,17 +24,18 @@ enum class ParsedStatementKind{
FunctionDeclaration, FunctionDeclaration,
Return, Return,
Conditional Conditional
}; };
class ParsedStatement { class ParsedStatement {
const unsigned int _start; const unsigned int _start;
const unsigned int _length; const unsigned int _length;
public: public:
ParsedStatement(unsigned int start, unsigned int length) ParsedStatement(unsigned int start, unsigned int length)
:_start(start), _length(length) : _start(start), _length(length) {
{
} }
virtual ~ParsedStatement() = default; virtual ~ParsedStatement() = default;
virtual const ParsedStatementKind GetKind() const = 0; virtual const ParsedStatementKind GetKind() const = 0;
const unsigned int GetStartPosition() const { const unsigned int GetStartPosition() const {
@ -47,229 +49,234 @@ public:
const unsigned int GetEndPosition() const { const unsigned int GetEndPosition() const {
return _start + _length - 1; return _start + _length - 1;
} }
}; };
class ParsedBadStatement : public ParsedStatement{ class ParsedBadStatement : public ParsedStatement {
public: public:
ParsedBadStatement(unsigned int start, unsigned int length) : ParsedStatement(start, length){}; ParsedBadStatement(unsigned int start, unsigned int length) : ParsedStatement(start, length) {};
const ParsedStatementKind GetKind() const final{
return ParsedStatementKind ::Bad; const ParsedStatementKind GetKind() const final {
return ParsedStatementKind::Bad;
} }
}; };
class ParsedBlockStatement : public ParsedStatement{ class ParsedBlockStatement : public ParsedStatement {
const std::vector<const ParsedStatement*> _statements; const std::vector<const ParsedStatement *> _statements;
public: public:
explicit ParsedBlockStatement(std::vector<const ParsedStatement*> statements) explicit ParsedBlockStatement(std::vector<const ParsedStatement *> statements)
: ParsedStatement(statements.front()->GetStartPosition(), statements.back()->GetEndPosition() - statements.front()->GetStartPosition()), : ParsedStatement(statements.front()->GetStartPosition(),
_statements(statements) statements.back()->GetEndPosition() - statements.front()->GetStartPosition()),
{} _statements(statements) {}
ParsedBlockStatement(std::vector<const ParsedStatement*> statements, unsigned int start) : ParsedStatement(start, 0), ParsedBlockStatement(std::vector<const ParsedStatement *> statements, unsigned int start) : ParsedStatement(
_statements(std::move(statements)) start, 0),
{ _statements(
std::move(
statements)) {
} }
~ParsedBlockStatement() override { ~ParsedBlockStatement() override {
for (auto s: _statements){ for (auto s: _statements) {
delete s; delete s;
} }
} }
const ParsedStatementKind GetKind() const override { const ParsedStatementKind GetKind() const override {
return ParsedStatementKind ::Block; return ParsedStatementKind::Block;
} }
const std::vector<const ParsedStatement*>* GetStatements() const{ const std::vector<const ParsedStatement *> *GetStatements() const {
return &_statements; return &_statements;
} }
}; };
class ParsedScriptStatement : public ParsedBlockStatement{ class ParsedScriptStatement : public ParsedBlockStatement {
public: public:
explicit ParsedScriptStatement(vector<const ParsedStatement*> statements) : ParsedBlockStatement(move(statements)){} explicit ParsedScriptStatement(vector<const ParsedStatement *> statements) : ParsedBlockStatement(
move(statements)) {}
const ParsedStatementKind GetKind() const final{ const ParsedStatementKind GetKind() const final {
return ParsedStatementKind ::Script; return ParsedStatementKind::Script;
} }
}; };
class ParsedExpressionStatement : public ParsedStatement{ class ParsedExpressionStatement : public ParsedStatement {
const ParsedExpression* _expression; const ParsedExpression *_expression;
public: public:
explicit ParsedExpressionStatement(ParsedExpression* expression) explicit ParsedExpressionStatement(ParsedExpression *expression)
: ParsedStatement(expression->GetStartPosition(), expression->GetLength()), : ParsedStatement(expression->GetStartPosition(), expression->GetLength()),
_expression(expression) _expression(expression) {
{
} }
~ParsedExpressionStatement() override { ~ParsedExpressionStatement() override {
delete _expression; delete _expression;
} }
const ParsedStatementKind GetKind() const final{ const ParsedStatementKind GetKind() const final {
return ParsedStatementKind ::Expression; return ParsedStatementKind::Expression;
} }
const ParsedExpression* GetExpression() const{ const ParsedExpression *GetExpression() const {
return _expression; return _expression;
} }
}; };
class ParsedFunctionDeclarationStatement : public ParsedStatement{ class ParsedFunctionDeclarationStatement : public ParsedStatement {
const HashedString _identifier; const HashedString _identifier;
const vector<TypedVariableIdentifier*> _parameters; const vector<TypedVariableIdentifier *> _parameters;
const ParsedBlockStatement* _block; const ParsedBlockStatement *_block;
public: public:
ParsedFunctionDeclarationStatement(HashedString identifier, vector<TypedVariableIdentifier*> parameters, ParsedBlockStatement* block, ParsedFunctionDeclarationStatement(HashedString identifier, vector<TypedVariableIdentifier *> parameters,
ParsedBlockStatement *block,
unsigned int start, unsigned int length) unsigned int start, unsigned int length)
: ParsedStatement(start, length), _identifier(identifier), _parameters(std::move(parameters)), _block(block){}; : ParsedStatement(start, length), _identifier(identifier), _parameters(std::move(parameters)),
_block(block) {};
~ParsedFunctionDeclarationStatement() override { ~ParsedFunctionDeclarationStatement() override {
for (auto v : _parameters){ for (auto v : _parameters) {
delete v; delete v;
} }
delete _block; delete _block;
} }
const ParsedStatementKind GetKind() const final{ const ParsedStatementKind GetKind() const final {
return ParsedStatementKind ::FunctionDeclaration; return ParsedStatementKind::FunctionDeclaration;
} }
const HashedString GetIdentifier() const{ const HashedString GetIdentifier() const {
return _identifier; return _identifier;
} }
const vector<TypedVariableIdentifier*>* GetParameters() const{ const vector<TypedVariableIdentifier *> *GetParameters() const {
return &_parameters; return &_parameters;
} }
const ParsedBlockStatement* GetBlock() const{ const ParsedBlockStatement *GetBlock() const {
return _block; return _block;
} }
}; };
class ParsedAssignmentStatement : public ParsedStatement{ class ParsedAssignmentStatement : public ParsedStatement {
const bool _local; const bool _local;
const HashedString _identifier; const HashedString _identifier;
const ParsedExpression* _expression; const ParsedExpression *_expression;
public: public:
ParsedAssignmentStatement(bool local, const HashedString identifier, ParsedExpression* expression, unsigned int start, unsigned int length) ParsedAssignmentStatement(bool local, const HashedString identifier, ParsedExpression *expression,
: ParsedStatement(start, length), _local(local), _identifier(identifier), _expression(expression) unsigned int start, unsigned int length)
{ : ParsedStatement(start, length), _local(local), _identifier(identifier), _expression(expression) {
} }
~ParsedAssignmentStatement() final{ ~ParsedAssignmentStatement() final {
delete _expression; delete _expression;
} }
const ParsedStatementKind GetKind() const final{ const ParsedStatementKind GetKind() const final {
return ParsedStatementKind ::Assignment; return ParsedStatementKind::Assignment;
} }
const bool IsLocal() const{ const bool IsLocal() const {
return _local; return _local;
} }
const HashedString GetIdentifier() const{ const HashedString GetIdentifier() const {
return _identifier; return _identifier;
} }
const ParsedExpression* GetExpression() const{ const ParsedExpression *GetExpression() const {
return _expression; return _expression;
} }
}; };
class ParsedIndexAssignmentStatement : public ParsedStatement{ class ParsedIndexAssignmentStatement : public ParsedStatement {
const ParsedExpression* _indexExpression; const ParsedExpression *_indexExpression;
const ParsedExpression* _valueExpression; const ParsedExpression *_valueExpression;
public: public:
ParsedIndexAssignmentStatement(ParsedExpression* indexExpression, ParsedExpression* valueExpression, unsigned int start, ParsedIndexAssignmentStatement(ParsedExpression *indexExpression, ParsedExpression *valueExpression,
unsigned int start,
unsigned int length) unsigned int length)
: ParsedStatement(start, length), : ParsedStatement(start, length),
_indexExpression(indexExpression), _valueExpression(valueExpression){} _indexExpression(indexExpression), _valueExpression(valueExpression) {}
~ParsedIndexAssignmentStatement() final{ ~ParsedIndexAssignmentStatement() final {
delete _indexExpression; delete _indexExpression;
delete _valueExpression; delete _valueExpression;
} }
const ParsedStatementKind GetKind() const final{ const ParsedStatementKind GetKind() const final {
return ParsedStatementKind ::IndexAssignment; return ParsedStatementKind::IndexAssignment;
} }
const ParsedExpression* GetIndexExpression() const{ const ParsedExpression *GetIndexExpression() const {
return _indexExpression; return _indexExpression;
} }
const ParsedExpression* GetValueExpression() const{ const ParsedExpression *GetValueExpression() const {
return _valueExpression; return _valueExpression;
} }
}; };
class ParsedReturnStatement : public ParsedStatement{ class ParsedReturnStatement : public ParsedStatement {
const ParsedExpression* _expression; const ParsedExpression *_expression;
public: public:
ParsedReturnStatement(ParsedExpression* expression, unsigned int start, unsigned int length) ParsedReturnStatement(ParsedExpression *expression, unsigned int start, unsigned int length)
: ParsedStatement(start, length), : ParsedStatement(start, length),
_expression(expression) _expression(expression) {
{
} }
~ParsedReturnStatement() final{ ~ParsedReturnStatement() final {
delete _expression; delete _expression;
} }
const ParsedStatementKind GetKind() const final{ const ParsedStatementKind GetKind() const final {
return ParsedStatementKind ::Return; return ParsedStatementKind::Return;
} }
const ParsedExpression* GetExpression() const{ const ParsedExpression *GetExpression() const {
return _expression; return _expression;
} }
}; };
class ParsedConditionalStatement : public ParsedStatement{ class ParsedConditionalStatement : public ParsedStatement {
const ParsedExpression* _condition; const ParsedExpression *_condition;
const ParsedStatement* _block; const ParsedStatement *_block;
// This can be either else if or else // This can be either else if or else
const ParsedStatement* _elseStatement; const ParsedStatement *_elseStatement;
public: public:
ParsedConditionalStatement(ParsedExpression* condition, ParsedStatement* block, unsigned int start, unsigned int length) ParsedConditionalStatement(ParsedExpression *condition, ParsedStatement *block, unsigned int start,
: ParsedStatement(start, length), _condition(condition), _block(block), _elseStatement(nullptr) unsigned int length)
{ : ParsedStatement(start, length), _condition(condition), _block(block), _elseStatement(nullptr) {
} }
ParsedConditionalStatement(ParsedExpression* condition, ParsedStatement* block, ParsedStatement* nextStatement, unsigned int start, unsigned int length) ParsedConditionalStatement(ParsedExpression *condition, ParsedStatement *block, ParsedStatement *nextStatement,
: ParsedStatement(start, length), _condition(condition), _block(block), _elseStatement(nextStatement) unsigned int start, unsigned int length)
{ : ParsedStatement(start, length), _condition(condition), _block(block), _elseStatement(nextStatement) {
_condition = condition; _condition = condition;
_block = block; _block = block;
_elseStatement = nextStatement; _elseStatement = nextStatement;
} }
~ParsedConditionalStatement() final{ ~ParsedConditionalStatement() final {
delete _condition; delete _condition;
delete _block; delete _block;
delete _elseStatement; delete _elseStatement;
} }
const ParsedStatementKind GetKind() const final{ const ParsedStatementKind GetKind() const final {
return ParsedStatementKind ::Conditional; return ParsedStatementKind::Conditional;
} }
const ParsedExpression* GetCondition() const { const ParsedExpression *GetCondition() const {
return _condition; return _condition;
} }
const ParsedStatement* GetBlock() const { const ParsedStatement *GetBlock() const {
return _block; return _block;
} }
const ParsedStatement* GetElseStatement() const { const ParsedStatement *GetElseStatement() const {
return _elseStatement; return _elseStatement;
} }
}; };
}
#endif //PORYGONLANG_PARSEDSTATEMENT_HPP #endif //PORYGONLANG_PARSEDSTATEMENT_HPP

538
src/Parser/Parser.cpp
View File

@ -7,218 +7,241 @@
#include "TypedVariableIdentifier.hpp" #include "TypedVariableIdentifier.hpp"
#include "ParsedExpressions/ParsedTableExpression.hpp" #include "ParsedExpressions/ParsedTableExpression.hpp"
namespace Porygon::Parser {
ParsedScriptStatement* Parser::Parse() { ParsedScriptStatement *Parser::Parse() {
vector<const ParsedStatement*> statements; vector<const ParsedStatement *> statements;
while (this->_position < this->_tokens.size()){ while (this->_position < this->_tokens.size()) {
auto next = this -> Next(); auto next = this->Next();
if (next->GetKind() == TokenKind::EndOfFile){ if (next->GetKind() == TokenKind::EndOfFile) {
break; break;
} }
statements.push_back(this -> ParseStatement(next)); statements.push_back(this->ParseStatement(next));
} }
return new ParsedScriptStatement(statements); return new ParsedScriptStatement(statements);
}
const IToken *Parser::Peek() {
return this -> _tokens[_position];
}
const IToken *Parser::PeekAt(int offset) {
return this -> _tokens[_position + offset];
}
const IToken *Parser::Next() {
this -> _position++;
return this -> _tokens[_position - 1];
}
ParsedStatement* Parser::ParseStatement(const IToken* current){
auto currentKind = current->GetKind();
switch (currentKind){
case TokenKind ::LocalKeyword: return this->ParseVariableAssignment(current);
case TokenKind ::FunctionKeyword: return this -> ParseFunctionDeclaration(current);
case TokenKind ::ReturnKeyword: return this->ParseReturnStatement(current);
case TokenKind ::IfKeyword: return this -> ParseIfStatement(current);
default: break;
} }
if (this->Peek()->GetKind() == TokenKind::AssignmentToken){
const IToken *Parser::Peek() {
return this->_tokens[_position];
}
const IToken *Parser::PeekAt(int offset) {
return this->_tokens[_position + offset];
}
const IToken *Parser::Next() {
this->_position++;
return this->_tokens[_position - 1];
}
ParsedStatement *Parser::ParseStatement(const IToken *current) {
auto currentKind = current->GetKind();
switch (currentKind) {
case TokenKind::LocalKeyword:
return this->ParseVariableAssignment(current);
case TokenKind::FunctionKeyword:
return this->ParseFunctionDeclaration(current);
case TokenKind::ReturnKeyword:
return this->ParseReturnStatement(current);
case TokenKind::IfKeyword:
return this->ParseIfStatement(current);
default:
break;
}
if (this->Peek()->GetKind() == TokenKind::AssignmentToken) {
return ParseVariableAssignment(current); return ParseVariableAssignment(current);
} }
auto expression = this -> ParseExpression(current); auto expression = this->ParseExpression(current);
auto expKind = expression -> GetKind(); auto expKind = expression->GetKind();
if ((expKind == ParsedExpressionKind::Indexer || expKind == ParsedExpressionKind::PeriodIndexer) if ((expKind == ParsedExpressionKind::Indexer || expKind == ParsedExpressionKind::PeriodIndexer)
&& this -> Peek()->GetKind() == TokenKind::AssignmentToken){ && this->Peek()->GetKind() == TokenKind::AssignmentToken) {
return this -> ParseIndexAssignment(expression); return this->ParseIndexAssignment(expression);
} }
return new ParsedExpressionStatement(expression); return new ParsedExpressionStatement(expression);
} }
ParsedStatement *Parser::ParseVariableAssignment(const IToken *current) { ParsedStatement *Parser::ParseVariableAssignment(const IToken *current) {
bool isLocal = false; bool isLocal = false;
const IToken* identifier; const IToken *identifier;
if (current -> GetKind() == TokenKind::LocalKeyword){ if (current->GetKind() == TokenKind::LocalKeyword) {
isLocal = true; isLocal = true;
identifier = this -> Next(); identifier = this->Next();
} else{ } else {
identifier = current; identifier = current;
} }
auto assignmentToken = this->Next(); auto assignmentToken = this->Next();
auto expression = this -> ParseExpression(this -> Next()); auto expression = this->ParseExpression(this->Next());
if (identifier -> GetKind() != TokenKind::Identifier){ if (identifier->GetKind() != TokenKind::Identifier) {
this -> ScriptData -> Diagnostics -> LogError(DiagnosticCode::UnexpectedToken, identifier->GetStartPosition(), identifier->GetLength()); this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, identifier->GetStartPosition(),
identifier->GetLength());
return new ParsedBadStatement(identifier->GetStartPosition(), identifier->GetLength()); return new ParsedBadStatement(identifier->GetStartPosition(), identifier->GetLength());
} }
if (assignmentToken -> GetKind() != TokenKind::AssignmentToken){ if (assignmentToken->GetKind() != TokenKind::AssignmentToken) {
this -> ScriptData -> Diagnostics -> LogError(DiagnosticCode::UnexpectedToken, identifier->GetStartPosition(), identifier->GetLength()); this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, identifier->GetStartPosition(),
identifier->GetLength());
return new ParsedBadStatement(identifier->GetStartPosition(), identifier->GetLength()); return new ParsedBadStatement(identifier->GetStartPosition(), identifier->GetLength());
} }
auto start = current -> GetStartPosition(); auto start = current->GetStartPosition();
return new ParsedAssignmentStatement(isLocal, ((IdentifierToken*)identifier) -> GetValue(), expression, start, expression->GetEndPosition() - start); return new ParsedAssignmentStatement(isLocal, ((IdentifierToken *) identifier)->GetValue(), expression, start,
} expression->GetEndPosition() - start);
}
ParsedStatement *Parser::ParseIndexAssignment(ParsedExpression *indexer) { ParsedStatement *Parser::ParseIndexAssignment(ParsedExpression *indexer) {
this -> Next(); // Consume assignment token this->Next(); // Consume assignment token
auto valueExpression = this -> ParseExpression(this -> Next()); auto valueExpression = this->ParseExpression(this->Next());
auto start = indexer->GetStartPosition(); auto start = indexer->GetStartPosition();
return new ParsedIndexAssignmentStatement(indexer, valueExpression, start, valueExpression->GetEndPosition() - start); return new ParsedIndexAssignmentStatement(indexer, valueExpression, start,
} valueExpression->GetEndPosition() - start);
}
ParsedStatement *Parser::ParseBlock(const vector<TokenKind>& endTokens, const vector<const ParsedStatement*>& openStatements) { ParsedStatement *
Parser::ParseBlock(const vector<TokenKind> &endTokens, const vector<const ParsedStatement *> &openStatements) {
auto statements = openStatements; auto statements = openStatements;
auto start = this->_position; auto start = this->_position;
while (this->_position < this->_tokens.size()){ while (this->_position < this->_tokens.size()) {
auto next = this -> Next(); auto next = this->Next();
auto nextKind = next->GetKind(); auto nextKind = next->GetKind();
if (std::find(endTokens.begin(), endTokens.end(), nextKind) != endTokens.end()){ if (std::find(endTokens.begin(), endTokens.end(), nextKind) != endTokens.end()) {
break; break;
} }
if (nextKind == TokenKind::EndOfFile){ if (nextKind == TokenKind::EndOfFile) {
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, next->GetStartPosition(), next->GetLength()); this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, next->GetStartPosition(),
next->GetLength());
break; break;
} }
statements.push_back(this -> ParseStatement(next)); statements.push_back(this->ParseStatement(next));
} }
if (statements.empty()){ if (statements.empty()) {
return new ParsedBlockStatement(statements,start); return new ParsedBlockStatement(statements, start);
} }
return new ParsedBlockStatement(statements); return new ParsedBlockStatement(statements);
} }
ParsedStatement *Parser::ParseFunctionDeclaration(const IToken *current) { ParsedStatement *Parser::ParseFunctionDeclaration(const IToken *current) {
auto functionIdentifierToken = this->Next(); auto functionIdentifierToken = this->Next();
auto openParenthesis = this->Next(); auto openParenthesis = this->Next();
vector<TypedVariableIdentifier*> parameters; vector<TypedVariableIdentifier *> parameters;
bool hasErrors = false; bool hasErrors = false;
if (functionIdentifierToken->GetKind() != TokenKind::Identifier){ if (functionIdentifierToken->GetKind() != TokenKind::Identifier) {
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, functionIdentifierToken->GetStartPosition(), functionIdentifierToken->GetLength()); this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken,
functionIdentifierToken->GetStartPosition(),
functionIdentifierToken->GetLength());
hasErrors = true; hasErrors = true;
} }
if (openParenthesis->GetKind() != TokenKind::OpenParenthesis && !hasErrors){ if (openParenthesis->GetKind() != TokenKind::OpenParenthesis && !hasErrors) {
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, openParenthesis->GetStartPosition(), openParenthesis->GetLength()); this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken,
openParenthesis->GetStartPosition(), openParenthesis->GetLength());
hasErrors = true; hasErrors = true;
} }
while (this -> _position < this->_tokens.size()){ while (this->_position < this->_tokens.size()) {
auto type = this->Next(); auto type = this->Next();
if (type->GetKind() == TokenKind::CloseParenthesis){ if (type->GetKind() == TokenKind::CloseParenthesis) {
break; break;
} }
auto identifier = this->Next(); auto identifier = this->Next();
auto next = this->Next(); auto next = this->Next();
if (type->GetKind() != TokenKind::Identifier &&!hasErrors){ if (type->GetKind() != TokenKind::Identifier && !hasErrors) {
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, type->GetStartPosition(), type->GetLength()); this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, type->GetStartPosition(),
type->GetLength());
hasErrors = true; hasErrors = true;
continue; continue;
} }
if (identifier->GetKind() != TokenKind::Identifier &&!hasErrors){ if (identifier->GetKind() != TokenKind::Identifier && !hasErrors) {
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, identifier->GetStartPosition(), identifier->GetLength()); this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, identifier->GetStartPosition(),
identifier->GetLength());
hasErrors = true; hasErrors = true;
continue; continue;
} }
if (type->GetKind() != TokenKind::Identifier || identifier->GetKind() != TokenKind::Identifier){ if (type->GetKind() != TokenKind::Identifier || identifier->GetKind() != TokenKind::Identifier) {
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, type->GetStartPosition(), type->GetLength()); this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, type->GetStartPosition(),
type->GetLength());
hasErrors = true; hasErrors = true;
continue; continue;
} }
auto typeToken = (IdentifierToken*)type; auto typeToken = (IdentifierToken *) type;
auto identifierToken = (IdentifierToken*)identifier; auto identifierToken = (IdentifierToken *) identifier;
parameters.push_back(new TypedVariableIdentifier(typeToken->GetValue(), identifierToken->GetValue())); parameters.push_back(new TypedVariableIdentifier(typeToken->GetValue(), identifierToken->GetValue()));
auto nextKind = next->GetKind(); auto nextKind = next->GetKind();
if (nextKind == TokenKind::CloseParenthesis || nextKind == TokenKind::EndOfFile){ if (nextKind == TokenKind::CloseParenthesis || nextKind == TokenKind::EndOfFile) {
break; break;
} else if (nextKind != TokenKind::CommaToken && !hasErrors){ } else if (nextKind != TokenKind::CommaToken && !hasErrors) {
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, next->GetStartPosition(), next->GetLength()); this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, next->GetStartPosition(),
next->GetLength());
hasErrors = true; hasErrors = true;
} }
} }
auto block = this -> ParseBlock({TokenKind ::EndKeyword}); auto block = this->ParseBlock({TokenKind::EndKeyword});
auto start = current->GetStartPosition(); auto start = current->GetStartPosition();
if (hasErrors){ if (hasErrors) {
return new ParsedBadStatement(start, block->GetEndPosition() - start); return new ParsedBadStatement(start, block->GetEndPosition() - start);
} }
if (block->GetKind() == ParsedStatementKind::Bad){ if (block->GetKind() == ParsedStatementKind::Bad) {
return new ParsedBadStatement(start, block->GetEndPosition() - start); return new ParsedBadStatement(start, block->GetEndPosition() - start);
} }
auto functionIdentifier = ((IdentifierToken*) functionIdentifierToken)->GetValue(); auto functionIdentifier = ((IdentifierToken *) functionIdentifierToken)->GetValue();
return new ParsedFunctionDeclarationStatement(HashedString(functionIdentifier), parameters, (ParsedBlockStatement*)block, start, block->GetEndPosition() - start); return new ParsedFunctionDeclarationStatement(HashedString(functionIdentifier), parameters,
} (ParsedBlockStatement *) block, start,
block->GetEndPosition() - start);
}
ParsedStatement* Parser::ParseReturnStatement(const IToken* current){ ParsedStatement *Parser::ParseReturnStatement(const IToken *current) {
//TODO: if next token is on a different line, don't parse it as return expression. //TODO: if next token is on a different line, don't parse it as return expression.
auto expression = this->ParseExpression(this->Next()); auto expression = this->ParseExpression(this->Next());
auto start = current->GetStartPosition(); auto start = current->GetStartPosition();
return new ParsedReturnStatement(expression, start, expression->GetEndPosition() - start); return new ParsedReturnStatement(expression, start, expression->GetEndPosition() - start);
} }
ParsedStatement* Parser::ParseIfStatement(const IToken* current){ ParsedStatement *Parser::ParseIfStatement(const IToken *current) {
auto condition = this->ParseExpression(this->Next()); auto condition = this->ParseExpression(this->Next());
auto next = this -> Next(); auto next = this->Next();
if (next->GetKind() != TokenKind::ThenKeyword){ if (next->GetKind() != TokenKind::ThenKeyword) {
this -> ScriptData -> Diagnostics -> LogError(DiagnosticCode::UnexpectedToken, next->GetStartPosition(), next->GetLength()); this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, next->GetStartPosition(),
next->GetLength());
return new ParsedBadStatement(next->GetStartPosition(), next->GetLength()); return new ParsedBadStatement(next->GetStartPosition(), next->GetLength());
} }
auto block = this -> ParseBlock({TokenKind ::EndKeyword, TokenKind ::ElseKeyword, TokenKind ::ElseIfKeyword}); auto block = this->ParseBlock({TokenKind::EndKeyword, TokenKind::ElseKeyword, TokenKind::ElseIfKeyword});
auto closeToken = this->PeekAt(-1); auto closeToken = this->PeekAt(-1);
auto start = current->GetStartPosition(); auto start = current->GetStartPosition();
if (closeToken->GetKind() == TokenKind::ElseIfKeyword){ if (closeToken->GetKind() == TokenKind::ElseIfKeyword) {
auto elseIfStatement = this -> ParseIfStatement(closeToken); auto elseIfStatement = this->ParseIfStatement(closeToken);
return new ParsedConditionalStatement(condition, block, elseIfStatement, start, elseIfStatement->GetEndPosition() - start); return new ParsedConditionalStatement(condition, block, elseIfStatement, start,
} else if (closeToken->GetKind() == TokenKind::ElseKeyword){ elseIfStatement->GetEndPosition() - start);
auto elseStatement = this -> ParseBlock({TokenKind ::EndKeyword}); } else if (closeToken->GetKind() == TokenKind::ElseKeyword) {
return new ParsedConditionalStatement(condition, block, elseStatement, start, elseStatement->GetEndPosition() - start); auto elseStatement = this->ParseBlock({TokenKind::EndKeyword});
return new ParsedConditionalStatement(condition, block, elseStatement, start,
elseStatement->GetEndPosition() - start);
} }
return new ParsedConditionalStatement(condition, block, start, block->GetEndPosition() - start); return new ParsedConditionalStatement(condition, block, start, block->GetEndPosition() - start);
} }
ParsedExpression* Parser::ParseExpression(const IToken* current){ ParsedExpression *Parser::ParseExpression(const IToken *current) {
auto expression = this -> ParseBinaryExpression(current, OperatorPrecedence::No); auto expression = this->ParseBinaryExpression(current, OperatorPrecedence::No);
auto peekKind = this->Peek()->GetKind(); auto peekKind = this->Peek()->GetKind();
while (peekKind == TokenKind::OpenParenthesis || while (peekKind == TokenKind::OpenParenthesis ||
peekKind == TokenKind::OpenSquareBracket || peekKind == TokenKind::OpenSquareBracket ||
peekKind == TokenKind::PeriodToken){ peekKind == TokenKind::PeriodToken) {
if (peekKind == TokenKind::OpenParenthesis){ if (peekKind == TokenKind::OpenParenthesis) {
expression = this->ParseFunctionCallExpression(expression); expression = this->ParseFunctionCallExpression(expression);
} else if (peekKind == TokenKind::OpenSquareBracket){ } else if (peekKind == TokenKind::OpenSquareBracket) {
expression = this->ParseIndexExpression(expression); expression = this->ParseIndexExpression(expression);
} else { } else {
expression = this -> ParsePeriodIndexExpression(expression); expression = this->ParsePeriodIndexExpression(expression);
} }
if (this -> _position >= this->_tokens.size()) if (this->_position >= this->_tokens.size())
break; break;
peekKind = this->Peek()->GetKind(); peekKind = this->Peek()->GetKind();
} }
return expression; return expression;
} }
OperatorPrecedence GetUnaryPrecedence(TokenKind kind){ OperatorPrecedence GetUnaryPrecedence(TokenKind kind) {
switch (kind){ switch (kind) {
case TokenKind::PlusToken: case TokenKind::PlusToken:
case TokenKind::MinusToken: case TokenKind::MinusToken:
case TokenKind::NotKeyword: case TokenKind::NotKeyword:
@ -226,207 +249,254 @@ OperatorPrecedence GetUnaryPrecedence(TokenKind kind){
default: default:
return OperatorPrecedence::No; return OperatorPrecedence::No;
} }
} }
UnaryOperatorKind GetUnaryOperatorKind(TokenKind kind){ UnaryOperatorKind GetUnaryOperatorKind(TokenKind kind) {
switch (kind){ switch (kind) {
case TokenKind::PlusToken: return UnaryOperatorKind::Identity; case TokenKind::PlusToken:
case TokenKind::MinusToken: return UnaryOperatorKind::Negation; return UnaryOperatorKind::Identity;
case TokenKind::NotKeyword: return UnaryOperatorKind::LogicalNegation; case TokenKind::MinusToken:
return UnaryOperatorKind::Negation;
case TokenKind::NotKeyword:
return UnaryOperatorKind::LogicalNegation;
default: // This should never trigger, so throw. default: // This should never trigger, so throw.
throw; throw;
} }
} }
BinaryOperatorKind GetBinaryOperatorKind(TokenKind kind){ BinaryOperatorKind GetBinaryOperatorKind(TokenKind kind) {
switch (kind){ switch (kind) {
// Math operators // Math operators
case TokenKind::PlusToken: return BinaryOperatorKind ::Addition; case TokenKind::PlusToken:
case TokenKind::MinusToken: return BinaryOperatorKind ::Subtraction; return BinaryOperatorKind::Addition;
case TokenKind::StarToken: return BinaryOperatorKind ::Multiplication; case TokenKind::MinusToken:
case TokenKind::SlashToken: return BinaryOperatorKind ::Division; return BinaryOperatorKind::Subtraction;
case TokenKind::StarToken:
return BinaryOperatorKind::Multiplication;
case TokenKind::SlashToken:
return BinaryOperatorKind::Division;
// Equality operators // Equality operators
case TokenKind::EqualityToken: return BinaryOperatorKind ::Equality; case TokenKind::EqualityToken:
case TokenKind::InequalityToken: return BinaryOperatorKind ::Inequality; return BinaryOperatorKind::Equality;
case TokenKind ::Less: return BinaryOperatorKind ::Less; case TokenKind::InequalityToken:
case TokenKind ::LessEquals: return BinaryOperatorKind ::LessOrEquals; return BinaryOperatorKind::Inequality;
case TokenKind ::Greater: return BinaryOperatorKind ::Greater; case TokenKind::Less:
case TokenKind ::GreaterEquals: return BinaryOperatorKind ::GreaterOrEquals; return BinaryOperatorKind::Less;
case TokenKind::LessEquals:
return BinaryOperatorKind::LessOrEquals;
case TokenKind::Greater:
return BinaryOperatorKind::Greater;
case TokenKind::GreaterEquals:
return BinaryOperatorKind::GreaterOrEquals;
// logical operators // logical operators
case TokenKind::AndKeyword: return BinaryOperatorKind ::LogicalAnd; case TokenKind::AndKeyword:
case TokenKind::OrKeyword: return BinaryOperatorKind ::LogicalOr; return BinaryOperatorKind::LogicalAnd;
case TokenKind::OrKeyword:
return BinaryOperatorKind::LogicalOr;
default: // This should never trigger, so throw. default: // This should never trigger, so throw.
throw; throw;
} }
} }
OperatorPrecedence GetBinaryPrecedence(TokenKind kind){ OperatorPrecedence GetBinaryPrecedence(TokenKind kind) {
switch (kind){ switch (kind) {
// Math // Math
case TokenKind::PlusToken: return OperatorPrecedence ::Additive; case TokenKind::PlusToken:
case TokenKind::MinusToken: return OperatorPrecedence ::Additive; return OperatorPrecedence::Additive;
case TokenKind::StarToken: return OperatorPrecedence ::Multiplication; case TokenKind::MinusToken:
case TokenKind::SlashToken: return OperatorPrecedence ::Multiplication; return OperatorPrecedence::Additive;
case TokenKind::StarToken:
return OperatorPrecedence::Multiplication;
case TokenKind::SlashToken:
return OperatorPrecedence::Multiplication;
// Equality // Equality
case TokenKind::EqualityToken: return OperatorPrecedence ::Equality; case TokenKind::EqualityToken:
case TokenKind::InequalityToken: return OperatorPrecedence ::Equality; return OperatorPrecedence::Equality;
case TokenKind ::Less: return OperatorPrecedence ::Equality; case TokenKind::InequalityToken:
case TokenKind ::LessEquals: return OperatorPrecedence ::Equality; return OperatorPrecedence::Equality;
case TokenKind ::Greater: return OperatorPrecedence ::Equality; case TokenKind::Less:
case TokenKind ::GreaterEquals: return OperatorPrecedence ::Equality; return OperatorPrecedence::Equality;
case TokenKind::LessEquals:
return OperatorPrecedence::Equality;
case TokenKind::Greater:
return OperatorPrecedence::Equality;
case TokenKind::GreaterEquals:
return OperatorPrecedence::Equality;
// Logical // Logical
case TokenKind::AndKeyword: return OperatorPrecedence ::LogicalAnd; case TokenKind::AndKeyword:
case TokenKind::OrKeyword: return OperatorPrecedence ::LogicalOr; return OperatorPrecedence::LogicalAnd;
case TokenKind::OrKeyword:
return OperatorPrecedence::LogicalOr;
default: default:
return OperatorPrecedence::No; return OperatorPrecedence::No;
} }
}
ParsedExpression* Parser::ParseBinaryExpression(const IToken* current, OperatorPrecedence parentPrecedence){
OperatorPrecedence unaryPrecedence = GetUnaryPrecedence(current -> GetKind());
ParsedExpression* left;
if (unaryPrecedence != OperatorPrecedence::No && unaryPrecedence >= parentPrecedence){
UnaryOperatorKind operatorKind = GetUnaryOperatorKind(current -> GetKind());
auto next = this -> Next();
auto operand = this -> ParseBinaryExpression(next, unaryPrecedence);
auto startPos = current -> GetStartPosition();
left = new UnaryExpression(operatorKind, operand, startPos, operand -> GetEndPosition() - startPos);
} else{
left = this -> ParsePrimaryExpression(current);
} }
while (true){
auto next = this -> Peek(); ParsedExpression *Parser::ParseBinaryExpression(const IToken *current, OperatorPrecedence parentPrecedence) {
OperatorPrecedence binaryPrecedence = GetBinaryPrecedence(next -> GetKind()); OperatorPrecedence unaryPrecedence = GetUnaryPrecedence(current->GetKind());
if (binaryPrecedence == OperatorPrecedence::No || binaryPrecedence <= parentPrecedence){ ParsedExpression *left;
if (unaryPrecedence != OperatorPrecedence::No && unaryPrecedence >= parentPrecedence) {
UnaryOperatorKind operatorKind = GetUnaryOperatorKind(current->GetKind());
auto next = this->Next();
auto operand = this->ParseBinaryExpression(next, unaryPrecedence);
auto startPos = current->GetStartPosition();
left = new UnaryExpression(operatorKind, operand, startPos, operand->GetEndPosition() - startPos);
} else {
left = this->ParsePrimaryExpression(current);
}
while (true) {
auto next = this->Peek();
OperatorPrecedence binaryPrecedence = GetBinaryPrecedence(next->GetKind());
if (binaryPrecedence == OperatorPrecedence::No || binaryPrecedence <= parentPrecedence) {
break; break;
} }
auto operatorKind = GetBinaryOperatorKind(next -> GetKind()); auto operatorKind = GetBinaryOperatorKind(next->GetKind());
this -> Next(); this->Next();
auto right = this -> ParseBinaryExpression(this -> Next(), binaryPrecedence); auto right = this->ParseBinaryExpression(this->Next(), binaryPrecedence);
auto startPos = left -> GetStartPosition(); auto startPos = left->GetStartPosition();
left = new BinaryExpression(operatorKind, left, right, startPos, right -> GetEndPosition() - startPos); left = new BinaryExpression(operatorKind, left, right, startPos, right->GetEndPosition() - startPos);
} }
return left; return left;
} }
ParsedExpression *Parser::ParsePrimaryExpression(const IToken *current) { ParsedExpression *Parser::ParsePrimaryExpression(const IToken *current) {
switch (current -> GetKind()){ switch (current->GetKind()) {
case TokenKind ::Integer: return new LiteralIntegerExpression((IntegerToken*)current); case TokenKind::Integer:
case TokenKind ::Float: return new LiteralFloatExpression((FloatToken*)current); return new LiteralIntegerExpression((IntegerToken *) current);
case TokenKind ::String: return new LiteralStringExpression((StringToken*)current); case TokenKind::Float:
case TokenKind ::TrueKeyword: return new LiteralBoolExpression(current); return new LiteralFloatExpression((FloatToken *) current);
case TokenKind ::FalseKeyword: return new LiteralBoolExpression(current); case TokenKind::String:
case TokenKind ::Identifier: return new VariableExpression((IdentifierToken*)current); return new LiteralStringExpression((StringToken *) current);
case TokenKind ::OpenParenthesis: return this -> ParseParenthesizedExpression(current); case TokenKind::TrueKeyword:
case TokenKind ::OpenCurlyBracket: return this -> ParseTableExpression(current); return new LiteralBoolExpression(current);
case TokenKind::FalseKeyword:
return new LiteralBoolExpression(current);
case TokenKind::Identifier:
return new VariableExpression((IdentifierToken *) current);
case TokenKind::OpenParenthesis:
return this->ParseParenthesizedExpression(current);
case TokenKind::OpenCurlyBracket:
return this->ParseTableExpression(current);
// If we find a bad token here, we should have already logged it in the lexer, so don't log another error. // If we find a bad token here, we should have already logged it in the lexer, so don't log another error.
case TokenKind ::BadToken: return new BadExpression(current->GetStartPosition(), current->GetLength()); case TokenKind::BadToken:
return new BadExpression(current->GetStartPosition(), current->GetLength());
default: default:
this -> ScriptData -> Diagnostics -> LogError(DiagnosticCode::UnexpectedToken, current->GetStartPosition(), current->GetLength()); this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, current->GetStartPosition(),
current->GetLength());
return new BadExpression(current->GetStartPosition(), current->GetLength()); return new BadExpression(current->GetStartPosition(), current->GetLength());
} }
} }
ParsedExpression *Parser::ParseParenthesizedExpression(const IToken *current) { ParsedExpression *Parser::ParseParenthesizedExpression(const IToken *current) {
auto next = this -> Next(); auto next = this->Next();
auto expression = this -> ParseExpression(next); auto expression = this->ParseExpression(next);
auto closeToken = this -> Next(); auto closeToken = this->Next();
if (closeToken -> GetKind() != TokenKind::CloseParenthesis){ if (closeToken->GetKind() != TokenKind::CloseParenthesis) {
this -> ScriptData -> Diagnostics -> LogError(DiagnosticCode::UnexpectedToken, closeToken->GetStartPosition(), closeToken->GetLength()); this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, closeToken->GetStartPosition(),
closeToken->GetLength());
return new BadExpression(closeToken->GetStartPosition(), closeToken->GetLength()); return new BadExpression(closeToken->GetStartPosition(), closeToken->GetLength());
} }
auto start = current -> GetStartPosition(); auto start = current->GetStartPosition();
return new ParenthesizedExpression(expression, start, closeToken->GetEndPosition() - start); return new ParenthesizedExpression(expression, start, closeToken->GetEndPosition() - start);
} }
ParsedExpression *Parser::ParseFunctionCallExpression(ParsedExpression* functionExpression) { ParsedExpression *Parser::ParseFunctionCallExpression(ParsedExpression *functionExpression) {
this -> Next(); // consume the open parenthesis this->Next(); // consume the open parenthesis
vector<const ParsedExpression*> parameters; vector<const ParsedExpression *> parameters;
auto peeked = this -> Peek(); auto peeked = this->Peek();
auto peekedKind = peeked->GetKind(); auto peekedKind = peeked->GetKind();
if (peekedKind == TokenKind::CloseParenthesis){ if (peekedKind == TokenKind::CloseParenthesis) {
this->Next(); this->Next();
} else{ } else {
while (peekedKind != TokenKind::CloseParenthesis){ while (peekedKind != TokenKind::CloseParenthesis) {
if (peekedKind == TokenKind ::EndOfFile){ if (peekedKind == TokenKind::EndOfFile) {
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, peeked->GetStartPosition(), peeked->GetLength()); this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, peeked->GetStartPosition(),
peeked->GetLength());
return new BadExpression(peeked->GetStartPosition(), peeked->GetLength()); return new BadExpression(peeked->GetStartPosition(), peeked->GetLength());
} }
parameters.push_back(this->ParseExpression(this->Next())); parameters.push_back(this->ParseExpression(this->Next()));
peeked = this -> Next() ; peeked = this->Next();
peekedKind = peeked->GetKind(); peekedKind = peeked->GetKind();
if (peekedKind != TokenKind::CloseParenthesis && peekedKind != TokenKind::CommaToken){ if (peekedKind != TokenKind::CloseParenthesis && peekedKind != TokenKind::CommaToken) {
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, peeked->GetStartPosition(), peeked->GetLength()); this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, peeked->GetStartPosition(),
peeked->GetLength());
return new BadExpression(peeked->GetStartPosition(), peeked->GetLength()); return new BadExpression(peeked->GetStartPosition(), peeked->GetLength());
} }
} }
} }
auto start = functionExpression->GetStartPosition(); auto start = functionExpression->GetStartPosition();
return new FunctionCallExpression(functionExpression, parameters, start, peeked->GetEndPosition() - start); return new FunctionCallExpression(functionExpression, parameters, start, peeked->GetEndPosition() - start);
} }
ParsedExpression* Parser::ParseIndexExpression(ParsedExpression* indexingExpression){ ParsedExpression *Parser::ParseIndexExpression(ParsedExpression *indexingExpression) {
this->Next(); // consume '[' token this->Next(); // consume '[' token
auto indexExpression = this -> ParseExpression(this -> Next()); auto indexExpression = this->ParseExpression(this->Next());
auto closeBracket = this->Next(); auto closeBracket = this->Next();
if (closeBracket->GetKind() != TokenKind::CloseSquareBracket){ if (closeBracket->GetKind() != TokenKind::CloseSquareBracket) {
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, closeBracket->GetStartPosition(), closeBracket->GetLength()); this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, closeBracket->GetStartPosition(),
closeBracket->GetLength());
return new BadExpression(closeBracket->GetStartPosition(), closeBracket->GetLength()); return new BadExpression(closeBracket->GetStartPosition(), closeBracket->GetLength());
} }
auto start = indexingExpression->GetStartPosition(); auto start = indexingExpression->GetStartPosition();
return new IndexExpression(indexingExpression, indexExpression, start, closeBracket->GetEndPosition() - start); return new IndexExpression(indexingExpression, indexExpression, start, closeBracket->GetEndPosition() - start);
} }
ParsedExpression* Parser::ParsePeriodIndexExpression(ParsedExpression* indexingExpression){ ParsedExpression *Parser::ParsePeriodIndexExpression(ParsedExpression *indexingExpression) {
this->Next(); // consume '.' token this->Next(); // consume '.' token
auto identifier = this -> Next(); auto identifier = this->Next();
if (identifier->GetKind() != TokenKind::Identifier){ if (identifier->GetKind() != TokenKind::Identifier) {
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, identifier->GetStartPosition(), identifier->GetLength()); this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, identifier->GetStartPosition(),
return new BadExpression(indexingExpression->GetStartPosition(), identifier->GetEndPosition() - indexingExpression->GetStartPosition()); identifier->GetLength());
return new BadExpression(indexingExpression->GetStartPosition(),
identifier->GetEndPosition() - indexingExpression->GetStartPosition());
} }
auto start = indexingExpression->GetStartPosition(); auto start = indexingExpression->GetStartPosition();
return new PeriodIndexExpression(indexingExpression, ((IdentifierToken*)identifier)->GetValue(), start, identifier->GetEndPosition() - start); return new PeriodIndexExpression(indexingExpression, ((IdentifierToken *) identifier)->GetValue(), start,
} identifier->GetEndPosition() - start);
}
ParsedExpression* Parser::ParseTableExpression(const IToken* current){ ParsedExpression *Parser::ParseTableExpression(const IToken *current) {
if (this -> Peek() -> GetKind() == TokenKind::CloseCurlyBracket){ if (this->Peek()->GetKind() == TokenKind::CloseCurlyBracket) {
this -> Next(); this->Next();
auto start = current->GetStartPosition(); auto start = current->GetStartPosition();
return new ParsedNumericalTableExpression({}, start, this -> Peek()->GetEndPosition() - start); return new ParsedNumericalTableExpression({}, start, this->Peek()->GetEndPosition() - start);
} }
auto start = current->GetStartPosition(); auto start = current->GetStartPosition();
auto firstItem = this->ParseStatement(this -> Next()); auto firstItem = this->ParseStatement(this->Next());
// If the first item is an expression, and is followed by a comma, we're dealing with a simple {1, 2, 3} kind of array // If the first item is an expression, and is followed by a comma, we're dealing with a simple {1, 2, 3} kind of array
if (firstItem->GetKind() == ParsedStatementKind::Expression && if (firstItem->GetKind() == ParsedStatementKind::Expression &&
(this->Peek()->GetKind() == TokenKind::CommaToken )){ (this->Peek()->GetKind() == TokenKind::CommaToken)) {
auto expr = ((ParsedExpressionStatement*)firstItem)->GetExpression(); auto expr = ((ParsedExpressionStatement *) firstItem)->GetExpression();
auto expressions = vector<const ParsedExpression*>{expr}; auto expressions = vector<const ParsedExpression *>{expr};
auto n = this -> Next(); // consume the comma auto n = this->Next(); // consume the comma
bool hasErrors = false; bool hasErrors = false;
while (n->GetKind() != TokenKind::CloseCurlyBracket){ while (n->GetKind() != TokenKind::CloseCurlyBracket) {
auto expression = this->ParseExpression(this->Next()); auto expression = this->ParseExpression(this->Next());
expressions.push_back(expression); expressions.push_back(expression);
n = this->Next(); n = this->Next();
if (n->GetKind() != TokenKind::CommaToken && n->GetKind() != TokenKind ::CloseCurlyBracket && !hasErrors){ if (n->GetKind() != TokenKind::CommaToken && n->GetKind() != TokenKind::CloseCurlyBracket &&
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, n->GetStartPosition(), n->GetLength()); !hasErrors) {
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, n->GetStartPosition(),
n->GetLength());
hasErrors = true; hasErrors = true;
} }
} }
if (hasErrors){ if (hasErrors) {
return new BadExpression(start, n->GetEndPosition() - start); return new BadExpression(start, n->GetEndPosition() - start);
} }
return new ParsedNumericalTableExpression(expressions, start, n->GetEndPosition() - start); return new ParsedNumericalTableExpression(expressions, start, n->GetEndPosition() - start);
} }
// Otherwise we have a more complex table, which can be defined by a block // Otherwise we have a more complex table, which can be defined by a block
else { else {
auto block = (ParsedBlockStatement*)this -> ParseBlock({TokenKind ::CloseCurlyBracket}, {firstItem}); auto block = (ParsedBlockStatement *) this->ParseBlock({TokenKind::CloseCurlyBracket}, {firstItem});
auto closeToken = this -> PeekAt(-1); auto closeToken = this->PeekAt(-1);
return new ParsedTableExpression(block, start, closeToken->GetEndPosition() - start); return new ParsedTableExpression(block, start, closeToken->GetEndPosition() - start);
} }
} }
}

62
src/Parser/Parser.hpp
View File

@ -7,7 +7,8 @@
#include "ParsedStatements/ParsedStatement.hpp" #include "ParsedStatements/ParsedStatement.hpp"
#include "../Script.hpp" #include "../Script.hpp"
enum class OperatorPrecedence { namespace Porygon::Parser {
enum class OperatorPrecedence {
No, No,
LogicalOr, LogicalOr,
LogicalAnd, LogicalAnd,
@ -15,43 +16,60 @@ enum class OperatorPrecedence {
Additive, Additive,
Multiplication, Multiplication,
Unary, Unary,
}; };
class Parser { class Parser {
vector<const IToken*> _tokens; vector<const IToken *> _tokens;
unsigned int _position; unsigned int _position;
Script* ScriptData; Porygon::Script *ScriptData;
const IToken *Peek();
const IToken* Peek();
const IToken *PeekAt(int offset); const IToken *PeekAt(int offset);
const IToken* Next();
ParsedStatement* ParseStatement(const IToken* current); const IToken *Next();
ParsedStatement* ParseVariableAssignment(const IToken *current);
ParsedStatement* ParseIndexAssignment(ParsedExpression *indexer); ParsedStatement *ParseStatement(const IToken *current);
ParsedStatement *ParseBlock(const vector<TokenKind>& endTokens, const vector<const ParsedStatement*>& openStatements = {});
ParsedStatement* ParseFunctionDeclaration(const IToken* current); ParsedStatement *ParseVariableAssignment(const IToken *current);
ParsedStatement *ParseIndexAssignment(ParsedExpression *indexer);
ParsedStatement *
ParseBlock(const vector<TokenKind> &endTokens, const vector<const ParsedStatement *> &openStatements = {});
ParsedStatement *ParseFunctionDeclaration(const IToken *current);
ParsedStatement *ParseReturnStatement(const IToken *current); ParsedStatement *ParseReturnStatement(const IToken *current);
ParsedStatement *ParseIfStatement(const IToken *current); ParsedStatement *ParseIfStatement(const IToken *current);
ParsedExpression* ParseExpression(const IToken* current); ParsedExpression *ParseExpression(const IToken *current);
ParsedExpression* ParseBinaryExpression(const IToken* current, OperatorPrecedence parentPrecedence);
ParsedExpression* ParsePrimaryExpression(const IToken* current); ParsedExpression *ParseBinaryExpression(const IToken *current, OperatorPrecedence parentPrecedence);
ParsedExpression* ParseParenthesizedExpression(const IToken *current);
ParsedExpression *ParsePrimaryExpression(const IToken *current);
ParsedExpression *ParseParenthesizedExpression(const IToken *current);
ParsedExpression *ParseFunctionCallExpression(ParsedExpression *functionExpression);
ParsedExpression* ParseFunctionCallExpression(ParsedExpression* functionExpression);
ParsedExpression *ParseIndexExpression(ParsedExpression *indexingExpression); ParsedExpression *ParseIndexExpression(ParsedExpression *indexingExpression);
ParsedExpression *ParsePeriodIndexExpression(ParsedExpression *indexingExpression); ParsedExpression *ParsePeriodIndexExpression(ParsedExpression *indexingExpression);
ParsedExpression *ParseTableExpression(const IToken *current); ParsedExpression *ParseTableExpression(const IToken *current);
public:
ParsedScriptStatement* Parse(); public:
explicit Parser(const vector<const IToken*>& tokens, Script* scriptData){ ParsedScriptStatement *Parse();
explicit Parser(const vector<const IToken *> &tokens, Porygon::Script *scriptData) {
_tokens = tokens; _tokens = tokens;
_position = 0; _position = 0;
ScriptData = scriptData; ScriptData = scriptData;
} }
}; };
}
#endif //PORYGONLANG_PARSER_HPP #endif //PORYGONLANG_PARSER_HPP

83
src/Parser/Token.hpp
View File

@ -10,122 +10,119 @@
#include "../Utilities/HashedString.hpp" #include "../Utilities/HashedString.hpp"
using namespace std; using namespace std;
using namespace Porygon::Utilities;
class IToken{ namespace Porygon::Parser {
class IToken {
const unsigned int _position; const unsigned int _position;
const unsigned int _length; const unsigned int _length;
public: public:
virtual const TokenKind GetKind() const = 0; virtual const TokenKind GetKind() const = 0;
IToken(unsigned int position, unsigned int length) IToken(unsigned int position, unsigned int length)
: _position(position), _length(length) : _position(position), _length(length) {
{
} }
const unsigned int GetStartPosition() const{ const unsigned int GetStartPosition() const {
return _position; return _position;
} }
const unsigned int GetEndPosition() const{ const unsigned int GetEndPosition() const {
return _position + _length - 1; return _position + _length - 1;
} }
const unsigned int GetLength() const{ const unsigned int GetLength() const {
return _length; return _length;
} }
virtual ~IToken() = default; virtual ~IToken() = default;
}; };
class SimpleToken : public IToken{ class SimpleToken : public IToken {
const TokenKind _kind; const TokenKind _kind;
public: public:
explicit SimpleToken(TokenKind kind, unsigned int position, unsigned int length) explicit SimpleToken(TokenKind kind, unsigned int position, unsigned int length)
: IToken(position, length), : IToken(position, length),
_kind(kind) _kind(kind) {
{
} }
const TokenKind GetKind() const final{ const TokenKind GetKind() const final {
return _kind; return _kind;
} }
}; };
class IntegerToken : public IToken{ class IntegerToken : public IToken {
const long _value; const long _value;
public: public:
explicit IntegerToken(long value, unsigned int position, unsigned int length) explicit IntegerToken(long value, unsigned int position, unsigned int length)
: IToken(position, length), : IToken(position, length),
_value(value) _value(value) {
{
} }
const TokenKind GetKind() const final{ const TokenKind GetKind() const final {
return TokenKind::Integer; return TokenKind::Integer;
} }
const long GetValue() const{ const long GetValue() const {
return _value; return _value;
} }
}; };
class FloatToken : public IToken{ class FloatToken : public IToken {
const double _value; const double _value;
public: public:
explicit FloatToken(double value, unsigned int position, unsigned int length) explicit FloatToken(double value, unsigned int position, unsigned int length)
: IToken(position, length), : IToken(position, length),
_value(value) _value(value) {
{
} }
const TokenKind GetKind() const final{ const TokenKind GetKind() const final {
return TokenKind::Float; return TokenKind::Float;
} }
const double GetValue() const{ const double GetValue() const {
return _value; return _value;
} }
}; };
class StringToken : public IToken{ class StringToken : public IToken {
const u16string _value; const u16string _value;
public: public:
explicit StringToken(u16string value, unsigned int position, unsigned int length) explicit StringToken(u16string value, unsigned int position, unsigned int length)
: IToken(position, length), : IToken(position, length),
_value(std::move(value)) _value(std::move(value)) {
{
} }
const TokenKind GetKind() const final{ const TokenKind GetKind() const final {
return TokenKind::String; return TokenKind::String;
} }
const u16string& GetValue() const{ const u16string &GetValue() const {
return _value; return _value;
} }
}; };
class IdentifierToken : public IToken{ class IdentifierToken : public IToken {
const HashedString _value; const Utilities::HashedString _value;
public: public:
explicit IdentifierToken(const HashedString value, unsigned int position, unsigned int length) explicit IdentifierToken(const HashedString value, unsigned int position, unsigned int length)
: IToken(position, length), : IToken(position, length),
_value(value) _value(value) {
{
} }
const TokenKind GetKind() const final{ const TokenKind GetKind() const final {
return TokenKind::Identifier; return TokenKind::Identifier;
} }
const HashedString GetValue() const{ const HashedString GetValue() const {
return _value; return _value;
} }
}; };
}
#endif //PORYGONLANG_TOKEN_HPP #endif //PORYGONLANG_TOKEN_HPP

7
src/Parser/TokenKind.hpp
View File

@ -1,7 +1,8 @@
#ifndef PORYGONLANG_TOKENKIND_HPP #ifndef PORYGONLANG_TOKENKIND_HPP
#define PORYGONLANG_TOKENKIND_HPP #define PORYGONLANG_TOKENKIND_HPP
enum class TokenKind{ namespace Porygon::Parser {
enum class TokenKind {
EndOfFile, EndOfFile,
BadToken, BadToken,
WhiteSpace, WhiteSpace,
@ -53,7 +54,7 @@ enum class TokenKind{
ThenKeyword, ThenKeyword,
TrueKeyword, TrueKeyword,
WhileKeyword, WhileKeyword,
}; };
}
#endif //PORYGONLANG_TOKENKIND_HPP #endif //PORYGONLANG_TOKENKIND_HPP

15
src/Parser/TypedVariableIdentifier.hpp
View File

@ -4,22 +4,23 @@
#include "../Utilities/HashedString.hpp" #include "../Utilities/HashedString.hpp"
class TypedVariableIdentifier{ namespace Porygon::Parser {
class TypedVariableIdentifier {
HashedString _type; HashedString _type;
HashedString _identifier; HashedString _identifier;
public: public:
TypedVariableIdentifier(HashedString type, HashedString identifier) TypedVariableIdentifier(HashedString type, HashedString identifier)
: _type(type), _identifier(identifier) : _type(type), _identifier(identifier) {
{
} }
HashedString GetType(){ HashedString GetType() {
return _type; return _type;
} }
HashedString GetIdentifier(){ HashedString GetIdentifier() {
return _identifier; return _identifier;
} }
}; };
}
#endif //PORYGONLANG_TYPEDVARIABLEIDENTIFIER_HPP #endif //PORYGONLANG_TYPEDVARIABLEIDENTIFIER_HPP

6
src/Parser/UnaryOperatorKind.hpp
View File

@ -2,9 +2,11 @@
#ifndef PORYGONLANG_UNARYOPERATORKIND_HPP #ifndef PORYGONLANG_UNARYOPERATORKIND_HPP
#define PORYGONLANG_UNARYOPERATORKIND_HPP #define PORYGONLANG_UNARYOPERATORKIND_HPP
enum class UnaryOperatorKind{ namespace Porygon::Parser {
enum class UnaryOperatorKind {
Identity, Identity,
Negation, Negation,
LogicalNegation, LogicalNegation,
}; };
}
#endif //PORYGONLANG_UNARYOPERATORKIND_HPP #endif //PORYGONLANG_UNARYOPERATORKIND_HPP

46
src/Script.cpp
View File

@ -9,7 +9,7 @@
#include "Parser/Parser.hpp" #include "Parser/Parser.hpp"
#include "Binder/Binder.hpp" #include "Binder/Binder.hpp"
Script* Script::Create(const u16string& script) { Porygon::Script* Porygon::Script::Create(const u16string& script) {
auto s = new Script(); auto s = new Script();
s -> Parse(script); s -> Parse(script);
return s; return s;
@ -20,22 +20,22 @@ std::u16string To_UTF16(const string &s)
std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> conv; std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> conv;
return conv.from_bytes(s); return conv.from_bytes(s);
} }
Script *Script::Create(const string &script) { Porygon::Script *Porygon::Script::Create(const string &script) {
return Script::Create(To_UTF16(script)); return Script::Create(To_UTF16(script));
} }
Script::Script() { Porygon::Script::Script() {
Diagnostics = new DiagnosticsHolder(); Diagnostics = new DiagnosticsHolder();
_evaluator = new Evaluator(this);
_boundScript = nullptr; _boundScript = nullptr;
_scriptVariables = new unordered_map<uint32_t, shared_ptr<EvalValue>>(0); _scriptVariables = new unordered_map<uint32_t, shared_ptr<EvalValue>>(0);
_evaluator = new Evaluator(this -> _scriptVariables);
} }
EvalValue* Script::Evaluate() { EvalValue* Porygon::Script::Evaluate() {
return _evaluator->Evaluate(_boundScript); return _evaluator->Evaluate(_boundScript);
} }
Script::~Script() { Porygon::Script::~Script() {
delete this -> Diagnostics; delete this -> Diagnostics;
delete this -> _boundScript; delete this -> _boundScript;
delete this -> _evaluator; delete this -> _evaluator;
@ -43,10 +43,10 @@ Script::~Script() {
delete this->_scriptVariables; delete this->_scriptVariables;
} }
void Script::Parse(const u16string& script) { void Porygon::Script::Parse(const u16string& script) {
auto lexer = Lexer(script, this); auto lexer = Lexer(script, this);
auto lexResult = lexer.Lex(); auto lexResult = lexer.Lex();
auto parser = Parser(lexResult, this); auto parser = Parser::Parser(lexResult, this);
auto parseResult = parser.Parse(); auto parseResult = parser.Parse();
for (auto token : lexResult){ for (auto token : lexResult){
delete token; delete token;
@ -55,7 +55,7 @@ void Script::Parse(const u16string& script) {
if (!Diagnostics->HasErrors()){ if (!Diagnostics->HasErrors()){
unordered_map<uint32_t, BoundVariable*> scriptScope; unordered_map<uint32_t, BoundVariable*> scriptScope;
auto bindScope = new BoundScope(&scriptScope); auto bindScope = new BoundScope(&scriptScope);
this->_boundScript = Binder::Bind(this, parseResult, bindScope); this->_boundScript = Binder::Binder::Bind(this, parseResult, bindScope);
for (const auto& v : scriptScope){ for (const auto& v : scriptScope){
this->_scriptVariables -> insert({v.first, nullptr}); this->_scriptVariables -> insert({v.first, nullptr});
delete v.second; delete v.second;
@ -65,59 +65,57 @@ void Script::Parse(const u16string& script) {
delete parseResult; delete parseResult;
} }
EvalValue *Script::GetVariable(const u16string &key) { EvalValue *Porygon::Script::GetVariable(const u16string &key) {
return _scriptVariables -> at(HashedString(key).GetHash()).get(); return _scriptVariables -> at(HashedString(key).GetHash()).get();
} }
bool Script::HasVariable(const u16string &key) { bool Porygon::Script::HasVariable(const u16string &key) {
auto f = _scriptVariables->find(HashedString(key).GetHash()); auto f = _scriptVariables->find(HashedString(key).GetHash());
return f != _scriptVariables->end(); return f != _scriptVariables->end();
} }
EvalValue *Script::GetLastValue() { EvalValue *Porygon::Script::GetLastValue() {
return _evaluator->GetLastValue(); return _evaluator->GetLastValue();
} }
bool Script::HasFunction(const u16string &key) { bool Porygon::Script::HasFunction(const u16string &key) {
auto f = _scriptVariables->find(HashedString(key).GetHash()); auto f = _scriptVariables->find(HashedString(key).GetHash());
return f != _scriptVariables->end() && f.operator->()->second->GetTypeClass() == TypeClass ::Function; return f != _scriptVariables->end() && f.operator->()->second->GetTypeClass() == TypeClass ::Function;
} }
shared_ptr<EvalValue> Script::CallFunction(const u16string &key, const vector<EvalValue *>& variables) { shared_ptr<EvalValue> Porygon::Script::CallFunction(const u16string &key, const vector<EvalValue *>& variables) {
auto var = (ScriptFunctionEvalValue*)GetVariable(key); auto var = (ScriptFunctionEvalValue*)GetVariable(key);
return this->_evaluator->EvaluateFunction(var, variables); return this->_evaluator->EvaluateFunction(var, variables);
} }
extern "C" { extern "C" {
Script* CreateScript(char16_t * s){ Porygon::Script* CreateScript(char16_t * s){
return Script::Create(s); return Porygon::Script::Create(s);
} }
void EvaluateScript(Script* script){ void EvaluateScript(Porygon::Script* script){
script->Evaluate(); script->Evaluate();
} }
EvalValue* GetLastValue(Script* script){ EvalValue* GetLastValue(Porygon::Script* script){
return script->GetLastValue(); return script->GetLastValue();
} }
bool HasVariable(Script* script, const char16_t* key){ bool HasVariable(Porygon::Script* script, const char16_t* key){
return script->HasVariable(key); return script->HasVariable(key);
} }
EvalValue* GetVariable(Script* script, const char16_t* key){ EvalValue* GetVariable(Porygon::Script* script, const char16_t* key){
return script->GetVariable(key); return script->GetVariable(key);
} }
bool HasFunction(Script* script, const char16_t* key){ bool HasFunction(Porygon::Script* script, const char16_t* key){
return script->HasFunction(key); return script->HasFunction(key);
} }
EvalValue* CallFunction(Script* script, const char16_t* key, EvalValue* parameters[], int parameterCount){ EvalValue* CallFunction(Porygon::Script* script, const char16_t* key, EvalValue* parameters[], int parameterCount){
std::vector<EvalValue*> v(parameters, parameters + parameterCount); std::vector<EvalValue*> v(parameters, parameters + parameterCount);
return script->CallFunction(key, v).get(); return script->CallFunction(key, v).get();
} }
} }

20
src/Script.hpp
View File

@ -1,3 +1,5 @@
#include <utility>
#ifndef PORYGONLANG_SCRIPT_HPP #ifndef PORYGONLANG_SCRIPT_HPP
#define PORYGONLANG_SCRIPT_HPP #define PORYGONLANG_SCRIPT_HPP
@ -6,25 +8,23 @@
#include <unordered_map> #include <unordered_map>
#include "Diagnostics/DiagnosticsHolder.hpp" #include "Diagnostics/DiagnosticsHolder.hpp"
#include "Binder/BoundStatements/BoundStatement.hpp" #include "Binder/BoundStatements/BoundStatement.hpp"
class Script;
class Evaluator;
#include "Evaluator/Evaluator.hpp" #include "Evaluator/Evaluator.hpp"
#include "Evaluator/EvalValues/EvalValue.hpp" #include "Evaluator/EvalValues/EvalValue.hpp"
#include "Utilities/HashedString.hpp" #include "Utilities/HashedString.hpp"
using namespace std; using namespace std;
using namespace Porygon::Evaluation;
class Script { namespace Porygon{
friend class Evaluator; class Script {
Evaluator* _evaluator; Evaluator* _evaluator;
unordered_map<uint32_t, shared_ptr<EvalValue>>* _scriptVariables; unordered_map<uint32_t, shared_ptr<EvalValue>>* _scriptVariables;
BoundScriptStatement* _boundScript; Binder::BoundScriptStatement* _boundScript;
shared_ptr<ScriptType> _returnType; shared_ptr<ScriptType> _returnType;
explicit Script(); explicit Script();
void Parse(const u16string& script); void Parse(const u16string& script);
public: public:
static Script* Create(const u16string& script); static Script* Create(const u16string& script);
static Script* Create(const string& script); static Script* Create(const string& script);
DiagnosticsHolder* Diagnostics; DiagnosticsHolder* Diagnostics;
@ -36,7 +36,7 @@ public:
} }
void SetReturnType(shared_ptr<ScriptType> t){ void SetReturnType(shared_ptr<ScriptType> t){
_returnType = t; _returnType = std::move(t);
} }
EvalValue* Evaluate(); EvalValue* Evaluate();
@ -48,7 +48,9 @@ public:
shared_ptr<EvalValue> CallFunction(const u16string& key, const vector<EvalValue*>& variables); shared_ptr<EvalValue> CallFunction(const u16string& key, const vector<EvalValue*>& variables);
bool HasFunction(const u16string& key); bool HasFunction(const u16string& key);
}; };
}
#endif //PORYGONLANG_SCRIPT_HPP #endif //PORYGONLANG_SCRIPT_HPP

15
src/ScriptType.cpp
View File

@ -1,19 +1,20 @@
#include "Script.hpp" #include "Script.hpp"
const bool ScriptType::CanBeIndexedWith(ScriptType *indexer) const{ namespace Porygon{
const bool ScriptType::CanBeIndexedWith(ScriptType *indexer) const{
// String type is the only simple script type we want to // String type is the only simple script type we want to
return _class == TypeClass::String && indexer->_class == TypeClass::Number && !((NumericScriptType*)indexer)->IsFloat(); return _class == TypeClass::String && indexer->_class == TypeClass::Number && !((NumericScriptType*)indexer)->IsFloat();
} }
const shared_ptr<ScriptType> ScriptType::GetIndexedType(ScriptType *indexer) const{ const shared_ptr<ScriptType> ScriptType::GetIndexedType(ScriptType *indexer) const{
if (_class == TypeClass::String){ if (_class == TypeClass::String){
return make_shared<ScriptType>(TypeClass::String); return make_shared<ScriptType>(TypeClass::String);
} }
return make_shared<ScriptType>(TypeClass::Error); return make_shared<ScriptType>(TypeClass::Error);
} }
extern "C"{ extern "C"{
ScriptType* CreateScriptType(TypeClass t){ ScriptType* CreateScriptType(Porygon::TypeClass t){
return new ScriptType(t); return new ScriptType(t);
} }
@ -24,4 +25,6 @@ extern "C"{
ScriptType* CreateStringScriptType(bool knownAtBind, uint32_t hash){ ScriptType* CreateStringScriptType(bool knownAtBind, uint32_t hash){
return new StringScriptType(knownAtBind, hash); return new StringScriptType(knownAtBind, hash);
} }
}
} }

42
src/ScriptType.hpp
View File

@ -12,7 +12,8 @@
using namespace std; using namespace std;
enum class TypeClass{ namespace Porygon{
enum class TypeClass{
Error, Error,
Nil, Nil,
Number, Number,
@ -21,11 +22,11 @@ enum class TypeClass{
Function, Function,
UserData, UserData,
Table, Table,
}; };
class ScriptType{ class ScriptType{
TypeClass _class; TypeClass _class;
public: public:
explicit ScriptType(TypeClass c){ explicit ScriptType(TypeClass c){
_class = c; _class = c;
} }
@ -60,14 +61,14 @@ public:
virtual const shared_ptr<ScriptType> GetIndexedType(uint32_t hash) const{ virtual const shared_ptr<ScriptType> GetIndexedType(uint32_t hash) const{
throw "Shouldn't be possible"; throw "Shouldn't be possible";
} }
}; };
class NumericScriptType : public ScriptType{ class NumericScriptType : public ScriptType{
// Are we aware of whether this is a float or not? // Are we aware of whether this is a float or not?
bool _awareOfFloat; bool _awareOfFloat;
// Is this value a float? // Is this value a float?
bool _isFloat; bool _isFloat;
public: public:
explicit NumericScriptType(bool floatAware, bool isFloat) : ScriptType(TypeClass::Number){ explicit NumericScriptType(bool floatAware, bool isFloat) : ScriptType(TypeClass::Number){
_awareOfFloat = floatAware; _awareOfFloat = floatAware;
_isFloat = isFloat; _isFloat = isFloat;
@ -80,12 +81,12 @@ public:
const bool IsFloat() const{ const bool IsFloat() const{
return _isFloat; return _isFloat;
} }
}; };
class StringScriptType : public ScriptType{ class StringScriptType : public ScriptType{
bool _isKnownAtBind; bool _isKnownAtBind;
uint32_t _hashValue; uint32_t _hashValue;
public: public:
explicit StringScriptType(bool knownAtBind, uint32_t hashValue): ScriptType(TypeClass::String){ explicit StringScriptType(bool knownAtBind, uint32_t hashValue): ScriptType(TypeClass::String){
_isKnownAtBind = knownAtBind; _isKnownAtBind = knownAtBind;
_hashValue = hashValue; _hashValue = hashValue;
@ -98,16 +99,16 @@ public:
const uint32_t GetHashValue() const{ const uint32_t GetHashValue() const{
return _hashValue; return _hashValue;
} }
}; };
class FunctionScriptType : public ScriptType{ class FunctionScriptType : public ScriptType{
shared_ptr<ScriptType> _returnType; shared_ptr<ScriptType> _returnType;
vector<shared_ptr<ScriptType>> _parameterTypes; vector<shared_ptr<ScriptType>> _parameterTypes;
vector<shared_ptr<BoundVariableKey>> _parameterKeys; vector<shared_ptr<Binder::BoundVariableKey>> _parameterKeys;
int _scopeIndex; int _scopeIndex;
public: public:
FunctionScriptType(std::shared_ptr<ScriptType> returnType, vector<shared_ptr<ScriptType>> parameterTypes, FunctionScriptType(std::shared_ptr<ScriptType> returnType, vector<shared_ptr<ScriptType>> parameterTypes,
vector<shared_ptr<BoundVariableKey>> parameterKeys, int scopeIndex) vector<shared_ptr<Binder::BoundVariableKey>> parameterKeys, int scopeIndex)
: ScriptType(TypeClass::Function){ : ScriptType(TypeClass::Function){
_returnType = std::move(returnType); _returnType = std::move(returnType);
_parameterTypes = std::move(parameterTypes); _parameterTypes = std::move(parameterTypes);
@ -126,19 +127,19 @@ public:
return _parameterTypes; return _parameterTypes;
} }
const vector<shared_ptr<BoundVariableKey>> GetParameterKeys() const{ const vector<shared_ptr<Binder::BoundVariableKey>> GetParameterKeys() const{
return _parameterKeys; return _parameterKeys;
} }
const int GetScopeIndex() const{ const int GetScopeIndex() const{
return _scopeIndex; return _scopeIndex;
} }
}; };
class NumericalTableScriptType : public ScriptType{ class NumericalTableScriptType : public ScriptType{
shared_ptr<ScriptType> _valueType; shared_ptr<ScriptType> _valueType;
// Consider adding a check whether the table actually contains a type if every key is static. // Consider adding a check whether the table actually contains a type if every key is static.
public: public:
explicit NumericalTableScriptType(shared_ptr<ScriptType> valueType) : ScriptType(TypeClass::Table){ explicit NumericalTableScriptType(shared_ptr<ScriptType> valueType) : ScriptType(TypeClass::Table){
_valueType = std::move(valueType); _valueType = std::move(valueType);
} }
@ -150,7 +151,8 @@ public:
const shared_ptr<ScriptType> GetIndexedType(ScriptType* indexer) const final{ const shared_ptr<ScriptType> GetIndexedType(ScriptType* indexer) const final{
return _valueType; return _valueType;
} }
}; };
}
#endif //PORYGONLANG_SCRIPTTYPE_HPP #endif //PORYGONLANG_SCRIPTTYPE_HPP

8
src/TableScriptType.hpp
View File

@ -4,10 +4,11 @@
#include <unordered_map> #include <unordered_map>
#include "Binder/BoundVariables/BoundVariable.hpp" #include "Binder/BoundVariables/BoundVariable.hpp"
class TableScriptType : public ScriptType{ namespace Porygon{
class TableScriptType : public ScriptType{
const unordered_map<uint32_t, BoundVariable*>* _values; const unordered_map<uint32_t, BoundVariable*>* _values;
const int _localVariableCount; const int _localVariableCount;
public: public:
explicit TableScriptType(unordered_map<uint32_t, BoundVariable*>* values, int localVariableCount) explicit TableScriptType(unordered_map<uint32_t, BoundVariable*>* values, int localVariableCount)
: ScriptType(TypeClass::Table), : ScriptType(TypeClass::Table),
_values(values), _values(values),
@ -49,7 +50,8 @@ public:
return _localVariableCount; return _localVariableCount;
} }
}; };
}
#include "ScriptType.hpp" #include "ScriptType.hpp"

14
src/UserData/UserData.cpp
View File

@ -2,19 +2,21 @@
#include "UserData.hpp" #include "UserData.hpp"
#include "UserDataStorage.hpp" #include "UserDataStorage.hpp"
extern "C"{ namespace Porygon::UserData {
void RegisterUserDataType(uint32_t id){ extern "C" {
void RegisterUserDataType(uint32_t id) {
auto ud = new UserData({}); auto ud = new UserData({});
UserDataStorage::RegisterType(id, ud); UserDataStorage::RegisterType(id, ud);
} }
void RegisterUserDataField(uint32_t typeId, uint32_t fieldId, UserDataField* field){ void RegisterUserDataField(uint32_t typeId, uint32_t fieldId, UserDataField *field) {
auto ud = UserDataStorage::GetUserDataType(typeId); auto ud = UserDataStorage::GetUserDataType(typeId);
ud -> CreateField(fieldId, field); ud->CreateField(fieldId, field);
} }
int32_t GetUserDataFieldCount(uint32_t typeId){ int32_t GetUserDataFieldCount(uint32_t typeId) {
auto ud = UserDataStorage::GetUserDataType(typeId); auto ud = UserDataStorage::GetUserDataType(typeId);
return ud ->GetFieldCount(); return ud->GetFieldCount();
}
} }
} }

20
src/UserData/UserData.hpp
View File

@ -5,29 +5,31 @@
#include <unordered_map> #include <unordered_map>
#include "UserDataField.hpp" #include "UserDataField.hpp"
class UserData { namespace Porygon::UserData {
std::unordered_map<uint32_t, UserDataField*> _fields; class UserData {
public: std::unordered_map<uint32_t, UserDataField *> _fields;
explicit UserData(std::unordered_map<uint32_t, UserDataField*> fields){ public:
explicit UserData(std::unordered_map<uint32_t, UserDataField *> fields) {
_fields = std::move(fields); _fields = std::move(fields);
} }
bool ContainsField(uint32_t fieldId){ bool ContainsField(uint32_t fieldId) {
return _fields.find(fieldId) != _fields.end(); return _fields.find(fieldId) != _fields.end();
} }
UserDataField* GetField(uint32_t fieldId){ UserDataField *GetField(uint32_t fieldId) {
return _fields[fieldId]; return _fields[fieldId];
} }
void CreateField(uint32_t fieldId, UserDataField* field){ void CreateField(uint32_t fieldId, UserDataField *field) {
_fields.insert({fieldId, field}); _fields.insert({fieldId, field});
} }
int32_t GetFieldCount(){ int32_t GetFieldCount() {
return _fields.size(); return _fields.size();
} }
}; };
}
#endif //PORYGONLANG_USERDATA_HPP #endif //PORYGONLANG_USERDATA_HPP

7
src/UserData/UserDataField.cpp
View File

@ -1,8 +1,11 @@
#include "UserDataField.hpp" #include "UserDataField.hpp"
extern "C"{ namespace Porygon::UserData {
UserDataField* CreateUserDataField(ScriptType* type, EvalValue* (*getter)(void* obj), void (*setter)(void* obj, EvalValue* val)){ extern "C" {
UserDataField *
CreateUserDataField(ScriptType *type, Evaluation::EvalValue *(*getter)(void *obj), void (*setter)(void *obj, Evaluation::EvalValue *val)) {
return new UserDataField(type, getter, setter); return new UserDataField(type, getter, setter);
} }
}
} }

18
src/UserData/UserDataField.hpp
View File

@ -6,12 +6,13 @@
#include "../Evaluator/EvalValues/EvalValue.hpp" #include "../Evaluator/EvalValues/EvalValue.hpp"
#include "../Evaluator/EvalValues/NumericEvalValue.hpp" #include "../Evaluator/EvalValues/NumericEvalValue.hpp"
class UserDataField { namespace Porygon::UserData{
class UserDataField {
shared_ptr<ScriptType> _type; shared_ptr<ScriptType> _type;
EvalValue* (*_get)(void* obj); Evaluation::EvalValue* (*_get)(void* obj);
void (*_set)(void* obj, EvalValue* val); void (*_set)(void* obj, Evaluation::EvalValue* val);
public: public:
UserDataField(ScriptType* type, EvalValue* (*getter)(void* obj), void (*setter)(void* obj, EvalValue* val)){ UserDataField(ScriptType* type, Evaluation::EvalValue* (*getter)(void* obj), void (*setter)(void* obj, Evaluation::EvalValue* val)){
_type = shared_ptr<ScriptType>(type); _type = shared_ptr<ScriptType>(type);
_get = getter; _get = getter;
_set = setter; _set = setter;
@ -25,7 +26,7 @@ public:
return _get != nullptr; return _get != nullptr;
} }
EvalValue* Get(void* obj){ Evaluation::EvalValue* Get(void* obj){
return this ->_get(obj); return this ->_get(obj);
} }
@ -33,10 +34,11 @@ public:
return _set != nullptr; return _set != nullptr;
} }
void Set(void* obj, EvalValue* val){ void Set(void* obj, Evaluation::EvalValue* val){
this->_set(obj, val); this->_set(obj, val);
} }
}; };
}
#endif //PORYGONLANG_USERDATAFIELD_HPP #endif //PORYGONLANG_USERDATAFIELD_HPP

33
src/UserData/UserDataScriptType.hpp
View File

@ -8,46 +8,49 @@
#include "UserData.hpp" #include "UserData.hpp"
#include "UserDataStorage.hpp" #include "UserDataStorage.hpp"
class UserDataScriptType : public ScriptType{ namespace Porygon::UserData {
class UserDataScriptType : public ScriptType {
shared_ptr<UserData> _userData; shared_ptr<UserData> _userData;
public: public:
explicit UserDataScriptType(uint32_t id) : ScriptType(TypeClass::UserData){ explicit UserDataScriptType(uint32_t id) : ScriptType(TypeClass::UserData) {
_userData = UserDataStorage::GetUserDataType(id); _userData = UserDataStorage::GetUserDataType(id);
} }
explicit UserDataScriptType(shared_ptr<UserData> ud) : ScriptType(TypeClass::UserData){
explicit UserDataScriptType(shared_ptr<UserData> ud) : ScriptType(TypeClass::UserData) {
_userData = std::move(ud); _userData = std::move(ud);
} }
const bool CanBeIndexedWith(ScriptType* indexer) const final{ const bool CanBeIndexedWith(ScriptType *indexer) const final {
if (indexer->GetClass() != TypeClass ::String){ if (indexer->GetClass() != TypeClass::String) {
return false; return false;
} }
auto str = (StringScriptType*)indexer; auto str = (StringScriptType *) indexer;
if (!str->IsKnownAtBind()) if (!str->IsKnownAtBind())
return false; return false;
return _userData->ContainsField(str->GetHashValue()); return _userData->ContainsField(str->GetHashValue());
} }
const bool CanBeIndexedWithIdentifier(uint32_t hash) const final{ const bool CanBeIndexedWithIdentifier(uint32_t hash) const final {
return true; return true;
} }
UserDataField* GetField(uint32_t id){ UserDataField *GetField(uint32_t id) {
return _userData -> GetField(id); return _userData->GetField(id);
} }
const shared_ptr<ScriptType> GetIndexedType(ScriptType* indexer) const final{ const shared_ptr<ScriptType> GetIndexedType(ScriptType *indexer) const final {
auto stringKey = (StringScriptType*)indexer; auto stringKey = (StringScriptType *) indexer;
if (stringKey->IsKnownAtBind()){ if (stringKey->IsKnownAtBind()) {
return _userData->GetField(stringKey->GetHashValue())->GetType(); return _userData->GetField(stringKey->GetHashValue())->GetType();
} }
throw "TODO: indexing with dynamic keys"; throw "TODO: indexing with dynamic keys";
} }
const shared_ptr<ScriptType> GetIndexedType(uint32_t hash) const final{ const shared_ptr<ScriptType> GetIndexedType(uint32_t hash) const final {
return _userData->GetField(hash)->GetType(); return _userData->GetField(hash)->GetType();
} }
}; };
}
#endif //PORYGONLANG_USERDATASCRIPTTYPE_HPP #endif //PORYGONLANG_USERDATASCRIPTTYPE_HPP

4
src/UserData/UserDataStorage.cpp
View File

@ -1,4 +1,6 @@
#include "UserDataStorage.hpp" #include "UserDataStorage.hpp"
UserDataStorage::_internalDataStorage UserDataStorage::_internal = UserDataStorage::_internalDataStorage(); namespace Porygon::UserData {
UserDataStorage::_internalDataStorage UserDataStorage::_internal = UserDataStorage::_internalDataStorage();
}

18
src/UserData/UserDataStorage.hpp
View File

@ -5,26 +5,28 @@
#include <unordered_map> #include <unordered_map>
#include "UserData.hpp" #include "UserData.hpp"
class UserDataStorage { namespace Porygon::UserData {
class _internalDataStorage{ class UserDataStorage {
class _internalDataStorage {
public: public:
std::unordered_map<uint32_t, shared_ptr<UserData>> _userData; std::unordered_map<uint32_t, shared_ptr<UserData>> _userData;
}; };
static _internalDataStorage _internal; static _internalDataStorage _internal;
public: public:
static void RegisterType(uint32_t i, UserData* ud){ static void RegisterType(uint32_t i, UserData *ud) {
UserDataStorage::_internal._userData.insert({i, shared_ptr<UserData>(ud)}); UserDataStorage::_internal._userData.insert({i, shared_ptr<UserData>(ud)});
} }
static bool HasUserDataType(uint32_t i){ static bool HasUserDataType(uint32_t i) {
return UserDataStorage::_internal._userData.find(i) != UserDataStorage::_internal._userData.end(); return UserDataStorage::_internal._userData.find(i) != UserDataStorage::_internal._userData.end();
} }
static shared_ptr<UserData> GetUserDataType(uint32_t i){ static shared_ptr<UserData> GetUserDataType(uint32_t i) {
return UserDataStorage::_internal._userData[i]; return UserDataStorage::_internal._userData[i];
} }
}; };
}
#endif //PORYGONLANG_USERDATASTORAGE_HPP #endif //PORYGONLANG_USERDATASTORAGE_HPP

6
src/UserData/UserDataValue.cpp
View File

@ -1,8 +1,10 @@
#include "UserDataValue.hpp" #include "UserDataValue.hpp"
extern "C"{ namespace Porygon::UserData {
UserDataValue* CreateUserDataEvalValue(uint32_t typeHash, void* obj){ extern "C" {
UserDataValue *CreateUserDataEvalValue(uint32_t typeHash, void *obj) {
return new UserDataValue(typeHash, obj); return new UserDataValue(typeHash, obj);
} }
}
} }

41
src/UserData/UserDataValue.hpp
View File

@ -7,57 +7,56 @@
#include "UserData.hpp" #include "UserData.hpp"
#include "UserDataStorage.hpp" #include "UserDataStorage.hpp"
class UserDataValue : public EvalValue{ namespace Porygon::UserData {
class UserDataValue : public Evaluation::EvalValue {
const shared_ptr<UserData> _userData; const shared_ptr<UserData> _userData;
void* _obj; void *_obj;
public: public:
UserDataValue(shared_ptr<UserData> userData, void* obj) UserDataValue(shared_ptr<UserData> userData, void *obj)
: _userData(std::move(userData)) : _userData(std::move(userData)) {
{
_obj = obj; _obj = obj;
} }
UserDataValue(uint32_t userDataId, void* obj) UserDataValue(uint32_t userDataId, void *obj)
: _userData(UserDataStorage::GetUserDataType(userDataId)) : _userData(UserDataStorage::GetUserDataType(userDataId)) {
{
_obj = obj; _obj = obj;
} }
const TypeClass GetTypeClass() const final{ const TypeClass GetTypeClass() const final {
return TypeClass ::UserData; return TypeClass::UserData;
} }
const bool operator ==(EvalValue* b) const final { const bool operator==(EvalValue *b) const final {
if (b->GetTypeClass() != TypeClass::UserData) if (b->GetTypeClass() != TypeClass::UserData)
return false; return false;
return _obj == ((UserDataValue*)b)->_obj; return _obj == ((UserDataValue *) b)->_obj;
} }
const shared_ptr<EvalValue> Clone() const final{ const shared_ptr<EvalValue> Clone() const final {
return make_shared<UserDataValue>(_userData, _obj); return make_shared<UserDataValue>(_userData, _obj);
} }
const std::size_t GetHashCode() const final{ const std::size_t GetHashCode() const final {
return reinterpret_cast<intptr_t>(_obj); return reinterpret_cast<intptr_t>(_obj);
} }
const shared_ptr<EvalValue> IndexValue(EvalValue* val) const final { const shared_ptr<EvalValue> IndexValue(EvalValue *val) const final {
auto fieldId = val->GetHashCode(); auto fieldId = val->GetHashCode();
auto field = _userData->GetField(fieldId); auto field = _userData->GetField(fieldId);
return shared_ptr<EvalValue>(field->Get(_obj)); return shared_ptr<EvalValue>(field->Get(_obj));
} }
const shared_ptr<EvalValue> IndexValue(uint32_t hash) const final{ const shared_ptr<EvalValue> IndexValue(uint32_t hash) const final {
auto field = _userData->GetField(hash); auto field = _userData->GetField(hash);
return shared_ptr<EvalValue>(field->Get(_obj)); return shared_ptr<EvalValue>(field->Get(_obj));
} }
void SetIndexValue(EvalValue *key, const shared_ptr<EvalValue>& value) const final{ void SetIndexValue(EvalValue *key, const shared_ptr<EvalValue> &value) const final {
auto fieldId = key->GetHashCode(); auto fieldId = key->GetHashCode();
auto field = _userData->GetField(fieldId); auto field = _userData->GetField(fieldId);
field -> Set(_obj, value.get()); field->Set(_obj, value.get());
} }
}; };
}
#endif //PORYGONLANG_USERDATAVALUE_HPP #endif //PORYGONLANG_USERDATAVALUE_HPP

8
src/Utilities/HashedString.hpp
View File

@ -4,9 +4,10 @@
#include <string> #include <string>
class HashedString{ namespace Porygon::Utilities{
class HashedString{
const uint32_t _hash; const uint32_t _hash;
public: public:
explicit HashedString(const std::u16string& s) : _hash(ConstHash(s.c_str())){ explicit HashedString(const std::u16string& s) : _hash(ConstHash(s.c_str())){
} }
explicit HashedString(char16_t const *input) : _hash(ConstHash(input)){ explicit HashedString(char16_t const *input) : _hash(ConstHash(input)){
@ -39,6 +40,7 @@ public:
bool operator!=(const HashedString& b) const{ bool operator!=(const HashedString& b) const{
return _hash != b._hash; return _hash != b._hash;
} }
}; };
}
#endif //PORYGONLANG_HASHEDSTRING_HPP #endif //PORYGONLANG_HASHEDSTRING_HPP

2
tests/integration/ConditionalTests.cpp
View File

@ -2,6 +2,8 @@
#include <catch.hpp> #include <catch.hpp>
#include "../src/Script.hpp" #include "../src/Script.hpp"
using namespace Porygon;
TEST_CASE( "Basic conditional", "[integration]" ) { TEST_CASE( "Basic conditional", "[integration]" ) {
Script* script = Script::Create("if true then foo = true end"); Script* script = Script::Create("if true then foo = true end");
REQUIRE(!script->Diagnostics -> HasErrors()); REQUIRE(!script->Diagnostics -> HasErrors());

1
tests/integration/DiagnosticsTests.cpp
View File

@ -3,6 +3,7 @@
#include <catch.hpp> #include <catch.hpp>
#include "../src/Script.hpp" #include "../src/Script.hpp"
using namespace Porygon;
TEST_CASE( "Diagnostic invalid character", "[integration]" ) { TEST_CASE( "Diagnostic invalid character", "[integration]" ) {
auto script = Script::Create("1 + 1 @"); auto script = Script::Create("1 + 1 @");
REQUIRE(script->Diagnostics -> HasErrors()); REQUIRE(script->Diagnostics -> HasErrors());

1
tests/integration/EqualityOperationsTests.cpp
View File

@ -3,6 +3,7 @@
#include <catch.hpp> #include <catch.hpp>
#include "../src/Script.hpp" #include "../src/Script.hpp"
using namespace Porygon;
TEST_CASE( "True Equals True", "[integration]" ) { TEST_CASE( "True Equals True", "[integration]" ) {
auto script = Script::Create("true == true"); auto script = Script::Create("true == true");
REQUIRE(!script->Diagnostics -> HasErrors()); REQUIRE(!script->Diagnostics -> HasErrors());

2
tests/integration/Functions.cpp
View File

@ -2,6 +2,8 @@
#include <catch.hpp> #include <catch.hpp>
#include "../src/Script.hpp" #include "../src/Script.hpp"
using namespace Porygon;
TEST_CASE( "Define script function", "[integration]" ) { TEST_CASE( "Define script function", "[integration]" ) {
Script* script = Script::Create("function add(number a, number b) a + b end"); Script* script = Script::Create("function add(number a, number b) a + b end");
REQUIRE(!script->Diagnostics -> HasErrors()); REQUIRE(!script->Diagnostics -> HasErrors());

1
tests/integration/IndexTests.cpp
View File

@ -1,6 +1,7 @@
#ifdef TESTS_BUILD #ifdef TESTS_BUILD
#include <catch.hpp> #include <catch.hpp>
#include "../src/Script.hpp" #include "../src/Script.hpp"
using namespace Porygon;
TEST_CASE( "String indexing", "[integration]" ) { TEST_CASE( "String indexing", "[integration]" ) {
auto script = Script::Create("'foobar'[4]"); auto script = Script::Create("'foobar'[4]");

1
tests/integration/LogicalOperationsTests.cpp
View File

@ -1,6 +1,7 @@
#ifdef TESTS_BUILD #ifdef TESTS_BUILD
#include <catch.hpp> #include <catch.hpp>
#include "../src/Script.hpp" #include "../src/Script.hpp"
using namespace Porygon;
TEST_CASE( "Basic True", "[integration]" ) { TEST_CASE( "Basic True", "[integration]" ) {
auto script = Script::Create("true"); auto script = Script::Create("true");

1
tests/integration/NumericalOperationsTests.cpp
View File

@ -1,6 +1,7 @@
#ifdef TESTS_BUILD #ifdef TESTS_BUILD
#include <catch.hpp> #include <catch.hpp>
#include "../src/Script.hpp" #include "../src/Script.hpp"
using namespace Porygon;
TEST_CASE( "Integer Negation", "[integration]" ) { TEST_CASE( "Integer Negation", "[integration]" ) {
auto script = Script::Create("-60"); auto script = Script::Create("-60");

1
tests/integration/StringOperationsTests.cpp
View File

@ -3,6 +3,7 @@
#include <catch.hpp> #include <catch.hpp>
#include "../src/Script.hpp" #include "../src/Script.hpp"
using namespace Porygon;
TEST_CASE( "Simple String", "[integration]" ) { TEST_CASE( "Simple String", "[integration]" ) {
auto script = Script::Create("\"foo bar\""); auto script = Script::Create("\"foo bar\"");

1
tests/integration/Tables.cpp
View File

@ -2,6 +2,7 @@
#include <catch.hpp> #include <catch.hpp>
#include "../src/Script.hpp" #include "../src/Script.hpp"
#include "../../src/Evaluator/EvalValues/TableEvalValue.hpp" #include "../../src/Evaluator/EvalValues/TableEvalValue.hpp"
using namespace Porygon;
TEST_CASE( "Create empty table", "[integration]" ) { TEST_CASE( "Create empty table", "[integration]" ) {
Script* script = Script::Create("table = {}"); Script* script = Script::Create("table = {}");

7
tests/integration/UserData.cpp
View File

@ -5,6 +5,9 @@
#include "../../src/UserData/UserData.hpp" #include "../../src/UserData/UserData.hpp"
#include "../../src/UserData/UserDataStorage.hpp" #include "../../src/UserData/UserDataStorage.hpp"
#include "../../src/UserData/UserDataValue.hpp" #include "../../src/UserData/UserDataValue.hpp"
using namespace Porygon;
using namespace Porygon::UserData;
using namespace Porygon::Utilities;
class UserDataTestObject{ class UserDataTestObject{
public: public:
@ -18,8 +21,8 @@ public:
((UserDataTestObject*)obj)->foo = val->EvaluateInteger(); ((UserDataTestObject*)obj)->foo = val->EvaluateInteger();
} }
static UserData* CreateData(){ static Porygon::UserData::UserData* CreateData(){
return new UserData({ return new Porygon::UserData::UserData({
{ {
HashedString::ConstHash("foo"), HashedString::ConstHash("foo"),
new UserDataField(new NumericScriptType(true, false), GetFoo, SetFoo) new UserDataField(new NumericScriptType(true, false), GetFoo, SetFoo)

1
tests/integration/Variables.cpp
View File

@ -1,6 +1,7 @@
#ifdef TESTS_BUILD #ifdef TESTS_BUILD
#include <catch.hpp> #include <catch.hpp>
#include "../src/Script.hpp" #include "../src/Script.hpp"
using namespace Porygon;
TEST_CASE( "Create script variable", "[integration]" ) { TEST_CASE( "Create script variable", "[integration]" ) {
Script* script = Script::Create("foo = true"); Script* script = Script::Create("foo = true");

1
tests/parser/LexerTests.cpp
View File

@ -3,6 +3,7 @@
#include <codecvt> #include <codecvt>
#include <locale> #include <locale>
#include "../../src/Parser/Lexer.hpp" #include "../../src/Parser/Lexer.hpp"
using namespace Porygon::Parser;
TEST_CASE( "When at end of script return terminator", "[lexer]" ) { TEST_CASE( "When at end of script return terminator", "[lexer]" ) {
Lexer lexer = Lexer(u"", nullptr); Lexer lexer = Lexer(u"", nullptr);

1
tests/parser/ParserTests.cpp
View File

@ -3,6 +3,7 @@
#ifdef TESTS_BUILD #ifdef TESTS_BUILD
#include <catch.hpp> #include <catch.hpp>
#include "../../src/Parser/Parser.hpp" #include "../../src/Parser/Parser.hpp"
using namespace Porygon::Parser;
TEST_CASE( "Parse single true keyword", "[parser]" ) { TEST_CASE( "Parse single true keyword", "[parser]" ) {
vector<const IToken*> v {new SimpleToken(TokenKind::TrueKeyword,0,0), new SimpleToken(TokenKind::EndOfFile,0,0)}; vector<const IToken*> v {new SimpleToken(TokenKind::TrueKeyword,0,0), new SimpleToken(TokenKind::EndOfFile,0,0)};