Better handling of userdata exceptions in other languages.

src/UserData/UserDataFunction.cpp

@@ -6,7 +6,7 @@ using namespace Porygon::Evaluation;
 
 namespace Porygon::UserData{
     extern "C" {
-        const EvalValue * CreateFunctionEvalValue(const Evaluation::EvalValue* (*func)(void*, const ScriptOptions*,
+        const EvalValue * CreateFunctionEvalValue(const UserData::UserDataReturnValue* (*func)(void*, const ScriptOptions*,
                 const EvalValue* [], int ), void* obj) {
             auto opt = new UserDataFunction(func, obj);
             auto t = new GenericFunctionEvalValue(make_shared<GenericFunctionScriptType>(), Utilities::Random::Get());
@@ -15,7 +15,7 @@ namespace Porygon::UserData{
         }
 
         void RegisterFunctionEvalValueOption(const GenericFunctionEvalValue* val,
-                const Evaluation::EvalValue* (*func)(void*, const ScriptOptions*, const EvalValue* [], int ), void* obj){
+                                             const UserData::UserDataReturnValue* (*func)(void*, const ScriptOptions*, const EvalValue* [], int ), void* obj){
             auto opt = new UserDataFunction(func, obj);
             val->RegisterOption(opt);
         }

src/UserData/UserDataFunction.hpp

@@ -5,21 +5,22 @@
 #include "UserDataFunctionType.hpp"
 #include "../ScriptTypes/FunctionScriptType.hpp"
 #include "../ScriptOptions.hpp"
+#include "UserDataReturnValue.hpp"
 
 namespace Porygon::UserData{
     class UserDataFunction : public Evaluation::GenericFunctionOption {
-        const Evaluation::EvalValue* (*_call)(void* obj, const ScriptOptions*, const Evaluation::EvalValue* parameters[],
+        const UserDataReturnValue* (*_call)(void* obj, const ScriptOptions*, const Evaluation::EvalValue* parameters[],
                 int parameterCount);
         void *_obj;
 
-        UserDataFunction(const Evaluation::EvalValue* (*call)(void* obj, const ScriptOptions*,
+        UserDataFunction(const UserDataReturnValue* (*call)(void* obj, const ScriptOptions*,
                 const Evaluation::EvalValue* parameters[], int parameterCount), void* obj,
                          const shared_ptr<GenericFunctionScriptType>& type, size_t hash) : GenericFunctionOption(){
             _call = call;
             _obj = obj;
         }
     public:
-        UserDataFunction(const Evaluation::EvalValue* (*call)(void* obj, const ScriptOptions*,
+        UserDataFunction(const UserDataReturnValue* (*call)(void* obj, const ScriptOptions*,
                 const Evaluation::EvalValue* parameters[], int parameterCount), void* obj) :
                 GenericFunctionOption(){
             _call = call;
@@ -29,7 +30,7 @@ namespace Porygon::UserData{
         ~UserDataFunction() final = default;
 
         [[nodiscard]]
-        inline const Evaluation::EvalValue* Call(const ScriptOptions* script,
+        inline const UserDataReturnValue* Call(const ScriptOptions* script,
                 const Evaluation::EvalValue* parameters[], int parameterCount) const{
             return _call(_obj, script, parameters, parameterCount);
         }

src/UserData/UserDataReturnValue.cpp

@@ -0,0 +1,12 @@
+#include "UserDataReturnValue.hpp"
+
+extern "C"{
+    Porygon::UserData::UserDataReturnValue* ReturnValue(Porygon::Evaluation::EvalValue* value){
+        return new Porygon::UserData::UserDataReturnValue(value);
+    }
+
+    Porygon::UserData::UserDataReturnValue* ErrorValue(const char* message){
+        return new Porygon::UserData::UserDataReturnValue(message);
+    }
+
+}

src/UserData/UserDataReturnValue.hpp

@@ -0,0 +1,29 @@
+#ifndef PORYGONLANG_USERDATARETURNVALUE_HPP
+#define PORYGONLANG_USERDATARETURNVALUE_HPP
+
+#include "../Evaluator/EvalValues/EvalValue.hpp"
+
+extern "C" {
+namespace Porygon::UserData {
+    struct UserDataReturnValue {
+        bool _success;
+        union {
+            const char *_message;
+            const Evaluation::EvalValue *_value;
+        };
+    public:
+        UserDataReturnValue(Evaluation::EvalValue *value) : _success(true), _value(value) {}
+        UserDataReturnValue(const Evaluation::EvalValue *value) : _success(true), _value(value) {}
+        UserDataReturnValue(const char *message) : _success(false), _message(message) {}
+
+        inline const Evaluation::EvalValue *Evaluate() const{
+            if (_success) {
+                return _value;
+            }
+            throw Evaluation::EvaluationException(_message);
+        }
+    };
+}
+}
+
+#endif //PORYGONLANG_USERDATARETURNVALUE_HPP

src/UserData/UserDataTemplates.hpp

@@ -117,7 +117,8 @@ Porygon::Utilities::HashedString* Convert(const char* k){
                         Porygon::Utilities::Random::Get()); \
                 t->RegisterOption(new Porygon::UserData::UserDataFunction( \
                 [](void* obj, const ScriptOptions* opts, const Porygon::Evaluation::EvalValue* par[], int parameterCount) \
-                    -> const Porygon::Evaluation::EvalValue*{return ((const T_USERDATA*)obj)->invoke__##fieldName(obj, opts, par, parameterCount);},  \
+                    -> const Porygon::UserData::UserDataReturnValue*{ \
+                    return new Porygon::UserData::UserDataReturnValue (((const T_USERDATA*)obj)->invoke__##fieldName(obj, opts, par, parameterCount));},  \
                 obj)); \
                 return t;}, \
         nullptr) \