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 <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();
binder._scriptData = script;
binder._scope = scriptScope;
auto statements = s->GetStatements();
vector<BoundStatement*> boundStatements (statements->size());
for (int i = 0; i < statements->size(); i++){
vector<BoundStatement *> boundStatements(statements->size());
for (int i = 0; i < statements->size(); i++) {
boundStatements[i] = binder.BindStatement(statements->at(i));
}
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) {
auto statements = ((ParsedBlockStatement*)statement)->GetStatements();
vector<BoundStatement*> boundStatements (statements->size());
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) {
auto statements = ((ParsedBlockStatement *) statement)->GetStatements();
vector<BoundStatement *> boundStatements(statements->size());
this->_scope->GoInnerScope();
for (int i = 0; i < statements->size(); i++){
boundStatements[i] = this -> BindStatement(statements->at(i));
for (int i = 0; i < statements->size(); i++) {
boundStatements[i] = this->BindStatement(statements->at(i));
}
this->_scope->GoOuterScope();
return new BoundBlockStatement(boundStatements);
}
}
BoundStatement *Binder::BindExpressionStatement(const ParsedStatement *statement) {
auto exp = ((ParsedExpressionStatement*)statement)->GetExpression();
return new BoundExpressionStatement(this -> BindExpression(exp));
}
BoundStatement *Binder::BindExpressionStatement(const ParsedStatement *statement) {
auto exp = ((ParsedExpressionStatement *) statement)->GetExpression();
return new BoundExpressionStatement(this->BindExpression(exp));
}
BoundStatement* Binder::BindAssignmentStatement(const ParsedStatement *statement){
auto s = (ParsedAssignmentStatement*) statement;
BoundStatement *Binder::BindAssignmentStatement(const ParsedStatement *statement) {
auto s = (ParsedAssignmentStatement *) statement;
auto boundExpression = this->BindExpression(s->GetExpression());
VariableAssignment assignment =
s->IsLocal() ?
this->_scope->CreateExplicitLocal(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();
return new BoundAssignmentStatement(key, boundExpression);
}
else{
this -> _scriptData -> Diagnostics -> LogError(DiagnosticCode::CantAssignVariable, statement->GetStartPosition(), statement->GetLength());
} else {
this->_scriptData->Diagnostics->LogError(DiagnosticCode::CantAssignVariable, statement->GetStartPosition(),
statement->GetLength());
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();
if (boundIndexType ->GetClass() != TypeClass ::Error && boundIndexType->operator!=(valueExpression->GetType().get())){
this -> _scriptData -> Diagnostics -> LogError(DiagnosticCode::InvalidTableValueType, statement->GetStartPosition(), statement->GetLength());
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();
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 BoundIndexAssignmentStatement(indexable, valueExpression);
}
}
std::shared_ptr<ScriptType> ParseTypeIdentifier(HashedString s){
std::shared_ptr<ScriptType> ParseTypeIdentifier(HashedString s) {
auto hash = s.GetHash();
switch (hash){
case HashedString::ConstHash("number"): return std::make_shared<NumericScriptType>(false, false);
case HashedString::ConstHash("bool"): return std::make_shared<ScriptType>(TypeClass::Bool);
case HashedString::ConstHash("string"): return std::make_shared<StringScriptType>(false, 0);
switch (hash) {
case HashedString::ConstHash("number"):
return std::make_shared<NumericScriptType>(false, false);
case HashedString::ConstHash("bool"):
return std::make_shared<ScriptType>(TypeClass::Bool);
case HashedString::ConstHash("string"):
return std::make_shared<StringScriptType>(false, 0);
default:
if (!UserDataStorage::HasUserDataType(hash)){
if (!UserData::UserDataStorage::HasUserDataType(hash)) {
return nullptr;
}
return std::make_shared<UserDataScriptType>(hash);
return std::make_shared<UserData::UserDataScriptType>(hash);
}
}
}
BoundStatement *Binder::BindFunctionDeclarationStatement(const ParsedStatement *statement) {
auto functionStatement = (ParsedFunctionDeclarationStatement*) statement;
BoundStatement *Binder::BindFunctionDeclarationStatement(const ParsedStatement *statement) {
auto functionStatement = (ParsedFunctionDeclarationStatement *) statement;
auto parameters = functionStatement->GetParameters();
auto parameterTypes = vector<shared_ptr<ScriptType>>(parameters->size());
auto parameterKeys = vector<shared_ptr<BoundVariableKey>>(parameters->size());
auto scopeIndex = this->_scope->GetCurrentScope();
this->_scope->GoInnerScope();
for (int i = 0; i < parameters->size(); i++){
auto var = parameters -> at(i);
for (int i = 0; i < parameters->size(); i++) {
auto var = parameters->at(i);
auto parsedType = ParseTypeIdentifier(var->GetType());
if (parsedType == nullptr){
this -> _scriptData -> Diagnostics -> LogError(DiagnosticCode::InvalidTypeName, statement->GetStartPosition(), statement->GetLength());
if (parsedType == nullptr) {
this->_scriptData->Diagnostics->LogError(DiagnosticCode::InvalidTypeName, statement->GetStartPosition(),
statement->GetLength());
return new BoundBadStatement();
}
parameterTypes.at(i) = 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());
}
else{
} else {
//TODO: log error
continue;
}
@ -136,250 +153,280 @@ BoundStatement *Binder::BindFunctionDeclarationStatement(const ParsedStatement *
this->_currentFunction = type;
auto assignment = this->_scope->AssignVariable(identifier.GetHash(), type);
if (assignment.GetResult() != VariableAssignmentResult::Ok){
this -> _scriptData -> Diagnostics -> LogError(DiagnosticCode::CantAssignVariable, statement->GetStartPosition(), statement->GetLength());
if (assignment.GetResult() != VariableAssignmentResult::Ok) {
this->_scriptData->Diagnostics->LogError(DiagnosticCode::CantAssignVariable, statement->GetStartPosition(),
statement->GetLength());
return new BoundBadStatement();
}
auto boundBlock = this -> BindBlockStatement(functionStatement->GetBlock());
auto boundBlock = this->BindBlockStatement(functionStatement->GetBlock());
this->_scope->GoOuterScope();
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){
auto expression = ((ParsedReturnStatement*)statement)->GetExpression();
BoundStatement *Binder::BindReturnStatement(const ParsedStatement *statement) {
auto expression = ((ParsedReturnStatement *) statement)->GetExpression();
shared_ptr<ScriptType> currentReturnType;
if (this->_currentFunction == nullptr){
if (this->_currentFunction == nullptr) {
currentReturnType = this->_scriptData->GetReturnType();
} else{
} else {
currentReturnType = this->_currentFunction->GetReturnType();
}
if (expression == nullptr && currentReturnType != nullptr){
this -> _scriptData -> Diagnostics -> LogError(DiagnosticCode::InvalidReturnType, statement->GetStartPosition(), statement->GetLength());
if (expression == nullptr && currentReturnType != nullptr) {
this->_scriptData->Diagnostics->LogError(DiagnosticCode::InvalidReturnType, statement->GetStartPosition(),
statement->GetLength());
return new BoundBadStatement();
}
auto boundExpression = this->BindExpression(expression);
auto expresionType = boundExpression->GetType();
if (currentReturnType == nullptr || currentReturnType->GetClass() == TypeClass::Nil){
if (this->_currentFunction == nullptr){
if (currentReturnType == nullptr || currentReturnType->GetClass() == TypeClass::Nil) {
if (this->_currentFunction == nullptr) {
this->_scriptData->SetReturnType(expresionType);
} else{
} else {
this->_currentFunction->SetReturnType(expresionType);
}
return new BoundReturnStatement(boundExpression);
}
if (currentReturnType.get()->operator!=(expresionType.get())){
this -> _scriptData -> Diagnostics -> LogError(DiagnosticCode::InvalidReturnType, statement->GetStartPosition(), statement->GetLength());
if (currentReturnType.get()->operator!=(expresionType.get())) {
this->_scriptData->Diagnostics->LogError(DiagnosticCode::InvalidReturnType, statement->GetStartPosition(),
statement->GetLength());
return new BoundBadStatement();
}
return new BoundReturnStatement(boundExpression);
}
}
BoundStatement *Binder::BindConditionalStatement(const ParsedStatement* statement) {
auto conditionalStatement = (ParsedConditionalStatement*)statement;
auto boundCondition = this -> BindExpression(conditionalStatement -> GetCondition());
if (boundCondition->GetType() -> GetClass() != TypeClass::Bool){
this -> _scriptData -> Diagnostics -> LogError(DiagnosticCode::ConditionNotABool, statement->GetStartPosition(), statement->GetLength());
BoundStatement *Binder::BindConditionalStatement(const ParsedStatement *statement) {
auto conditionalStatement = (ParsedConditionalStatement *) statement;
auto boundCondition = this->BindExpression(conditionalStatement->GetCondition());
if (boundCondition->GetType()->GetClass() != TypeClass::Bool) {
this->_scriptData->Diagnostics->LogError(DiagnosticCode::ConditionNotABool, statement->GetStartPosition(),
statement->GetLength());
return new BoundBadStatement();
}
auto boundBlock = this -> BindStatement(conditionalStatement->GetBlock());
BoundStatement* elseStatement = nullptr;
if (conditionalStatement->GetElseStatement() != nullptr){
elseStatement = this -> BindStatement(conditionalStatement->GetElseStatement());
auto boundBlock = this->BindStatement(conditionalStatement->GetBlock());
BoundStatement *elseStatement = nullptr;
if (conditionalStatement->GetElseStatement() != nullptr) {
elseStatement = this->BindStatement(conditionalStatement->GetElseStatement());
}
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 scope = this->_scope->Exists(key.GetHash());
if (scope == -1){
this -> _scriptData -> Diagnostics->LogError(DiagnosticCode::VariableNotFound, expression->GetStartPosition(), expression->GetLength());
if (scope == -1) {
this->_scriptData->Diagnostics->LogError(DiagnosticCode::VariableNotFound, expression->GetStartPosition(),
expression->GetLength());
return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
}
auto var = this->_scope->GetVariable(scope, key.GetHash());
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){
auto boundLeft = this -> BindExpression(expression->GetLeft());
auto boundRight = this -> BindExpression(expression->GetRight());
BoundExpression *Binder::BindBinaryOperator(const BinaryExpression *expression) {
auto boundLeft = this->BindExpression(expression->GetLeft());
auto boundRight = this->BindExpression(expression->GetRight());
auto boundLeftType = boundLeft->GetType();
auto boundRightType = boundRight->GetType();
switch (expression->GetOperatorKind()){
case BinaryOperatorKind ::Addition:
if (boundLeftType->GetClass() == TypeClass::Number && boundRightType->GetClass() == TypeClass::Number){
switch (expression->GetOperatorKind()) {
case BinaryOperatorKind::Addition:
if (boundLeftType->GetClass() == TypeClass::Number && boundRightType->GetClass() == TypeClass::Number) {
auto leftNumeric = std::dynamic_pointer_cast<NumericScriptType>(boundLeftType);
auto rightNumeric = std::dynamic_pointer_cast<NumericScriptType>(boundRightType);
if (leftNumeric->IsAwareOfFloat() && rightNumeric->IsAwareOfFloat()){
if (leftNumeric->IsAwareOfFloat() && rightNumeric->IsAwareOfFloat()) {
return new BoundBinaryExpression(boundLeft, boundRight,
BoundBinaryOperation::Addition,
std::make_shared<NumericScriptType>(true, leftNumeric->IsFloat() || rightNumeric->IsFloat()),
std::make_shared<NumericScriptType>(true,
leftNumeric->IsFloat() ||
rightNumeric->IsFloat()),
expression->GetStartPosition(), expression->GetLength());
}
else{
} else {
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Addition,
std::make_shared<NumericScriptType>(false, false),
expression->GetStartPosition(), expression->GetLength());
}
} else if (boundLeftType->GetClass() == TypeClass::String){
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Concatenation, std::make_shared<StringScriptType>(false,
} else if (boundLeftType->GetClass() == TypeClass::String) {
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Concatenation,
std::make_shared<StringScriptType>(false,
0),
expression->GetStartPosition(), expression->GetLength());
}
break;
case BinaryOperatorKind ::Subtraction:
if (boundLeftType->GetClass() == TypeClass::Number && boundRightType->GetClass() == TypeClass::Number){
case BinaryOperatorKind::Subtraction:
if (boundLeftType->GetClass() == TypeClass::Number && boundRightType->GetClass() == TypeClass::Number) {
auto leftNumeric = std::dynamic_pointer_cast<NumericScriptType>(boundLeftType);
auto rightNumeric = std::dynamic_pointer_cast<NumericScriptType>(boundRightType);
if (leftNumeric->IsAwareOfFloat() && rightNumeric->IsAwareOfFloat()){
if (leftNumeric->IsAwareOfFloat() && rightNumeric->IsAwareOfFloat()) {
return new BoundBinaryExpression(boundLeft, boundRight,
BoundBinaryOperation::Subtraction,
std::make_shared<NumericScriptType>(true, leftNumeric->IsFloat() || rightNumeric->IsFloat()),
std::make_shared<NumericScriptType>(true,
leftNumeric->IsFloat() ||
rightNumeric->IsFloat()),
expression->GetStartPosition(), expression->GetLength());
}
else{
} else {
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Subtraction,
std::make_shared<NumericScriptType>(false, false),
expression->GetStartPosition(), expression->GetLength());
}
}
break;
case BinaryOperatorKind ::Multiplication:
if (boundLeftType->GetClass() == TypeClass::Number && boundRightType->GetClass() == TypeClass::Number){
case BinaryOperatorKind::Multiplication:
if (boundLeftType->GetClass() == TypeClass::Number && boundRightType->GetClass() == TypeClass::Number) {
auto leftNumeric = std::dynamic_pointer_cast<NumericScriptType>(boundLeftType);
auto rightNumeric = std::dynamic_pointer_cast<NumericScriptType>(boundRightType);
if (leftNumeric->IsAwareOfFloat() && rightNumeric->IsAwareOfFloat()){
if (leftNumeric->IsAwareOfFloat() && rightNumeric->IsAwareOfFloat()) {
return new BoundBinaryExpression(boundLeft, boundRight,
BoundBinaryOperation::Multiplication,
std::make_shared<NumericScriptType>(true, leftNumeric->IsFloat() || rightNumeric->IsFloat()),
std::make_shared<NumericScriptType>(true,
leftNumeric->IsFloat() ||
rightNumeric->IsFloat()),
expression->GetStartPosition(), expression->GetLength());
}
else{
} else {
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Multiplication,
std::make_shared<NumericScriptType>(false, false),
expression->GetStartPosition(), expression->GetLength());
}
}
break;
case BinaryOperatorKind ::Division:
if (boundLeftType->GetClass() == TypeClass::Number && boundRightType->GetClass() == TypeClass::Number){
case BinaryOperatorKind::Division:
if (boundLeftType->GetClass() == TypeClass::Number && boundRightType->GetClass() == TypeClass::Number) {
auto leftNumeric = std::dynamic_pointer_cast<NumericScriptType>(boundLeftType);
auto rightNumeric = std::dynamic_pointer_cast<NumericScriptType>(boundRightType);
if (leftNumeric->IsAwareOfFloat() && rightNumeric->IsAwareOfFloat()){
if (leftNumeric->IsAwareOfFloat() && rightNumeric->IsAwareOfFloat()) {
return new BoundBinaryExpression(boundLeft, boundRight,
BoundBinaryOperation::Division,
std::make_shared<NumericScriptType>(true, leftNumeric->IsFloat() || rightNumeric->IsFloat()),
std::make_shared<NumericScriptType>(true,
leftNumeric->IsFloat() ||
rightNumeric->IsFloat()),
expression->GetStartPosition(), expression->GetLength());
}
else{
} else {
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Division,
std::make_shared<NumericScriptType>(false, false),
expression->GetStartPosition(), expression->GetLength());
}
}
break;
case BinaryOperatorKind ::Equality:
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Equality, std::make_shared<ScriptType>(TypeClass::Bool),
case BinaryOperatorKind::Equality:
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Equality,
std::make_shared<ScriptType>(TypeClass::Bool),
expression->GetStartPosition(), expression->GetLength());
case BinaryOperatorKind ::Inequality:
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Inequality, std::make_shared<ScriptType>(TypeClass::Bool),
case BinaryOperatorKind::Inequality:
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::Inequality,
std::make_shared<ScriptType>(TypeClass::Bool),
expression->GetStartPosition(), expression->GetLength());
case BinaryOperatorKind ::Less:
if (boundLeft->GetType()->GetClass() == TypeClass::Number && boundRight->GetType()->GetClass() == TypeClass::Number){
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::LessThan, std::make_shared<ScriptType>(TypeClass::Bool),
case BinaryOperatorKind::Less:
if (boundLeft->GetType()->GetClass() == TypeClass::Number &&
boundRight->GetType()->GetClass() == TypeClass::Number) {
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::LessThan,
std::make_shared<ScriptType>(TypeClass::Bool),
expression->GetStartPosition(), expression->GetLength());
}
case BinaryOperatorKind ::LessOrEquals:
if (boundLeft->GetType()->GetClass() == TypeClass::Number && boundRight->GetType()->GetClass() == TypeClass::Number){
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::LessThanEquals, std::make_shared<ScriptType>(TypeClass::Bool),
case BinaryOperatorKind::LessOrEquals:
if (boundLeft->GetType()->GetClass() == TypeClass::Number &&
boundRight->GetType()->GetClass() == TypeClass::Number) {
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::LessThanEquals,
std::make_shared<ScriptType>(TypeClass::Bool),
expression->GetStartPosition(), expression->GetLength());
}
case BinaryOperatorKind ::Greater:
if (boundLeft->GetType()->GetClass() == TypeClass::Number && boundRight->GetType()->GetClass() == TypeClass::Number){
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::GreaterThan, std::make_shared<ScriptType>(TypeClass::Bool),
case BinaryOperatorKind::Greater:
if (boundLeft->GetType()->GetClass() == TypeClass::Number &&
boundRight->GetType()->GetClass() == TypeClass::Number) {
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::GreaterThan,
std::make_shared<ScriptType>(TypeClass::Bool),
expression->GetStartPosition(), expression->GetLength());
}
case BinaryOperatorKind ::GreaterOrEquals:
if (boundLeft->GetType()->GetClass() == TypeClass::Number && boundRight->GetType()->GetClass() == TypeClass::Number){
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::GreaterThanEquals, std::make_shared<ScriptType>(TypeClass::Bool),
case BinaryOperatorKind::GreaterOrEquals:
if (boundLeft->GetType()->GetClass() == TypeClass::Number &&
boundRight->GetType()->GetClass() == TypeClass::Number) {
return new BoundBinaryExpression(boundLeft, boundRight, BoundBinaryOperation::GreaterThanEquals,
std::make_shared<ScriptType>(TypeClass::Bool),
expression->GetStartPosition(), expression->GetLength());
}
case BinaryOperatorKind ::LogicalAnd:
case BinaryOperatorKind::LogicalAnd:
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());
break;
case BinaryOperatorKind ::LogicalOr:
case BinaryOperatorKind::LogicalOr:
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());
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());
}
}
BoundExpression* Binder::BindUnaryOperator(const UnaryExpression* expression){
auto operand = this -> BindExpression(expression->GetOperand());
auto operandType = operand -> GetType();
switch (expression->GetOperatorKind()){
case UnaryOperatorKind ::Identity:
if (operandType->GetClass() == TypeClass::Number){
BoundExpression *Binder::BindUnaryOperator(const UnaryExpression *expression) {
auto operand = this->BindExpression(expression->GetOperand());
auto operandType = operand->GetType();
switch (expression->GetOperatorKind()) {
case UnaryOperatorKind::Identity:
if (operandType->GetClass() == TypeClass::Number) {
// Identity won't change anything during evaluation, so just return the inner operand.
return operand;
}
break;
case UnaryOperatorKind ::Negation:
if (operandType->GetClass() == TypeClass::Number){
case UnaryOperatorKind::Negation:
if (operandType->GetClass() == TypeClass::Number) {
auto innerType = std::dynamic_pointer_cast<NumericScriptType>(operandType);
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());
}
break;
case UnaryOperatorKind ::LogicalNegation:
if (operandType->GetClass() == TypeClass::Bool){
case UnaryOperatorKind::LogicalNegation:
if (operandType->GetClass() == TypeClass::Bool) {
return new BoundUnaryExpression(operand, BoundUnaryOperation::LogicalNegation,
std::make_shared<ScriptType>(TypeClass::Bool),
expression->GetStartPosition(), expression->GetLength());
@ -388,33 +435,37 @@ BoundExpression* Binder::BindUnaryOperator(const UnaryExpression* expression){
default:
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());
}
}
BoundExpression* Binder::BindFunctionCall(const FunctionCallExpression* expression){
BoundExpression *Binder::BindFunctionCall(const FunctionCallExpression *expression) {
auto functionExpression = BindExpression(expression->GetFunction());
auto type = functionExpression->GetType();
if (type->GetClass() != TypeClass::Function){
this->_scriptData->Diagnostics->LogError(DiagnosticCode::ExpressionIsNotAFunction, expression->GetStartPosition(),
if (type->GetClass() != TypeClass::Function) {
this->_scriptData->Diagnostics->LogError(DiagnosticCode::ExpressionIsNotAFunction,
expression->GetStartPosition(),
expression->GetLength());
return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
}
auto functionType = std::dynamic_pointer_cast<FunctionScriptType>(type);
auto parameterTypes = functionType->GetParameterTypes();
auto givenParameters = expression->GetParameters();
if (parameterTypes.size() != givenParameters->size()){
this->_scriptData->Diagnostics->LogError(DiagnosticCode::ParameterCountMismatch, expression->GetStartPosition(),
if (parameterTypes.size() != givenParameters->size()) {
this->_scriptData->Diagnostics->LogError(DiagnosticCode::ParameterCountMismatch,
expression->GetStartPosition(),
expression->GetLength());
return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
}
vector<BoundExpression*> boundParameters = vector<BoundExpression*>(givenParameters->size());
for (int i = 0; i < givenParameters->size(); i++){
auto parameter = givenParameters -> at(i);
auto boundParameter = this -> BindExpression(parameter);
if (boundParameter->GetType().get()->operator!=(parameterTypes.at(i).get())){
this->_scriptData->Diagnostics->LogError(DiagnosticCode::ParameterTypeMismatch, parameter->GetStartPosition(),
vector<BoundExpression *> boundParameters = vector<BoundExpression *>(givenParameters->size());
for (int i = 0; i < givenParameters->size(); i++) {
auto parameter = givenParameters->at(i);
auto boundParameter = this->BindExpression(parameter);
if (boundParameter->GetType().get()->operator!=(parameterTypes.at(i).get())) {
this->_scriptData->Diagnostics->LogError(DiagnosticCode::ParameterTypeMismatch,
parameter->GetStartPosition(),
parameter->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(),
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 index = this->BindExpression(expression->GetIndex());
auto indexerType = indexer -> GetType();
if (!indexerType->CanBeIndexedWith(index->GetType().get())){
auto indexerType = indexer->GetType();
if (!indexerType->CanBeIndexedWith(index->GetType().get())) {
this->_scriptData->Diagnostics->LogError(DiagnosticCode::CantIndex, index->GetStartPosition(),
index->GetLength());
return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
}
if (indexerType -> GetClass() == TypeClass::UserData){
auto stringKey = dynamic_pointer_cast<StringScriptType>(index -> GetType());
auto field = dynamic_pointer_cast<UserDataScriptType>(indexerType) -> GetField(stringKey->GetHashValue());
if (!setter){
if (!field->HasGetter()){
this->_scriptData->Diagnostics->LogError(DiagnosticCode::UserDataFieldNoGetter, index->GetStartPosition(),
if (indexerType->GetClass() == TypeClass::UserData) {
auto stringKey = dynamic_pointer_cast<StringScriptType>(index->GetType());
auto field = dynamic_pointer_cast<UserData::UserDataScriptType>(indexerType)->GetField(stringKey->GetHashValue());
if (!setter) {
if (!field->HasGetter()) {
this->_scriptData->Diagnostics->LogError(DiagnosticCode::UserDataFieldNoGetter,
index->GetStartPosition(),
index->GetLength());
return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
}
} else{
if (!field->HasSetter()){
this->_scriptData->Diagnostics->LogError(DiagnosticCode::UserDataFieldNoSetter, index->GetStartPosition(),
} else {
if (!field->HasSetter()) {
this->_scriptData->Diagnostics->LogError(DiagnosticCode::UserDataFieldNoSetter,
index->GetStartPosition(),
index->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());
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());
const auto& identifier = expression->GetIndex();
const auto& indexerType = indexer -> GetType();
if (!indexerType -> CanBeIndexedWithIdentifier(identifier.GetHash())){
const auto &identifier = expression->GetIndex();
const auto &indexerType = indexer->GetType();
if (!indexerType->CanBeIndexedWithIdentifier(identifier.GetHash())) {
this->_scriptData->Diagnostics->LogError(DiagnosticCode::CantIndex, expression->GetStartPosition(),
expression->GetLength());
return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
}
if (indexerType -> GetClass() == TypeClass::UserData){
auto field = dynamic_pointer_cast<UserDataScriptType>(indexerType) -> GetField(identifier . GetHash());
if (!setter){
if (!field->HasGetter()){
this->_scriptData->Diagnostics->LogError(DiagnosticCode::UserDataFieldNoGetter, expression->GetStartPosition(),
if (indexerType->GetClass() == TypeClass::UserData) {
auto field = dynamic_pointer_cast<UserData::UserDataScriptType>(indexerType)->GetField(identifier.GetHash());
if (!setter) {
if (!field->HasGetter()) {
this->_scriptData->Diagnostics->LogError(DiagnosticCode::UserDataFieldNoGetter,
expression->GetStartPosition(),
expression->GetLength());
return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
}
} else{
if (!field->HasSetter()){
this->_scriptData->Diagnostics->LogError(DiagnosticCode::UserDataFieldNoSetter, expression->GetStartPosition(),
} else {
if (!field->HasSetter()) {
this->_scriptData->Diagnostics->LogError(DiagnosticCode::UserDataFieldNoSetter,
expression->GetStartPosition(),
expression->GetLength());
return new BoundBadExpression(expression->GetStartPosition(), expression->GetLength());
}
}
}
auto resultType = indexer->GetType()->GetIndexedType(identifier . GetHash());
return new BoundPeriodIndexExpression(indexer, identifier, resultType, expression->GetStartPosition(), expression->GetLength());
auto resultType = indexer->GetType()->GetIndexedType(identifier.GetHash());
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 boundExpressions = vector<const BoundExpression*>(expressions-> size());
auto boundExpressions = vector<const BoundExpression *>(expressions->size());
shared_ptr<ScriptType> valueType = nullptr;
if (!boundExpressions.empty()){
boundExpressions[0] = this -> BindExpression(expressions -> at(0));
valueType = boundExpressions[0] -> GetType();
for (int i = 1; i < expressions->size(); i++){
boundExpressions[i] = this -> BindExpression(expressions -> at(i));
if (boundExpressions[i] -> GetType().get()->operator!=(valueType.get())){
this->_scriptData->Diagnostics->LogError(DiagnosticCode::InvalidTableValueType, boundExpressions[i]->GetStartPosition(),
if (!boundExpressions.empty()) {
boundExpressions[0] = this->BindExpression(expressions->at(0));
valueType = boundExpressions[0]->GetType();
for (int i = 1; i < expressions->size(); i++) {
boundExpressions[i] = this->BindExpression(expressions->at(i));
if (boundExpressions[i]->GetType().get()->operator!=(valueType.get())) {
this->_scriptData->Diagnostics->LogError(DiagnosticCode::InvalidTableValueType,
boundExpressions[i]->GetStartPosition(),
boundExpressions[i]->GetLength());
}
}
}
if (valueType == nullptr){
if (valueType == nullptr) {
valueType = std::make_shared<ScriptType>(TypeClass::Nil);
}
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) {
auto tableScope = new unordered_map<uint32_t, BoundVariable*>();
BoundExpression *Binder::BindTableExpression(const ParsedTableExpression *expression) {
auto tableScope = new unordered_map<uint32_t, BoundVariable *>();
auto innerScope = new BoundScope(tableScope);
auto currentScope = this -> _scope;
this -> _scope = innerScope;
auto block = this -> BindBlockStatement(expression -> GetBlock());
this -> _scope = currentScope;
auto currentScope = this->_scope;
this->_scope = innerScope;
auto block = this->BindBlockStatement(expression->GetBlock());
this->_scope = currentScope;
auto tableType = std::make_shared<TableScriptType>(tableScope, innerScope->GetLocalVariableCount());
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"
using namespace std;
using namespace Porygon::Parser;
class Binder {
Script* _scriptData;
BoundScope* _scope;
namespace Porygon::Binder {
class Binder {
Porygon::Script *_scriptData;
BoundScope *_scope;
shared_ptr<FunctionScriptType> _currentFunction;
~Binder();
BoundStatement *BindStatement(const ParsedStatement *statement);
BoundStatement *BindBlockStatement(const ParsedStatement *statement);
BoundStatement *BindExpressionStatement(const ParsedStatement *statement);
BoundStatement *BindAssignmentStatement(const ParsedStatement *statement);
BoundStatement *BindIndexAssignmentStatement(const ParsedStatement *statement);
BoundStatement *BindFunctionDeclarationStatement(const ParsedStatement * statement);
BoundStatement *BindFunctionDeclarationStatement(const ParsedStatement *statement);
BoundStatement *BindReturnStatement(const ParsedStatement *statement);
BoundStatement *BindConditionalStatement(const ParsedStatement *statement);
BoundExpression *BindExpression(const ParsedExpression *expression);
BoundExpression *BindVariableExpression(const VariableExpression *expression);
BoundExpression *BindBinaryOperator(const BinaryExpression *expression);
BoundExpression *BindUnaryOperator(const UnaryExpression *expression);
BoundExpression *BindFunctionCall(const FunctionCallExpression *expression);
BoundExpression *BindIndexExpression(const IndexExpression *expression, bool setter);
BoundExpression *BindNumericalTableExpression(const ParsedNumericalTableExpression *expression);
BoundExpression *BindTableExpression(const ParsedTableExpression * expression);
public:
static BoundScriptStatement* Bind(Script* script, const ParsedScriptStatement* s, BoundScope* scriptScope);
BoundExpression *BindTableExpression(const ParsedTableExpression *expression);
public:
static BoundScriptStatement *
Bind(Porygon::Script *script, const ParsedScriptStatement *s, BoundScope *scriptScope);
BoundExpression *BindPeriodIndexExpression(const PeriodIndexExpression *expression, bool setter);
};
};
}
#endif //PORYGONLANG_BINDER_HPP

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

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

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

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

10
src/Binder/BoundOperators.hpp
View File

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

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

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

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

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

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

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

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

@ -13,31 +13,38 @@
using namespace std;
class BoundScope {
unordered_map<uint32_t, BoundVariable*>* _tableScope;
vector<unordered_map<uint32_t, BoundVariable*>*> _localScope;
namespace Porygon::Binder {
class BoundScope {
unordered_map<uint32_t, BoundVariable *> *_tableScope;
vector<unordered_map<uint32_t, BoundVariable *> *> _localScope;
int _currentScope;
int _lastCreatedScope;
public:
explicit BoundScope(unordered_map<uint32_t, BoundVariable*> *tableScope);
public:
explicit BoundScope(unordered_map<uint32_t, BoundVariable *> *tableScope);
~BoundScope();
void GoInnerScope();
void GoOuterScope();
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();
}
int GetCurrentScope(){
int GetCurrentScope() {
return _currentScope;
}
};
};
}
#endif //PORYGONLANG_BOUNDSCOPE_HPP

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

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

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

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

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

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

94
src/Evaluator/BinaryEvaluation.cpp
View File

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

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

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

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

@ -8,77 +8,83 @@
#include <sstream>
#include <memory>
class EvalValue{
public:
namespace Porygon::Evaluation {
class EvalValue {
public:
EvalValue() = default;
virtual ~EvalValue() = default;
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{
return ! (this->operator==(b));
virtual const bool operator!=(EvalValue *b) const {
return !(this->operator==(b));
}
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.");
}
virtual const double EvaluateFloat() const{
virtual const double EvaluateFloat() const {
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.");
}
virtual const std::u16string* EvaluateString() const {
virtual const std::u16string *EvaluateString() const {
throw EvaluationException("Can't evaluate this EvalValue as string.");
}
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");
}
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");
}
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");
}
};
};
class BooleanEvalValue : public EvalValue{
class BooleanEvalValue : public EvalValue {
const bool _value;
public:
public:
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);
}
const TypeClass GetTypeClass() const final{
return TypeClass ::Bool;
const TypeClass GetTypeClass() const final {
return TypeClass::Bool;
}
const bool EvaluateBool() const final{
const bool EvaluateBool() const final {
return _value;
}
const bool operator ==(EvalValue* b) const final{
const bool operator==(EvalValue *b) const final {
if (b->GetTypeClass() != TypeClass::Bool)
return false;
return this->EvaluateBool() == b->EvaluateBool();
};
const std::size_t GetHashCode() const final{
const std::size_t GetHashCode() const final {
return _value;
}
};
};
}
#endif //PORYGONLANG_EVALVALUE_HPP

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

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

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

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

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

@ -11,63 +11,65 @@
#include "../Evaluator.hpp"
#include "../EvaluationScope/EvaluationScope.hpp"
class ScriptFunctionEvalValue : public EvalValue{
namespace Porygon::Evaluation {
class ScriptFunctionEvalValue : public EvalValue {
const std::shared_ptr<BoundBlockStatement> _innerBlock;
const std::shared_ptr<FunctionScriptType> _type;
const std::shared_ptr<EvaluationScope> _scope;
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)
: _type(std::move(type)),
_innerBlock(std::move(innerBlock)),
_scope(std::move(scope)),
_hash(hash)
{
_hash(hash) {
}
public:
explicit ScriptFunctionEvalValue(std::shared_ptr<BoundBlockStatement> innerBlock, std::shared_ptr<EvaluationScope> scope,
public:
explicit ScriptFunctionEvalValue(std::shared_ptr<BoundBlockStatement> innerBlock,
std::shared_ptr<EvaluationScope> scope,
std::shared_ptr<FunctionScriptType> type)
: _type(std::move(type)),
_innerBlock(std::move(innerBlock)),
_scope(std::move(scope)),
_hash(rand())
{
_hash(rand()) {
}
const std::shared_ptr<ScriptType> GetType() const{
const std::shared_ptr<ScriptType> GetType() const {
return _type;
}
const TypeClass GetTypeClass() const final{
return TypeClass ::Function;
const TypeClass GetTypeClass() const final {
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
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)
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;
}
const std::size_t GetHashCode() const final{
const std::size_t GetHashCode() const final {
return _hash;
}
const std::shared_ptr<EvaluationScope>& GetScope() const{
const std::shared_ptr<EvaluationScope> &GetScope() const {
return _scope;
}
};
};
}
#endif //PORYGONLANG_SCRIPTFUNCTIONEVALVALUE_HPP

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

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

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

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

14
src/Evaluator/EvaluationException.hpp
View File

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

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

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

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

@ -5,18 +5,24 @@
#include <unordered_map>
#include <vector>
#include "../EvalValues/EvalValue.hpp"
using namespace Porygon::Binder;
class EvaluationScope {
unordered_map<uint32_t, shared_ptr<EvalValue>>* _scriptScope;
namespace Porygon::Evaluation {
class EvaluationScope {
unordered_map<uint32_t, shared_ptr<EvalValue>> *_scriptScope;
unordered_map<uint64_t, shared_ptr<EvalValue>> _localScope;
public:
explicit EvaluationScope(unordered_map<uint32_t, shared_ptr<EvalValue>>* scriptVariables, int deepestScope);
public:
explicit EvaluationScope(unordered_map<uint32_t, shared_ptr<EvalValue>> *scriptVariables, int deepestScope);
~EvaluationScope() = default;
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 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);
};
}
#endif //PORYGONLANG_EVALUATIONSCOPE_HPP

388
src/Evaluator/Evaluator.cpp
View File

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

16
src/Evaluator/Evaluator.hpp
View File

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

22
src/Evaluator/UnaryEvaluation.cpp
View File

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

7
src/Parser/BinaryOperatorKind.hpp
View File

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

321
src/Parser/Lexer.cpp
View File

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

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

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

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

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

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

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

538
src/Parser/Parser.cpp
View File

@ -7,218 +7,241 @@
#include "TypedVariableIdentifier.hpp"
#include "ParsedExpressions/ParsedTableExpression.hpp"
ParsedScriptStatement* Parser::Parse() {
vector<const ParsedStatement*> statements;
while (this->_position < this->_tokens.size()){
auto next = this -> Next();
if (next->GetKind() == TokenKind::EndOfFile){
namespace Porygon::Parser {
ParsedScriptStatement *Parser::Parse() {
vector<const ParsedStatement *> statements;
while (this->_position < this->_tokens.size()) {
auto next = this->Next();
if (next->GetKind() == TokenKind::EndOfFile) {
break;
}
statements.push_back(this -> ParseStatement(next));
statements.push_back(this->ParseStatement(next));
}
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);
}
auto expression = this -> ParseExpression(current);
auto expKind = expression -> GetKind();
auto expression = this->ParseExpression(current);
auto expKind = expression->GetKind();
if ((expKind == ParsedExpressionKind::Indexer || expKind == ParsedExpressionKind::PeriodIndexer)
&& this -> Peek()->GetKind() == TokenKind::AssignmentToken){
return this -> ParseIndexAssignment(expression);
&& this->Peek()->GetKind() == TokenKind::AssignmentToken) {
return this->ParseIndexAssignment(expression);
}
return new ParsedExpressionStatement(expression);
}
}
ParsedStatement *Parser::ParseVariableAssignment(const IToken *current) {
ParsedStatement *Parser::ParseVariableAssignment(const IToken *current) {
bool isLocal = false;
const IToken* identifier;
if (current -> GetKind() == TokenKind::LocalKeyword){
const IToken *identifier;
if (current->GetKind() == TokenKind::LocalKeyword) {
isLocal = true;
identifier = this -> Next();
} else{
identifier = this->Next();
} else {
identifier = current;
}
auto assignmentToken = this->Next();
auto expression = this -> ParseExpression(this -> Next());
auto expression = this->ParseExpression(this->Next());
if (identifier -> GetKind() != TokenKind::Identifier){
this -> ScriptData -> Diagnostics -> LogError(DiagnosticCode::UnexpectedToken, identifier->GetStartPosition(), identifier->GetLength());
if (identifier->GetKind() != TokenKind::Identifier) {
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, identifier->GetStartPosition(),
identifier->GetLength());
return new ParsedBadStatement(identifier->GetStartPosition(), identifier->GetLength());
}
if (assignmentToken -> GetKind() != TokenKind::AssignmentToken){
this -> ScriptData -> Diagnostics -> LogError(DiagnosticCode::UnexpectedToken, identifier->GetStartPosition(), identifier->GetLength());
if (assignmentToken->GetKind() != TokenKind::AssignmentToken) {
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, identifier->GetStartPosition(),
identifier->GetLength());
return new ParsedBadStatement(identifier->GetStartPosition(), identifier->GetLength());
}
auto start = current -> GetStartPosition();
return new ParsedAssignmentStatement(isLocal, ((IdentifierToken*)identifier) -> GetValue(), expression, start, expression->GetEndPosition() - start);
}
auto start = current->GetStartPosition();
return new ParsedAssignmentStatement(isLocal, ((IdentifierToken *) identifier)->GetValue(), expression, start,
expression->GetEndPosition() - start);
}
ParsedStatement *Parser::ParseIndexAssignment(ParsedExpression *indexer) {
this -> Next(); // Consume assignment token
auto valueExpression = this -> ParseExpression(this -> Next());
ParsedStatement *Parser::ParseIndexAssignment(ParsedExpression *indexer) {
this->Next(); // Consume assignment token
auto valueExpression = this->ParseExpression(this->Next());
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 start = this->_position;
while (this->_position < this->_tokens.size()){
auto next = this -> Next();
while (this->_position < this->_tokens.size()) {
auto next = this->Next();
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;
}
if (nextKind == TokenKind::EndOfFile){
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, next->GetStartPosition(), next->GetLength());
if (nextKind == TokenKind::EndOfFile) {
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, next->GetStartPosition(),
next->GetLength());
break;
}
statements.push_back(this -> ParseStatement(next));
statements.push_back(this->ParseStatement(next));
}
if (statements.empty()){
return new ParsedBlockStatement(statements,start);
if (statements.empty()) {
return new ParsedBlockStatement(statements, start);
}
return new ParsedBlockStatement(statements);
}
}
ParsedStatement *Parser::ParseFunctionDeclaration(const IToken *current) {
ParsedStatement *Parser::ParseFunctionDeclaration(const IToken *current) {
auto functionIdentifierToken = this->Next();
auto openParenthesis = this->Next();
vector<TypedVariableIdentifier*> parameters;
vector<TypedVariableIdentifier *> parameters;
bool hasErrors = false;
if (functionIdentifierToken->GetKind() != TokenKind::Identifier){
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, functionIdentifierToken->GetStartPosition(), functionIdentifierToken->GetLength());
if (functionIdentifierToken->GetKind() != TokenKind::Identifier) {
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken,
functionIdentifierToken->GetStartPosition(),
functionIdentifierToken->GetLength());
hasErrors = true;
}
if (openParenthesis->GetKind() != TokenKind::OpenParenthesis && !hasErrors){
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, openParenthesis->GetStartPosition(), openParenthesis->GetLength());
if (openParenthesis->GetKind() != TokenKind::OpenParenthesis && !hasErrors) {
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken,
openParenthesis->GetStartPosition(), openParenthesis->GetLength());
hasErrors = true;
}
while (this -> _position < this->_tokens.size()){
while (this->_position < this->_tokens.size()) {
auto type = this->Next();
if (type->GetKind() == TokenKind::CloseParenthesis){
if (type->GetKind() == TokenKind::CloseParenthesis) {
break;
}
auto identifier = this->Next();
auto next = this->Next();
if (type->GetKind() != TokenKind::Identifier &&!hasErrors){
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, type->GetStartPosition(), type->GetLength());
if (type->GetKind() != TokenKind::Identifier && !hasErrors) {
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, type->GetStartPosition(),
type->GetLength());
hasErrors = true;
continue;
}
if (identifier->GetKind() != TokenKind::Identifier &&!hasErrors){
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, identifier->GetStartPosition(), identifier->GetLength());
if (identifier->GetKind() != TokenKind::Identifier && !hasErrors) {
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, identifier->GetStartPosition(),
identifier->GetLength());
hasErrors = true;
continue;
}
if (type->GetKind() != TokenKind::Identifier || identifier->GetKind() != TokenKind::Identifier){
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, type->GetStartPosition(), type->GetLength());
if (type->GetKind() != TokenKind::Identifier || identifier->GetKind() != TokenKind::Identifier) {
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, type->GetStartPosition(),
type->GetLength());
hasErrors = true;
continue;
}
auto typeToken = (IdentifierToken*)type;
auto identifierToken = (IdentifierToken*)identifier;
auto typeToken = (IdentifierToken *) type;
auto identifierToken = (IdentifierToken *) identifier;
parameters.push_back(new TypedVariableIdentifier(typeToken->GetValue(), identifierToken->GetValue()));
auto nextKind = next->GetKind();
if (nextKind == TokenKind::CloseParenthesis || nextKind == TokenKind::EndOfFile){
if (nextKind == TokenKind::CloseParenthesis || nextKind == TokenKind::EndOfFile) {
break;
} else if (nextKind != TokenKind::CommaToken && !hasErrors){
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, next->GetStartPosition(), next->GetLength());
} else if (nextKind != TokenKind::CommaToken && !hasErrors) {
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, next->GetStartPosition(),
next->GetLength());
hasErrors = true;
}
}
auto block = this -> ParseBlock({TokenKind ::EndKeyword});
auto block = this->ParseBlock({TokenKind::EndKeyword});
auto start = current->GetStartPosition();
if (hasErrors){
if (hasErrors) {
return new ParsedBadStatement(start, block->GetEndPosition() - start);
}
if (block->GetKind() == ParsedStatementKind::Bad){
if (block->GetKind() == ParsedStatementKind::Bad) {
return new ParsedBadStatement(start, block->GetEndPosition() - start);
}
auto functionIdentifier = ((IdentifierToken*) functionIdentifierToken)->GetValue();
return new ParsedFunctionDeclarationStatement(HashedString(functionIdentifier), parameters, (ParsedBlockStatement*)block, start, block->GetEndPosition() - start);
}
auto functionIdentifier = ((IdentifierToken *) functionIdentifierToken)->GetValue();
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.
auto expression = this->ParseExpression(this->Next());
auto start = current->GetStartPosition();
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 next = this -> Next();
if (next->GetKind() != TokenKind::ThenKeyword){
this -> ScriptData -> Diagnostics -> LogError(DiagnosticCode::UnexpectedToken, next->GetStartPosition(), next->GetLength());
auto next = this->Next();
if (next->GetKind() != TokenKind::ThenKeyword) {
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, 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 start = current->GetStartPosition();
if (closeToken->GetKind() == TokenKind::ElseIfKeyword){
auto elseIfStatement = this -> ParseIfStatement(closeToken);
return new ParsedConditionalStatement(condition, block, elseIfStatement, start, elseIfStatement->GetEndPosition() - start);
} else if (closeToken->GetKind() == TokenKind::ElseKeyword){
auto elseStatement = this -> ParseBlock({TokenKind ::EndKeyword});
return new ParsedConditionalStatement(condition, block, elseStatement, start, elseStatement->GetEndPosition() - start);
if (closeToken->GetKind() == TokenKind::ElseIfKeyword) {
auto elseIfStatement = this->ParseIfStatement(closeToken);
return new ParsedConditionalStatement(condition, block, elseIfStatement, start,
elseIfStatement->GetEndPosition() - start);
} else if (closeToken->GetKind() == TokenKind::ElseKeyword) {
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);
}
}
ParsedExpression* Parser::ParseExpression(const IToken* current){
auto expression = this -> ParseBinaryExpression(current, OperatorPrecedence::No);
ParsedExpression *Parser::ParseExpression(const IToken *current) {
auto expression = this->ParseBinaryExpression(current, OperatorPrecedence::No);
auto peekKind = this->Peek()->GetKind();
while (peekKind == TokenKind::OpenParenthesis ||
peekKind == TokenKind::OpenSquareBracket ||
peekKind == TokenKind::PeriodToken){
if (peekKind == TokenKind::OpenParenthesis){
peekKind == TokenKind::PeriodToken) {
if (peekKind == TokenKind::OpenParenthesis) {
expression = this->ParseFunctionCallExpression(expression);
} else if (peekKind == TokenKind::OpenSquareBracket){
} else if (peekKind == TokenKind::OpenSquareBracket) {
expression = this->ParseIndexExpression(expression);
} else {
expression = this -> ParsePeriodIndexExpression(expression);
expression = this->ParsePeriodIndexExpression(expression);
}
if (this -> _position >= this->_tokens.size())
if (this->_position >= this->_tokens.size())
break;
peekKind = this->Peek()->GetKind();
}
return expression;
}
}
OperatorPrecedence GetUnaryPrecedence(TokenKind kind){
switch (kind){
OperatorPrecedence GetUnaryPrecedence(TokenKind kind) {
switch (kind) {
case TokenKind::PlusToken:
case TokenKind::MinusToken:
case TokenKind::NotKeyword:
@ -226,207 +249,254 @@ OperatorPrecedence GetUnaryPrecedence(TokenKind kind){
default:
return OperatorPrecedence::No;
}
}
}
UnaryOperatorKind GetUnaryOperatorKind(TokenKind kind){
switch (kind){
case TokenKind::PlusToken: return UnaryOperatorKind::Identity;
case TokenKind::MinusToken: return UnaryOperatorKind::Negation;
case TokenKind::NotKeyword: return UnaryOperatorKind::LogicalNegation;
UnaryOperatorKind GetUnaryOperatorKind(TokenKind kind) {
switch (kind) {
case TokenKind::PlusToken:
return UnaryOperatorKind::Identity;
case TokenKind::MinusToken:
return UnaryOperatorKind::Negation;
case TokenKind::NotKeyword:
return UnaryOperatorKind::LogicalNegation;
default: // This should never trigger, so throw.
throw;
}
}
}
BinaryOperatorKind GetBinaryOperatorKind(TokenKind kind){
switch (kind){
BinaryOperatorKind GetBinaryOperatorKind(TokenKind kind) {
switch (kind) {
// Math operators
case TokenKind::PlusToken: return BinaryOperatorKind ::Addition;
case TokenKind::MinusToken: return BinaryOperatorKind ::Subtraction;
case TokenKind::StarToken: return BinaryOperatorKind ::Multiplication;
case TokenKind::SlashToken: return BinaryOperatorKind ::Division;
case TokenKind::PlusToken:
return BinaryOperatorKind::Addition;
case TokenKind::MinusToken:
return BinaryOperatorKind::Subtraction;
case TokenKind::StarToken:
return BinaryOperatorKind::Multiplication;
case TokenKind::SlashToken:
return BinaryOperatorKind::Division;
// Equality operators
case TokenKind::EqualityToken: return BinaryOperatorKind ::Equality;
case TokenKind::InequalityToken: return BinaryOperatorKind ::Inequality;
case TokenKind ::Less: return BinaryOperatorKind ::Less;
case TokenKind ::LessEquals: return BinaryOperatorKind ::LessOrEquals;
case TokenKind ::Greater: return BinaryOperatorKind ::Greater;
case TokenKind ::GreaterEquals: return BinaryOperatorKind ::GreaterOrEquals;
case TokenKind::EqualityToken:
return BinaryOperatorKind::Equality;
case TokenKind::InequalityToken:
return BinaryOperatorKind::Inequality;
case TokenKind::Less:
return BinaryOperatorKind::Less;
case TokenKind::LessEquals:
return BinaryOperatorKind::LessOrEquals;
case TokenKind::Greater:
return BinaryOperatorKind::Greater;
case TokenKind::GreaterEquals:
return BinaryOperatorKind::GreaterOrEquals;
// logical operators
case TokenKind::AndKeyword: return BinaryOperatorKind ::LogicalAnd;
case TokenKind::OrKeyword: return BinaryOperatorKind ::LogicalOr;
case TokenKind::AndKeyword:
return BinaryOperatorKind::LogicalAnd;
case TokenKind::OrKeyword:
return BinaryOperatorKind::LogicalOr;
default: // This should never trigger, so throw.
throw;
}
}
}
OperatorPrecedence GetBinaryPrecedence(TokenKind kind){
switch (kind){
OperatorPrecedence GetBinaryPrecedence(TokenKind kind) {
switch (kind) {
// Math
case TokenKind::PlusToken: return OperatorPrecedence ::Additive;
case TokenKind::MinusToken: return OperatorPrecedence ::Additive;
case TokenKind::StarToken: return OperatorPrecedence ::Multiplication;
case TokenKind::SlashToken: return OperatorPrecedence ::Multiplication;
case TokenKind::PlusToken:
return OperatorPrecedence::Additive;
case TokenKind::MinusToken:
return OperatorPrecedence::Additive;
case TokenKind::StarToken:
return OperatorPrecedence::Multiplication;
case TokenKind::SlashToken:
return OperatorPrecedence::Multiplication;
// Equality
case TokenKind::EqualityToken: return OperatorPrecedence ::Equality;
case TokenKind::InequalityToken: return OperatorPrecedence ::Equality;
case TokenKind ::Less: return OperatorPrecedence ::Equality;
case TokenKind ::LessEquals: return OperatorPrecedence ::Equality;
case TokenKind ::Greater: return OperatorPrecedence ::Equality;
case TokenKind ::GreaterEquals: return OperatorPrecedence ::Equality;
case TokenKind::EqualityToken:
return OperatorPrecedence::Equality;
case TokenKind::InequalityToken:
return OperatorPrecedence::Equality;
case TokenKind::Less:
return OperatorPrecedence::Equality;
case TokenKind::LessEquals:
return OperatorPrecedence::Equality;
case TokenKind::Greater:
return OperatorPrecedence::Equality;
case TokenKind::GreaterEquals:
return OperatorPrecedence::Equality;
// Logical
case TokenKind::AndKeyword: return OperatorPrecedence ::LogicalAnd;
case TokenKind::OrKeyword: return OperatorPrecedence ::LogicalOr;
case TokenKind::AndKeyword:
return OperatorPrecedence::LogicalAnd;
case TokenKind::OrKeyword:
return OperatorPrecedence::LogicalOr;
default:
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();
OperatorPrecedence binaryPrecedence = GetBinaryPrecedence(next -> GetKind());
if (binaryPrecedence == OperatorPrecedence::No || binaryPrecedence <= parentPrecedence){
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();
OperatorPrecedence binaryPrecedence = GetBinaryPrecedence(next->GetKind());
if (binaryPrecedence == OperatorPrecedence::No || binaryPrecedence <= parentPrecedence) {
break;
}
auto operatorKind = GetBinaryOperatorKind(next -> GetKind());
this -> Next();
auto right = this -> ParseBinaryExpression(this -> Next(), binaryPrecedence);
auto startPos = left -> GetStartPosition();
left = new BinaryExpression(operatorKind, left, right, startPos, right -> GetEndPosition() - startPos);
auto operatorKind = GetBinaryOperatorKind(next->GetKind());
this->Next();
auto right = this->ParseBinaryExpression(this->Next(), binaryPrecedence);
auto startPos = left->GetStartPosition();
left = new BinaryExpression(operatorKind, left, right, startPos, right->GetEndPosition() - startPos);
}
return left;
}
}
ParsedExpression *Parser::ParsePrimaryExpression(const IToken *current) {
switch (current -> GetKind()){
case TokenKind ::Integer: return new LiteralIntegerExpression((IntegerToken*)current);
case TokenKind ::Float: return new LiteralFloatExpression((FloatToken*)current);
case TokenKind ::String: return new LiteralStringExpression((StringToken*)current);
case TokenKind ::TrueKeyword: 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);
ParsedExpression *Parser::ParsePrimaryExpression(const IToken *current) {
switch (current->GetKind()) {
case TokenKind::Integer:
return new LiteralIntegerExpression((IntegerToken *) current);
case TokenKind::Float:
return new LiteralFloatExpression((FloatToken *) current);
case TokenKind::String:
return new LiteralStringExpression((StringToken *) current);
case TokenKind::TrueKeyword:
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.
case TokenKind ::BadToken: return new BadExpression(current->GetStartPosition(), current->GetLength());
case TokenKind::BadToken:
return new BadExpression(current->GetStartPosition(), current->GetLength());
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());
}
}
}
ParsedExpression *Parser::ParseParenthesizedExpression(const IToken *current) {
auto next = this -> Next();
auto expression = this -> ParseExpression(next);
auto closeToken = this -> Next();
if (closeToken -> GetKind() != TokenKind::CloseParenthesis){
this -> ScriptData -> Diagnostics -> LogError(DiagnosticCode::UnexpectedToken, closeToken->GetStartPosition(), closeToken->GetLength());
ParsedExpression *Parser::ParseParenthesizedExpression(const IToken *current) {
auto next = this->Next();
auto expression = this->ParseExpression(next);
auto closeToken = this->Next();
if (closeToken->GetKind() != TokenKind::CloseParenthesis) {
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, 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);
}
}
ParsedExpression *Parser::ParseFunctionCallExpression(ParsedExpression* functionExpression) {
this -> Next(); // consume the open parenthesis
vector<const ParsedExpression*> parameters;
auto peeked = this -> Peek();
ParsedExpression *Parser::ParseFunctionCallExpression(ParsedExpression *functionExpression) {
this->Next(); // consume the open parenthesis
vector<const ParsedExpression *> parameters;
auto peeked = this->Peek();
auto peekedKind = peeked->GetKind();
if (peekedKind == TokenKind::CloseParenthesis){
if (peekedKind == TokenKind::CloseParenthesis) {
this->Next();
} else{
while (peekedKind != TokenKind::CloseParenthesis){
if (peekedKind == TokenKind ::EndOfFile){
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, peeked->GetStartPosition(), peeked->GetLength());
} else {
while (peekedKind != TokenKind::CloseParenthesis) {
if (peekedKind == TokenKind::EndOfFile) {
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, peeked->GetStartPosition(),
peeked->GetLength());
return new BadExpression(peeked->GetStartPosition(), peeked->GetLength());
}
parameters.push_back(this->ParseExpression(this->Next()));
peeked = this -> Next() ;
peeked = this->Next();
peekedKind = peeked->GetKind();
if (peekedKind != TokenKind::CloseParenthesis && peekedKind != TokenKind::CommaToken){
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, peeked->GetStartPosition(), peeked->GetLength());
if (peekedKind != TokenKind::CloseParenthesis && peekedKind != TokenKind::CommaToken) {
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, peeked->GetStartPosition(),
peeked->GetLength());
return new BadExpression(peeked->GetStartPosition(), peeked->GetLength());
}
}
}
auto start = functionExpression->GetStartPosition();
return new FunctionCallExpression(functionExpression, parameters, start, peeked->GetEndPosition() - start);
}
}
ParsedExpression* Parser::ParseIndexExpression(ParsedExpression* indexingExpression){
ParsedExpression *Parser::ParseIndexExpression(ParsedExpression *indexingExpression) {
this->Next(); // consume '[' token
auto indexExpression = this -> ParseExpression(this -> Next());
auto indexExpression = this->ParseExpression(this->Next());
auto closeBracket = this->Next();
if (closeBracket->GetKind() != TokenKind::CloseSquareBracket){
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, closeBracket->GetStartPosition(), closeBracket->GetLength());
if (closeBracket->GetKind() != TokenKind::CloseSquareBracket) {
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, closeBracket->GetStartPosition(),
closeBracket->GetLength());
return new BadExpression(closeBracket->GetStartPosition(), closeBracket->GetLength());
}
auto start = indexingExpression->GetStartPosition();
return new IndexExpression(indexingExpression, indexExpression, start, closeBracket->GetEndPosition() - start);
}
}
ParsedExpression* Parser::ParsePeriodIndexExpression(ParsedExpression* indexingExpression){
ParsedExpression *Parser::ParsePeriodIndexExpression(ParsedExpression *indexingExpression) {
this->Next(); // consume '.' token
auto identifier = this -> Next();
if (identifier->GetKind() != TokenKind::Identifier){
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, identifier->GetStartPosition(), identifier->GetLength());
return new BadExpression(indexingExpression->GetStartPosition(), identifier->GetEndPosition() - indexingExpression->GetStartPosition());
auto identifier = this->Next();
if (identifier->GetKind() != TokenKind::Identifier) {
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, identifier->GetStartPosition(),
identifier->GetLength());
return new BadExpression(indexingExpression->GetStartPosition(),
identifier->GetEndPosition() - 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){
if (this -> Peek() -> GetKind() == TokenKind::CloseCurlyBracket){
this -> Next();
ParsedExpression *Parser::ParseTableExpression(const IToken *current) {
if (this->Peek()->GetKind() == TokenKind::CloseCurlyBracket) {
this->Next();
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 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 (firstItem->GetKind() == ParsedStatementKind::Expression &&
(this->Peek()->GetKind() == TokenKind::CommaToken )){
auto expr = ((ParsedExpressionStatement*)firstItem)->GetExpression();
auto expressions = vector<const ParsedExpression*>{expr};
auto n = this -> Next(); // consume the comma
(this->Peek()->GetKind() == TokenKind::CommaToken)) {
auto expr = ((ParsedExpressionStatement *) firstItem)->GetExpression();
auto expressions = vector<const ParsedExpression *>{expr};
auto n = this->Next(); // consume the comma
bool hasErrors = false;
while (n->GetKind() != TokenKind::CloseCurlyBracket){
while (n->GetKind() != TokenKind::CloseCurlyBracket) {
auto expression = this->ParseExpression(this->Next());
expressions.push_back(expression);
n = this->Next();
if (n->GetKind() != TokenKind::CommaToken && n->GetKind() != TokenKind ::CloseCurlyBracket && !hasErrors){
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, n->GetStartPosition(), n->GetLength());
if (n->GetKind() != TokenKind::CommaToken && n->GetKind() != TokenKind::CloseCurlyBracket &&
!hasErrors) {
this->ScriptData->Diagnostics->LogError(DiagnosticCode::UnexpectedToken, n->GetStartPosition(),
n->GetLength());
hasErrors = true;
}
}
if (hasErrors){
if (hasErrors) {
return new BadExpression(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
else {
auto block = (ParsedBlockStatement*)this -> ParseBlock({TokenKind ::CloseCurlyBracket}, {firstItem});
auto closeToken = this -> PeekAt(-1);
auto block = (ParsedBlockStatement *) this->ParseBlock({TokenKind::CloseCurlyBracket}, {firstItem});
auto closeToken = this->PeekAt(-1);
return new ParsedTableExpression(block, start, closeToken->GetEndPosition() - start);
}
}
}
}

62
src/Parser/Parser.hpp
View File

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

83
src/Parser/Token.hpp
View File

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

7
src/Parser/TokenKind.hpp
View File

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

15
src/Parser/TypedVariableIdentifier.hpp
View File

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

6
src/Parser/UnaryOperatorKind.hpp
View File

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

46
src/Script.cpp
View File

@ -9,7 +9,7 @@
#include "Parser/Parser.hpp"
#include "Binder/Binder.hpp"
Script* Script::Create(const u16string& script) {
Porygon::Script* Porygon::Script::Create(const u16string& script) {
auto s = new Script();
s -> Parse(script);
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;
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));
}
Script::Script() {
Porygon::Script::Script() {
Diagnostics = new DiagnosticsHolder();
_evaluator = new Evaluator(this);
_boundScript = nullptr;
_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);
}
Script::~Script() {
Porygon::Script::~Script() {
delete this -> Diagnostics;
delete this -> _boundScript;
delete this -> _evaluator;
@ -43,10 +43,10 @@ Script::~Script() {
delete this->_scriptVariables;
}
void Script::Parse(const u16string& script) {
void Porygon::Script::Parse(const u16string& script) {
auto lexer = Lexer(script, this);
auto lexResult = lexer.Lex();
auto parser = Parser(lexResult, this);
auto parser = Parser::Parser(lexResult, this);
auto parseResult = parser.Parse();
for (auto token : lexResult){
delete token;
@ -55,7 +55,7 @@ void Script::Parse(const u16string& script) {
if (!Diagnostics->HasErrors()){
unordered_map<uint32_t, BoundVariable*> 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){
this->_scriptVariables -> insert({v.first, nullptr});
delete v.second;
@ -65,59 +65,57 @@ void Script::Parse(const u16string& script) {
delete parseResult;
}
EvalValue *Script::GetVariable(const u16string &key) {
EvalValue *Porygon::Script::GetVariable(const u16string &key) {
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());
return f != _scriptVariables->end();
}
EvalValue *Script::GetLastValue() {
EvalValue *Porygon::Script::GetLastValue() {
return _evaluator->GetLastValue();
}
bool Script::HasFunction(const u16string &key) {
bool Porygon::Script::HasFunction(const u16string &key) {
auto f = _scriptVariables->find(HashedString(key).GetHash());
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);
return this->_evaluator->EvaluateFunction(var, variables);
}
extern "C" {
Script* CreateScript(char16_t * s){
return Script::Create(s);
Porygon::Script* CreateScript(char16_t * s){
return Porygon::Script::Create(s);
}
void EvaluateScript(Script* script){
void EvaluateScript(Porygon::Script* script){
script->Evaluate();
}
EvalValue* GetLastValue(Script* script){
EvalValue* GetLastValue(Porygon::Script* script){
return script->GetLastValue();
}
bool HasVariable(Script* script, const char16_t* key){
bool HasVariable(Porygon::Script* script, const char16_t* 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);
}
bool HasFunction(Script* script, const char16_t* key){
bool HasFunction(Porygon::Script* script, const char16_t* 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);
return script->CallFunction(key, v).get();
}
}

20
src/Script.hpp
View File

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

15
src/ScriptType.cpp
View File

@ -1,19 +1,20 @@
#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
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){
return make_shared<ScriptType>(TypeClass::String);
}
return make_shared<ScriptType>(TypeClass::Error);
}
}
extern "C"{
ScriptType* CreateScriptType(TypeClass t){
extern "C"{
ScriptType* CreateScriptType(Porygon::TypeClass t){
return new ScriptType(t);
}
@ -24,4 +25,6 @@ extern "C"{
ScriptType* CreateStringScriptType(bool knownAtBind, uint32_t hash){
return new StringScriptType(knownAtBind, hash);
}
}
}

42
src/ScriptType.hpp
View File

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

8
src/TableScriptType.hpp
View File

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

14
src/UserData/UserData.cpp
View File

@ -2,19 +2,21 @@
#include "UserData.hpp"
#include "UserDataStorage.hpp"
extern "C"{
void RegisterUserDataType(uint32_t id){
namespace Porygon::UserData {
extern "C" {
void RegisterUserDataType(uint32_t id) {
auto ud = new UserData({});
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);
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);
return ud ->GetFieldCount();
return ud->GetFieldCount();
}
}
}

20
src/UserData/UserData.hpp
View File

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

7
src/UserData/UserDataField.cpp
View File

@ -1,8 +1,11 @@
#include "UserDataField.hpp"
extern "C"{
UserDataField* CreateUserDataField(ScriptType* type, EvalValue* (*getter)(void* obj), void (*setter)(void* obj, EvalValue* val)){
namespace Porygon::UserData {
extern "C" {
UserDataField *
CreateUserDataField(ScriptType *type, Evaluation::EvalValue *(*getter)(void *obj), void (*setter)(void *obj, Evaluation::EvalValue *val)) {
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/NumericEvalValue.hpp"
class UserDataField {
namespace Porygon::UserData{
class UserDataField {
shared_ptr<ScriptType> _type;
EvalValue* (*_get)(void* obj);
void (*_set)(void* obj, EvalValue* val);
public:
UserDataField(ScriptType* type, EvalValue* (*getter)(void* obj), void (*setter)(void* obj, EvalValue* val)){
Evaluation::EvalValue* (*_get)(void* obj);
void (*_set)(void* obj, Evaluation::EvalValue* val);
public:
UserDataField(ScriptType* type, Evaluation::EvalValue* (*getter)(void* obj), void (*setter)(void* obj, Evaluation::EvalValue* val)){
_type = shared_ptr<ScriptType>(type);
_get = getter;
_set = setter;
@ -25,7 +26,7 @@ public:
return _get != nullptr;
}
EvalValue* Get(void* obj){
Evaluation::EvalValue* Get(void* obj){
return this ->_get(obj);
}
@ -33,10 +34,11 @@ public:
return _set != nullptr;
}
void Set(void* obj, EvalValue* val){
void Set(void* obj, Evaluation::EvalValue* val){
this->_set(obj, val);
}
};
};
}
#endif //PORYGONLANG_USERDATAFIELD_HPP

33
src/UserData/UserDataScriptType.hpp
View File

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

4
src/UserData/UserDataStorage.cpp
View File

@ -1,4 +1,6 @@
#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 "UserData.hpp"
class UserDataStorage {
class _internalDataStorage{
namespace Porygon::UserData {
class UserDataStorage {
class _internalDataStorage {
public:
std::unordered_map<uint32_t, shared_ptr<UserData>> _userData;
};
static _internalDataStorage _internal;
public:
static void RegisterType(uint32_t i, UserData* ud){
public:
static void RegisterType(uint32_t i, 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();
}
static shared_ptr<UserData> GetUserDataType(uint32_t i){
static shared_ptr<UserData> GetUserDataType(uint32_t i) {
return UserDataStorage::_internal._userData[i];
}
};
};
}
#endif //PORYGONLANG_USERDATASTORAGE_HPP

6
src/UserData/UserDataValue.cpp
View File

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

41
src/UserData/UserDataValue.hpp
View File

@ -7,57 +7,56 @@
#include "UserData.hpp"
#include "UserDataStorage.hpp"
class UserDataValue : public EvalValue{
namespace Porygon::UserData {
class UserDataValue : public Evaluation::EvalValue {
const shared_ptr<UserData> _userData;
void* _obj;
public:
UserDataValue(shared_ptr<UserData> userData, void* obj)
: _userData(std::move(userData))
{
void *_obj;
public:
UserDataValue(shared_ptr<UserData> userData, void *obj)
: _userData(std::move(userData)) {
_obj = obj;
}
UserDataValue(uint32_t userDataId, void* obj)
: _userData(UserDataStorage::GetUserDataType(userDataId))
{
UserDataValue(uint32_t userDataId, void *obj)
: _userData(UserDataStorage::GetUserDataType(userDataId)) {
_obj = obj;
}
const TypeClass GetTypeClass() const final{
return TypeClass ::UserData;
const TypeClass GetTypeClass() const final {
return TypeClass::UserData;
}
const bool operator ==(EvalValue* b) const final {
const bool operator==(EvalValue *b) const final {
if (b->GetTypeClass() != TypeClass::UserData)
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);
}
const std::size_t GetHashCode() const final{
const std::size_t GetHashCode() const final {
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 field = _userData->GetField(fieldId);
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);
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 field = _userData->GetField(fieldId);
field -> Set(_obj, value.get());
field->Set(_obj, value.get());
}
};
};
}
#endif //PORYGONLANG_USERDATAVALUE_HPP

8
src/Utilities/HashedString.hpp
View File

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

2
tests/integration/ConditionalTests.cpp
View File

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

1
tests/integration/DiagnosticsTests.cpp
View File

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

1
tests/integration/EqualityOperationsTests.cpp
View File

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

2
tests/integration/Functions.cpp
View File

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

1
tests/integration/IndexTests.cpp
View File

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

1
tests/integration/LogicalOperationsTests.cpp
View File

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

1
tests/integration/NumericalOperationsTests.cpp
View File

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

1
tests/integration/StringOperationsTests.cpp
View File

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

1
tests/integration/Tables.cpp
View File

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

7
tests/integration/UserData.cpp
View File

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

1
tests/integration/Variables.cpp
View File

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

1
tests/parser/LexerTests.cpp
View File

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

1
tests/parser/ParserTests.cpp
View File

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