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

Cleans up basic library handling, implements print function
All checks were successful
continuous-integration/drone/push Build is passing
Details

Browse Source
This commit is contained in:
Deukhoofd
2019-07-04 15:56:42 +02:00
parent db2d731b06
commit 5e02b6b389
7 changed files with 135 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

73
src/StandardLibraries/BasicLibrary.hpp
View File

@@ -10,6 +10,7 @@
#include "../Binder/BoundVariables/BoundVariable.hpp"
#include "../UserData/UserDataFunction.hpp"
#include "../UserData/UserDataFunctionType.hpp"
#include "../GlobalScriptOptions.hpp"
namespace Porygon::StandardLibraries{
class BasicLibrary{
@@ -22,42 +23,80 @@ namespace Porygon::StandardLibraries{
static Evaluation::EvalValue* _assert(void*, Evaluation::EvalValue* parameters[], int parameterCount){
auto assertion = parameters[0]->EvaluateBool();
if (!assertion){
if (parameterCount >= 2){
auto error = parameters[1]->EvaluateString();
auto conv = Utilities::StringUtils::FromUTF8(error);
throw Evaluation::EvaluationException(conv);
}
throw Evaluation::EvaluationException("assertion failed!");
}
return new Evaluation::BooleanEvalValue(true);
}
static Evaluation::EvalValue* _print(void*, Evaluation::EvalValue* parameters[], int parameterCount){
auto message = parameters[0]->EvaluateString();
GlobalScriptOptions::Print(message);
return new Evaluation::NilEvalValue();
}
static shared_ptr<GenericFunctionScriptType> GetFuncType(const shared_ptr<ScriptType>& result, const vector<vector<shared_ptr<ScriptType>>>& options){
auto funcType = make_shared<GenericFunctionScriptType>();
for (const auto& o: options){
auto option = new UserData::UserDataFunctionOption(result, o);
funcType->RegisterFunctionOption(option);
}
return funcType;
}
static shared_ptr<GenericFunctionScriptType> GetErrorFuncType(){
return GetFuncType(make_shared<ScriptType>(TypeClass::Nil), {{make_shared<StringScriptType>(false, 0)}});
}
static shared_ptr<GenericFunctionScriptType> GetAssertFuncType(){
return GetFuncType(make_shared<ScriptType>(TypeClass::Bool),
{{make_shared<ScriptType>(TypeClass::Bool)},
{make_shared<ScriptType>(TypeClass::Bool), make_shared<StringScriptType>(false, 0)}});
}
static shared_ptr<GenericFunctionScriptType> GetPrintFuncType(){
return GetFuncType(make_shared<ScriptType>(TypeClass::Nil), {{make_shared<StringScriptType>(false, 0)}});
}
static shared_ptr<Evaluation::EvalValue> GetFuncEvalValue(
Evaluation::EvalValue* (*func)(void* obj, Evaluation::EvalValue* parameters[], int parameterCount),
shared_ptr<GenericFunctionScriptType> type, size_t optionLength){
auto f = make_shared<Evaluation::GenericFunctionEvalValue>(type, rand());
for (int i = 0; i < optionLength; i++){
auto funcOption = new UserData::UserDataFunction(func, nullptr);
f->RegisterOption(funcOption);
}
return f;
}
public:
static void RegisterVariables(std::map<Utilities::HashedString, Binder::BoundVariable *>* bound,
std::map<Utilities::HashedString, shared_ptr<Evaluation::EvalValue>>* values){
// Register error function
auto errorFuncTypeOption = new UserData::UserDataFunctionOption(
make_shared<ScriptType>(TypeClass::Nil),
vector<shared_ptr<ScriptType>>{make_shared<StringScriptType>(false, 0)});
auto errorFuncType = make_shared<GenericFunctionScriptType>();
errorFuncType->RegisterFunctionOption(errorFuncTypeOption);
auto errorFuncOption = new UserData::UserDataFunction(_error, nullptr);
auto errorFunc = make_shared<Evaluation::GenericFunctionEvalValue>(errorFuncType, rand());
errorFunc->RegisterOption(errorFuncOption);
auto errorFuncType = BasicLibrary::GetErrorFuncType();
auto errorLookup = Utilities::HashedString::CreateLookup(u"error");
auto errorFunc = BasicLibrary::GetFuncEvalValue(_error, errorFuncType, 1);
bound->insert({errorLookup, new Binder::BoundVariable(errorFuncType)});
values->insert({errorLookup, errorFunc});
// Register assert function
auto assertFuncTypeOption = new UserData::UserDataFunctionOption(
make_shared<ScriptType>(TypeClass::Bool),
vector<shared_ptr<ScriptType>>{make_shared<ScriptType>(TypeClass::Bool)});
auto assertFuncType = make_shared<GenericFunctionScriptType>();
assertFuncType->RegisterFunctionOption(assertFuncTypeOption);
auto assertFuncOption = new UserData::UserDataFunction(_assert, nullptr);
auto assertFunc = make_shared<Evaluation::GenericFunctionEvalValue>(assertFuncType, rand());
assertFunc->RegisterOption(assertFuncOption);
auto assertFuncType = BasicLibrary::GetAssertFuncType();
auto assertLookup = Utilities::HashedString::CreateLookup(u"assert");
auto assertFunc = BasicLibrary::GetFuncEvalValue(_assert, assertFuncType, 2);
bound->insert({assertLookup, new Binder::BoundVariable(assertFuncType)});
values->insert({assertLookup, assertFunc});
// Register print function
auto printFuncType = BasicLibrary::GetPrintFuncType();
auto printLookup = Utilities::HashedString::CreateLookup(u"print");
auto printFunc = BasicLibrary::GetFuncEvalValue(_print, printFuncType, 1);
bound->insert({printLookup, new Binder::BoundVariable(printFuncType)});
values->insert({printLookup, printFunc});
}
};
}