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

Rework of variable scope to reduce load on evaluator

Browse Source
This commit is contained in:
Deukhoofd
2019-06-13 15:16:41 +02:00
parent 0339c44a89
commit 813ab1e90b
9 changed files with 65 additions and 91 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/Evaluator/EvaluationException.hpp
View File

@@ -1,15 +1,17 @@
#ifndef PORYGONLANG_EVALUATIONEXCEPTION_HPP
#define PORYGONLANG_EVALUATIONEXCEPTION_HPP
#include <utility>
#include <exception>
#include <string>
using namespace std;
class EvaluationException : std::exception {
class EvaluationException : public std::exception {
string _message;
public:
explicit EvaluationException(string message){
_message = message;
_message = std::move(message);
}
const string defaultErrorText = "An evaluation exception occurred: ";

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

@@ -4,60 +4,32 @@
EvaluationScope::EvaluationScope(unordered_map<size_t, shared_ptr<EvalValue>> *scriptVariables, int deepestScope) {
_scriptScope = scriptVariables;
_localScope = vector<shared_ptr<unordered_map<int, shared_ptr<EvalValue>>>>(deepestScope);
for (int i = 0; i < deepestScope; i++){
_localScope[i] = make_shared<unordered_map<int, shared_ptr<EvalValue>>>();
}
_currentScope = -1;
_localScope = unordered_map<u_int64_t, shared_ptr<EvalValue>>(deepestScope);
}
void EvaluationScope::CreateVariable(int scope, int id, const shared_ptr<EvalValue>& value) {
if (scope == 0){
_scriptScope->at(id) = value;
void EvaluationScope::CreateVariable(BoundVariableKey* key, const shared_ptr<EvalValue> &value) {
if (key->GetScopeId() == 0){
_scriptScope -> at(key->GetIdentifier()) = value;
} else{
auto insert = _localScope[scope - 1]->insert({id, value});
auto insert = _localScope.insert({key->GetHash(), value});
if (!insert.second){
_localScope[scope - 1]->at(id) = value;
_localScope[key->GetHash()] = value;
}
}
}
void EvaluationScope::SetVariable(int scope, int id, const shared_ptr<EvalValue>& value) {
if (scope == 0){
_scriptScope->at(id) = value;
void EvaluationScope::SetVariable(BoundVariableKey* key, const shared_ptr<EvalValue> &value) {
if (key->GetScopeId() == 0){
_scriptScope -> at(key->GetIdentifier()) = value;
} else{
_localScope[scope - 1]->at(id) = value;
_localScope[key->GetHash()] = value;
}
}
shared_ptr<EvalValue> EvaluationScope::GetVariable(int scope, int id) {
if (scope == 0){
return _scriptScope->at(id);
shared_ptr<EvalValue> EvaluationScope::GetVariable(BoundVariableKey* key) {
if (key->GetScopeId() == 0){
return _scriptScope -> at(key->GetIdentifier());
} else{
return _localScope[key->GetHash()];
}
return _localScope[scope - 1]->at(id);
}
EvaluationScope* EvaluationScope::CreateBranchingScope(int scopeIndex){
auto scope = new EvaluationScope(this -> _scriptScope, this -> _localScope.size());
for (int i = 0; i <= scopeIndex; i++){
scope->_localScope[i] = this->_localScope[i];
}
for (int i = scopeIndex + 1; i < _localScope.size(); i++){
scope->_localScope[i] = make_shared<unordered_map<int, shared_ptr<EvalValue>>>();
}
scope->_currentScope = this -> _currentScope;
return scope;
}
void EvaluationScope::OuterScope() {
_currentScope++;
}
void EvaluationScope::InnerScope(bool clearScope) {
if (clearScope){
auto scope = this->_localScope[_currentScope];
scope->clear();
}
_currentScope--;
}
}

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

@@ -8,24 +8,14 @@
class EvaluationScope {
unordered_map<size_t, shared_ptr<EvalValue>>* _scriptScope;
vector<shared_ptr<unordered_map<int, shared_ptr<EvalValue>>>> _localScope;
int _currentScope;
unordered_map<u_int64_t, shared_ptr<EvalValue>> _localScope;
public:
explicit EvaluationScope(unordered_map<size_t, shared_ptr<EvalValue>>* scriptVariables, int deepestScope);
~EvaluationScope() = default;
void CreateVariable(int scope, int id, const shared_ptr<EvalValue>& value);
void SetVariable(int scope, int id, const shared_ptr<EvalValue>& value);
void OuterScope();
void InnerScope(bool clearScope = true);
shared_ptr<EvalValue> GetVariable(int scope, int id);
EvaluationScope* CreateBranchingScope(int scopeIndex);
int GetCurrentScope(){
return _currentScope;
}
void CreateVariable(BoundVariableKey* key, const shared_ptr<EvalValue>& value);
void SetVariable(BoundVariableKey* key, const shared_ptr<EvalValue>& value);
shared_ptr<EvalValue> GetVariable(BoundVariableKey* key);
};

30
src/Evaluator/Evaluator.cpp
View File

@@ -35,13 +35,11 @@ void Evaluator::EvaluateStatement(BoundStatement *statement) {
}
void Evaluator::EvaluateBlockStatement(BoundBlockStatement* statement, bool clearScope) {
this->_evaluationScope->OuterScope();
for (auto s: statement->GetStatements()){
this -> EvaluateStatement(s);
if (this->_hasReturned)
break;
}
this->_evaluationScope->InnerScope(clearScope);
}
void Evaluator::EvaluateExpressionStatement(BoundExpressionStatement *statement) {
@@ -53,9 +51,9 @@ void Evaluator::EvaluateAssignmentStatement(BoundAssignmentStatement *statement)
auto value = this -> EvaluateExpression(statement->GetExpression());
auto key = statement->GetKey();
if (key->IsCreation()){
this->_evaluationScope->CreateVariable(key->GetScopeId(), key->GetIdentifier(), value);
this->_evaluationScope->CreateVariable(key, value);
} else{
this->_evaluationScope->SetVariable(key->GetScopeId(), key->GetIdentifier(), value);
this->_evaluationScope->SetVariable(key, value);
}
}
@@ -63,12 +61,11 @@ void Evaluator::EvaluateFunctionDeclarationStatement(BoundFunctionDeclarationSta
auto type = statement->GetType();
auto key = statement->GetKey();
auto block = statement->GetBlock();
auto evaluator = shared_ptr<EvaluationScope>(this->_evaluationScope->CreateBranchingScope(this->_evaluationScope->GetCurrentScope() + 1));
auto value = make_shared<ScriptFunctionEvalValue>(block, evaluator, type);
auto value = make_shared<ScriptFunctionEvalValue>(block, this->_evaluationScope, type);
if (key->IsCreation()){
this->_evaluationScope->CreateVariable(key->GetScopeId(), key->GetIdentifier(), value);
this->_evaluationScope->CreateVariable(key, value);
} else{
this->_evaluationScope->SetVariable(key->GetScopeId(), key->GetIdentifier(), value);
this->_evaluationScope->SetVariable(key, value);
}
}
@@ -109,7 +106,10 @@ shared_ptr<EvalValue> Evaluator::EvaluateExpression(BoundExpression *expression)
}
shared_ptr<EvalValue> Evaluator::GetVariable(BoundVariableExpression* expression){
auto variable = this->_evaluationScope->GetVariable(expression->GetScope(), expression->GetId());
auto variable = this->_evaluationScope->GetVariable(expression->GetKey());
if (variable == nullptr){
throw EvaluationException("Variable not found");
}
return variable->Clone();
}
@@ -218,9 +218,8 @@ shared_ptr<EvalValue> Evaluator::EvaluateFunctionCallExpression(BoundExpression*
auto type = std::dynamic_pointer_cast<FunctionScriptType>(function->GetType());
auto parameterTypes = type->GetParameterTypes();
auto parameterKeys = type->GetParameterKeys();
auto scope = type -> GetScopeIndex();
auto originalScope = this->_evaluationScope;
this->_evaluationScope = shared_ptr<EvaluationScope>(function -> GetScope() -> CreateBranchingScope(scope));
this->_evaluationScope = function->GetScope();
for (int i = 0; i < parameterTypes.size() && i < parameterKeys.size() && i < parameters.size(); i++){
auto parameter = parameters[i];
@@ -229,11 +228,11 @@ shared_ptr<EvalValue> Evaluator::EvaluateFunctionCallExpression(BoundExpression*
throw EvaluationException("Passed wrong type to function.");
}
auto key = parameterKeys.at(i);
this->_evaluationScope->CreateVariable(key->GetScopeId(), key->GetIdentifier(), parameter->Clone());
this->_evaluationScope->CreateVariable(key.get(), parameter->Clone());
}
this->EvaluateBlockStatement(function->GetInnerBlock().get(), true);
this->_evaluationScope = originalScope;
this->_hasReturned = false;
auto r = this -> _returnValue;
this -> _returnValue = nullptr;
@@ -245,9 +244,8 @@ shared_ptr<EvalValue> Evaluator::EvaluateFunction(ScriptFunctionEvalValue *funct
auto parameterTypes = type->GetParameterTypes();
auto parameterKeys = type->GetParameterKeys();
auto scope = type -> GetScopeIndex();
auto originalScope = this->_evaluationScope;
this->_evaluationScope = shared_ptr<EvaluationScope>(function -> GetScope() -> CreateBranchingScope(scope));
this->_evaluationScope = function->GetScope();
for (int i = 0; i < parameterTypes.size() && i < parameterKeys.size() && i < parameters.size(); i++){
auto parameter = parameters[i];
@@ -256,7 +254,7 @@ shared_ptr<EvalValue> Evaluator::EvaluateFunction(ScriptFunctionEvalValue *funct
throw EvaluationException("Passed wrong type to function.");
}
auto key = parameterKeys.at(i);
this->_evaluationScope->CreateVariable(key->GetScopeId(), key->GetIdentifier(), parameter->Clone());
this->_evaluationScope->CreateVariable(key.get(), parameter->Clone());
}
this->EvaluateBlockStatement(function->GetInnerBlock().get(), true);
this->_evaluationScope = originalScope;