Work on making userdata work through extern C entry points

src/UserData/UserData.cpp

@@ -1,2 +1,20 @@
 
 #include "UserData.hpp"
+#include "UserDataStorage.hpp"
+
+extern "C"{
+    void RegisterUserDataType(uint32_t id){
+        auto ud = new UserData({});
+        UserDataStorage::RegisterType(id, ud);
+    }
+
+    void RegisterUserDataField(uint32_t typeId, uint32_t fieldId, UserDataField* field){
+        auto ud = UserDataStorage::GetUserDataType(typeId);
+        ud -> CreateField(fieldId, field);
+    }
+
+    int32_t GetUserDataFieldCount(uint32_t typeId){
+        auto ud = UserDataStorage::GetUserDataType(typeId);
+        return ud ->GetFieldCount();
+    }
+}

src/UserData/UserData.hpp

@@ -6,19 +6,27 @@
 #include "UserDataField.hpp"
 
 class UserData {
-    std::unordered_map<int, UserDataField*> _fields;
+    std::unordered_map<uint32_t, UserDataField*> _fields;
 public:
-    explicit UserData(std::unordered_map<int, UserDataField*> fields){
+    explicit UserData(std::unordered_map<uint32_t, UserDataField*> fields){
         _fields = std::move(fields);
     }
 
-    bool ContainsField(int fieldId){
+    bool ContainsField(uint32_t fieldId){
         return _fields.find(fieldId) != _fields.end();
     }
 
-    UserDataField* GetField(int fieldId){
+    UserDataField* GetField(uint32_t fieldId){
         return _fields[fieldId];
     }
+
+    void CreateField(uint32_t fieldId, UserDataField* field){
+        _fields.insert({fieldId, field});
+    }
+
+    int32_t GetFieldCount(){
+        return _fields.size();
+    }
 };
 
 

src/UserData/UserDataField.cpp

@@ -1,2 +1,8 @@
 
 #include "UserDataField.hpp"
+
+extern "C"{
+    UserDataField* CreateUserDataField(ScriptType* type, EvalValue* (*getter)(void* obj), void (*setter)(void* obj, EvalValue* val)){
+        return new UserDataField(type, getter, setter);
+    }
+}

src/UserData/UserDataField.hpp

@@ -4,6 +4,7 @@
 
 
 #include "../Evaluator/EvalValues/EvalValue.hpp"
+#include "../Evaluator/EvalValues/NumericEvalValue.hpp"
 
 class UserDataField {
     shared_ptr<ScriptType> _type;

src/UserData/UserDataScriptType.hpp

@@ -1,8 +1,9 @@
 
+
 #ifndef PORYGONLANG_USERDATASCRIPTTYPE_HPP
 #define PORYGONLANG_USERDATASCRIPTTYPE_HPP
 
-
+#include <utility>
 #include "../ScriptType.hpp"
 #include "UserData.hpp"
 #include "UserDataStorage.hpp"
@@ -10,12 +11,21 @@
 class UserDataScriptType : public ScriptType{
     shared_ptr<UserData> _userData;
 public:
-    explicit UserDataScriptType(int id) : ScriptType(TypeClass::UserData){
+    explicit UserDataScriptType(uint32_t id) : ScriptType(TypeClass::UserData){
         _userData = UserDataStorage::GetUserDataType(id);
     }
+    explicit UserDataScriptType(shared_ptr<UserData> ud) : ScriptType(TypeClass::UserData){
+        _userData = std::move(ud);
+    }
 
     bool CanBeIndexedWith(ScriptType* indexer) final{
-        return indexer->GetClass() == TypeClass ::String;
+        if (indexer->GetClass() != TypeClass ::String){
+            return false;
+        }
+        auto str = (StringScriptType*)indexer;
+        if (!str->IsKnownAtBind())
+            return false;
+        return _userData->ContainsField(str->GetHashValue());
     }
 
     shared_ptr<ScriptType> GetIndexedType(ScriptType* indexer) final{

src/UserData/UserDataStorage.hpp

@@ -8,16 +8,20 @@
 class UserDataStorage {
     class _internalDataStorage{
     public:
-        std::unordered_map<int, shared_ptr<UserData>> _userData;
+        std::unordered_map<uint32_t, shared_ptr<UserData>> _userData;
     };
     static _internalDataStorage _internal;
 
 public:
-    static void RegisterType(int i, UserData* ud){
+    static void RegisterType(uint32_t i, UserData* ud){
         UserDataStorage::_internal._userData.insert({i, shared_ptr<UserData>(ud)});
     }
 
-    static shared_ptr<UserData> GetUserDataType(int i){
+    static bool HasUserDataType(uint32_t i){
+        return UserDataStorage::_internal._userData.find(i) != UserDataStorage::_internal._userData.end();
+    }
+
+    static shared_ptr<UserData> GetUserDataType(uint32_t i){
         return UserDataStorage::_internal._userData[i];
     }
 };

src/UserData/UserDataValue.cpp

@@ -1,2 +1,8 @@
 
 #include "UserDataValue.hpp"
+
+extern "C"{
+    UserDataValue* CreateUserDataEvalValue(uint32_t typeHash, void* obj){
+        return new UserDataValue(typeHash, obj);
+    }
+}

src/UserData/UserDataValue.hpp

@@ -17,7 +17,7 @@ public:
         _obj = obj;
     }
 
-    UserDataValue(int userDataId, void* obj){
+    UserDataValue(uint32_t userDataId, void* obj){
         _userData = UserDataStorage::GetUserDataType(userDataId);
         _obj = obj;
     }