PorygonLang/src/Script.cpp

#include <utility>
#include <unordered_map>
#include "Script.hpp"
#include "Parser/Lexer.hpp"
#include "Parser/Parser.hpp"
#include "Binder/Binder.hpp"

Script* Script::Create(string script) {
    auto s = new Script();
    s -> Parse(std::move(script));
    return s;
}

Script::Script() {
    Diagnostics = new class Diagnostics();
    _evaluator = new Evaluator(this);
    _lastValue = nullptr;
    BoundScript = nullptr;
    _scriptVariables = new unordered_map<int, EvalValue*>(0);
}

void Script::Evaluate() {
    _evaluator->Evaluate(BoundScript);
}

Script::~Script() {
    delete this -> Diagnostics;
    delete this -> BoundScript;
    delete this -> _lastValue;
    delete this -> _evaluator;
    for (auto v : *this->_scriptVariables){
        delete v.second;
    }
    this->_scriptVariables->clear();
    delete this->_scriptVariables;
}

void Script::Parse(string script) {
    auto lexer = Lexer(std::move(script), this);
    auto lexResult = lexer.Lex();
    auto parser = Parser(lexResult, this);
    auto parseResult = parser.Parse();
    for (auto token : lexResult){
        delete token;
    }
    lexResult.clear();
    if (!Diagnostics->HasErrors()){
        unordered_map<int, BoundVariable*> scriptScope;
        auto bindScope = new BoundScope(&scriptScope);
        this->BoundScript = Binder::Bind(this, parseResult, bindScope);
        for (const auto& v : scriptScope){
            this->_scriptVariables -> insert({v.first, nullptr});
            delete v.second;
        }
        scriptScope.clear();
    }
    delete parseResult;
}

EvalValue *Script::GetVariable(const string &key) {
    return _scriptVariables -> at(HashedString(key).GetHash());
}

bool Script::HasVariable(const string &key) {
    auto f = _scriptVariables->find(HashedString(key).GetHash());
    return f != _scriptVariables->end();
}