Work on extern support for userdata functions

src/Evaluator/EvalValues/EvalValue.cpp

@@ -2,6 +2,7 @@
 #include "NumericEvalValue.hpp"
 #include "StringEvalValue.hpp"
 #include <cstring>
+#include <memory>
 
 namespace Porygon::Evaluation {
 
@@ -26,6 +27,7 @@ namespace Porygon::Evaluation {
         return v->EvaluateString()->c_str();
     }
 
+
     EvalValue *CreateIntegerEvalValue(long l) {
         return new IntegerEvalValue(l);
     }

src/Evaluator/EvalValues/ScriptFunctionEvalValue.hpp

@@ -1,6 +1,3 @@
-#include <utility>
-
-#include <utility>
 
 #ifndef PORYGONLANG_SCRIPTFUNCTIONEVALVALUE_HPP
 #define PORYGONLANG_SCRIPTFUNCTIONEVALVALUE_HPP
@@ -10,7 +7,6 @@
 #include "../../ScriptType.hpp"
 #include "EvalValue.hpp"
 #include "../../Binder/BoundStatements/BoundStatement.hpp"
-#include "../Evaluator.hpp"
 #include "../EvaluationScope/EvaluationScope.hpp"
 
 using namespace std;

src/Evaluator/Evaluator.cpp

@@ -285,8 +285,8 @@ namespace Porygon::Evaluation {
         }
 
         auto type = std::dynamic_pointer_cast<GenericFunctionScriptType>(function->GetType());
-        auto parameterTypes = type->GetParameterTypes();
         if (type -> IsScriptFunction()){
+            auto parameterTypes = type->GetParameterTypes();
             auto scriptFunctionType = std::dynamic_pointer_cast<FunctionScriptType>(type);
             auto parameterKeys = scriptFunctionType->GetParameterKeys();
             auto originalScope = this->_evaluationScope;

src/ScriptType.cpp

@@ -1,4 +1,5 @@
 #include "Script.hpp"
+#include "UserData/UserDataFunctionType.hpp"
 
 namespace Porygon{
     const bool ScriptType::CanBeIndexedWith(ScriptType *indexer) const{
@@ -25,6 +26,14 @@ namespace Porygon{
         ScriptType* CreateStringScriptType(bool knownAtBind, uint32_t hash){
             return new StringScriptType(knownAtBind, hash);
         }
+
+        ScriptType* CreateUserDataFunctionScriptType(ScriptType* returnType, ScriptType* parameters[], size_t parameterCount){
+            vector<shared_ptr<ScriptType>> vector(parameterCount);
+            for (int i = 0; i < parameterCount; i++){
+                vector[i] = shared_ptr<ScriptType>(parameters[i]);
+            }
+            return new UserData::UserDataFunctionType(shared_ptr<ScriptType>(returnType), vector);
+        }
     }
 }
 

src/UserData/UserDataFunction.cpp

@@ -1,2 +1,12 @@
 
 #include "UserDataFunction.hpp"
+
+using namespace Porygon::Evaluation;
+
+namespace Porygon::UserData{
+    extern "C" {
+        EvalValue * CreateFunctionEvalValue(Evaluation::EvalValue* (*func)(void* , EvalValue* [], int ), void* obj) {
+            return new UserDataFunction(func, obj);
+        }
+    }
+}

src/UserData/UserDataFunction.hpp

@@ -3,6 +3,7 @@
 
 #include <utility>
 #include "../Evaluator/EvalValues/ScriptFunctionEvalValue.hpp"
+#include "UserDataFunctionType.hpp"
 
 namespace Porygon::UserData{
     class UserDataFunction : public Evaluation::GenericFunctionEvalValue {
@@ -15,14 +16,18 @@ namespace Porygon::UserData{
             _obj = obj;
         }
     public:
-        UserDataFunction(Evaluation::EvalValue* (*call)(void* obj, EvalValue* parameters[], int parameterCount), void* obj,
-                shared_ptr<GenericFunctionScriptType> type) : GenericFunctionEvalValue(std::move(type), rand()){
+        UserDataFunction(Evaluation::EvalValue* (*call)(void* obj, EvalValue* parameters[], int parameterCount), void* obj) :
+        GenericFunctionEvalValue(make_shared<UserDataFunctionType>(nullptr, vector<shared_ptr<ScriptType>>{}), rand()){
             _call = call;
             _obj = obj;
         }
 
         EvalValue* Call(EvalValue* parameters[], int parameterCount){
-            return _call(_obj, parameters, parameterCount);
+            try{
+                return _call(_obj, parameters, parameterCount);
+            } catch (...){
+                throw Evaluation::EvaluationException("An error occurred while executing a userdata function.");
+            }
         }
 
         const shared_ptr<EvalValue> Clone() const final {

src/UserData/UserDataScriptType.hpp

@@ -31,7 +31,7 @@ namespace Porygon::UserData {
         }
 
         const bool CanBeIndexedWithIdentifier(uint32_t hash) const final {
-            return true;
+            return _userData -> ContainsField(hash);
         }
 
         UserDataField *GetField(uint32_t id) {

src/UserData/UserDataValue.cpp

@@ -6,5 +6,10 @@ namespace Porygon::UserData {
     UserDataValue *CreateUserDataEvalValue(uint32_t typeHash, void *obj) {
         return new UserDataValue(typeHash, obj);
     }
+
+    void* EvaluateUserDataObj(UserDataValue *v){
+        return v -> GetObjectPointer();
+    }
+
     }
 }

src/UserData/UserDataValue.hpp

@@ -56,6 +56,10 @@ namespace Porygon::UserData {
             auto field = _userData->GetField(fieldId);
             field->Set(_obj, value.get());
         }
+
+        void* GetObjectPointer(){
+            return _obj;
+        }
     };
 }
 

tests/integration/UserData.cpp

@@ -37,8 +37,7 @@ private:
     }
 
     static EvalValue* GetFooFunction(void* obj){
-        return new UserDataFunction(CallFooFunction, obj,
-                                    make_shared<UserDataFunctionType>(make_shared<NumericScriptType>(true, false), vector<shared_ptr<ScriptType>>(0)));
+        return new UserDataFunction(CallFooFunction, obj);
     }
 
     static EvalValue* CallAddition(void* obj, EvalValue* parameters[], int parameterCount){
@@ -51,7 +50,7 @@ private:
     static GenericFunctionScriptType* AdditionFunctionType;
 
     static EvalValue* GetAdditionFunction(void* obj){
-        return new UserDataFunction(CallAddition, obj, shared_ptr<GenericFunctionScriptType>(AdditionFunctionType));
+        return new UserDataFunction(CallAddition, obj);
     }
 
 public: