184 lines
6.3 KiB
C++
184 lines
6.3 KiB
C++
#include <utility>
|
|
#include <vector>
|
|
#include <locale>
|
|
#include <codecvt>
|
|
#include "Script.hpp"
|
|
#include "Parser/Lexer.hpp"
|
|
#include "Parser/Parser.hpp"
|
|
#include "Binder/Binder.hpp"
|
|
#include "EvaluateResult.hpp"
|
|
|
|
Porygon::Script* Porygon::Script::Create(const u16string& script, ScriptOptions* options) {
|
|
return new Script(script, options);
|
|
}
|
|
|
|
std::u16string To_UTF16(const string &s)
|
|
{
|
|
std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> conv;
|
|
return conv.from_bytes(s);
|
|
}
|
|
Porygon::Script *Porygon::Script::Create(const string &script, ScriptOptions* options) {
|
|
return Script::Create(To_UTF16(script), options);
|
|
}
|
|
|
|
Porygon::Script::Script(const u16string& s, ScriptOptions* options)
|
|
: Diagnostics(make_shared<Diagnostics::DiagnosticsHolder>(s)),
|
|
_boundScript(nullptr),
|
|
_scriptVariables(new map<Utilities::HashedString, EvalValuePointer>()),
|
|
_scriptTypes(new unordered_map<Utilities::HashedString, shared_ptr<ScriptType>>{}),
|
|
_scriptOptions(options)
|
|
{
|
|
_evaluator = new Evaluator(this -> _scriptVariables, this -> GetScriptOptions());
|
|
this -> Parse(s);
|
|
}
|
|
|
|
EvalValuePointer Porygon::Script::Evaluate() {
|
|
return _evaluator->Evaluate(_boundScript.get());
|
|
}
|
|
|
|
Porygon::Script::~Script() {
|
|
delete this -> _evaluator;
|
|
this->_scriptVariables->clear();
|
|
delete this->_scriptVariables;
|
|
this->_scriptTypes->clear();
|
|
delete this->_scriptTypes;
|
|
}
|
|
|
|
void Porygon::Script::Parse(const u16string& script) {
|
|
auto lexer = Lexer(script, this);
|
|
auto lexResult = lexer.Lex();
|
|
auto parser = Parser::Parser(lexResult, this);
|
|
auto parseResult = parser.Parse();
|
|
for (auto token : lexResult){
|
|
delete token;
|
|
}
|
|
lexResult.clear();
|
|
if (!Diagnostics->HasErrors()){
|
|
map<Utilities::HashedString, BoundVariable*> scriptScope;
|
|
unordered_map<Utilities::HashedString, shared_ptr<const ScriptType>> variableTypes;
|
|
auto bindScope = new BoundScope(&scriptScope, &variableTypes);
|
|
this->_boundScript = shared_ptr<BoundScriptStatement>(Binder::Binder::Bind(this, parseResult, bindScope));
|
|
for (const auto& v : scriptScope){
|
|
this->_scriptVariables -> insert({v.first, nullptr});
|
|
delete v.second;
|
|
}
|
|
for (const auto& v : variableTypes){
|
|
this->_scriptTypes -> insert({v.first, nullptr});
|
|
}
|
|
scriptScope.clear();
|
|
variableTypes.clear();
|
|
}
|
|
delete parseResult;
|
|
}
|
|
|
|
const EvalValue* Porygon::Script::GetVariable(const u16string &key) {
|
|
return _scriptVariables -> at(HashedString::CreateLookup(key)).Clone();
|
|
}
|
|
|
|
bool Porygon::Script::HasVariable(const u16string &key) {
|
|
auto f = _scriptVariables->find(HashedString::CreateLookup(key));
|
|
return f != _scriptVariables->end();
|
|
}
|
|
|
|
bool Porygon::Script::HasFunction(const u16string &key) {
|
|
auto f = _scriptVariables->find(HashedString::CreateLookup(key));
|
|
return f != _scriptVariables->end() && f.operator->()->second->GetTypeClass() == TypeClass ::Function;
|
|
}
|
|
|
|
const EvalValue* Porygon::Script::CallFunction(const u16string &key, const vector<EvalValue *>& variables) {
|
|
auto var = (GenericFunctionEvalValue*)GetVariable(key);
|
|
return this->_evaluator->EvaluateFunction(var, variables);
|
|
}
|
|
|
|
Porygon::Script *Porygon::Script::Clone(const Porygon::Script *script) {
|
|
auto s = new Script(script->_boundScript, script->Diagnostics);
|
|
s->_scriptOptions = script ->_scriptOptions;
|
|
for (const auto& v: *script->_scriptVariables){
|
|
s->_scriptVariables->insert({v.first, nullptr});
|
|
}
|
|
for (const auto& v: *script->_scriptTypes){
|
|
s->_scriptTypes->insert({v.first, v.second});
|
|
}
|
|
|
|
s->_returnType = script->_returnType;
|
|
return s;
|
|
}
|
|
|
|
Porygon::Script::Script(shared_ptr<BoundScriptStatement> boundScript,
|
|
shared_ptr<Porygon::Diagnostics::DiagnosticsHolder> diagnostics)
|
|
: _boundScript(std::move(boundScript)),
|
|
Diagnostics(std::move(diagnostics)),
|
|
_scriptVariables(new map<Utilities::HashedString, EvalValuePointer>()),
|
|
_scriptTypes(new unordered_map<Utilities::HashedString, shared_ptr<ScriptType>>{}),
|
|
_scriptOptions(nullptr)
|
|
{
|
|
_evaluator = new Evaluator(_scriptVariables, this -> GetScriptOptions());
|
|
}
|
|
|
|
std::string Porygon::Script::GetTreeString() {
|
|
if (_treeString.empty()){
|
|
std::stringstream stream;
|
|
_boundScript->GetTreeString(stream, 0);
|
|
_treeString = stream.str();
|
|
}
|
|
return _treeString;
|
|
}
|
|
|
|
extern "C" {
|
|
Porygon::Script* CreateScript(char16_t * s, Porygon::ScriptOptions* options){
|
|
return Porygon::Script::Create(s, options);
|
|
}
|
|
|
|
Porygon::Script* CloneScript(Porygon::Script* p){
|
|
return Porygon::Script::Clone(p);
|
|
}
|
|
|
|
Porygon::EvaluateResult* EvaluateScript(Porygon::Script* script){
|
|
try{
|
|
auto result = script -> Evaluate();
|
|
return new Porygon::EvaluateResult(result.Take());
|
|
}
|
|
catch (const EvaluationException& e){
|
|
return new Porygon::EvaluateResult(e.what());
|
|
}
|
|
}
|
|
|
|
bool HasVariable(Porygon::Script* script, const char16_t* key){
|
|
return script->HasVariable(key);
|
|
}
|
|
|
|
const EvalValue* GetVariable(Porygon::Script* script, const char16_t* key){
|
|
return script->GetVariable(key);
|
|
}
|
|
|
|
bool HasFunction(Porygon::Script* script, const char16_t* key){
|
|
return script->HasFunction(key);
|
|
}
|
|
|
|
Porygon::EvaluateResult* CallFunction(Porygon::Script* script, const char16_t* key, EvalValue* parameters[], int parameterCount){
|
|
try{
|
|
std::vector<EvalValue*> v(parameters, parameters + parameterCount);
|
|
auto result = script->CallFunction(key, v);
|
|
return new Porygon::EvaluateResult(result);
|
|
}
|
|
catch (const EvaluationException& e){
|
|
return new Porygon::EvaluateResult(e.what());
|
|
}
|
|
}
|
|
|
|
const char * GetResultError(Porygon::EvaluateResult * result){
|
|
return result->GetError();
|
|
}
|
|
|
|
const size_t GetTreeStringLength(Porygon::Script* script){
|
|
return script->GetTreeString().size();
|
|
}
|
|
|
|
void GetTreeString(Porygon::Script* script, char* buffer){
|
|
auto s = script->GetTreeString();
|
|
for (size_t i = 0; i < s.size(); i++){
|
|
buffer[i] = s[i];
|
|
}
|
|
}
|
|
|
|
} |