Fix all valgrind leak issues in tests

Signed-off-by: Deukhoofd <deukhoofd@gmail.com>

src/Evaluator/EvalValues/EvalValue.cpp

@@ -23,8 +23,18 @@ namespace Porygon::Evaluation {
         return v->EvaluateBool();
     }
 
-    const char16_t *EvaluateEvalValueString(EvalValue *v) {
-        return (new u16string(v->EvaluateString()))->c_str();
+    size_t GetEvalValueStringLength(EvalValue *v) {
+        auto result = v->EvaluateString();
+        return result.size();
+    }
+
+    int EvaluateEvalValueString(EvalValue *v, char16_t dst[]){
+        auto result = v->EvaluateString();
+        for (int i = 0; i < result.size(); i++){
+            dst[i] = result[i];
+        }
+        dst[result.size() + 1] = '\0';
+        return 0;
     }
 
 
@@ -52,13 +62,18 @@ namespace Porygon::Evaluation {
 
 
 TEST_CASE( "Evaluate String", "[integration]" ) {
-    auto script = Porygon::Script::Create(u"\"foo bar\"");
+    auto sc = new u16string(u"\"foo bar\"");
+    auto script = Porygon::Script::Create(*sc);
     REQUIRE(!script->Diagnostics -> HasErrors());
     script->Evaluate();
     auto lastValue = script->GetLastValue();
-    auto s = u16string(EvaluateEvalValueString(lastValue));
+    size_t size = GetEvalValueStringLength(lastValue);
+    char16_t dst[size + 1];
+    EvaluateEvalValueString(lastValue, dst);
+    auto s = u16string(dst);
     REQUIRE(s == u"foo bar");
     delete script;
+    delete sc;
 }
 
 

src/Evaluator/Iterator/Iterator.hpp

@@ -25,7 +25,7 @@ namespace Porygon::Evaluation{
             : _iterator(table->GetTableIterator()), _end(table->GetTableIteratorEnd()){}
 
         shared_ptr<EvalValue> GetCurrent() final{
-            return make_shared<StringEvalValue>(_iterator->first.GetString());
+            return make_shared<StringEvalValue>(*_iterator->first.GetString());
         }
 
         bool MoveNext() final{

src/Parser/ParsedStatements/ParsedStatement.hpp

@@ -111,6 +111,10 @@ namespace Porygon::Parser {
             delete _expression;
         }
 
+        void NullifyExpression(){
+            _expression = nullptr;
+        }
+
         const ParsedStatementKind GetKind() const final {
             return ParsedStatementKind::Expression;
         }

src/Parser/Parser.cpp

@@ -525,7 +525,10 @@ namespace Porygon::Parser {
         // If the first item is an expression, and is followed by a comma, we're dealing with a simple {1, 2, 3} kind of array
         if (firstItem->GetKind() == ParsedStatementKind::Expression &&
             (this->Peek()->GetKind() == TokenKind::CommaToken)) {
-            auto expr = ((ParsedExpressionStatement *) firstItem)->GetExpression();
+            auto statement = ((ParsedExpressionStatement *) firstItem);
+            auto expr = statement->GetExpression();
+            statement->NullifyExpression();
+            delete statement;
             auto expressions = vector<const ParsedExpression *>{expr};
             auto n = this->Next(); // consume the comma
             bool hasErrors = false;

src/UserData/UserData.hpp

@@ -1,3 +1,5 @@
+#include <utility>
+
 #ifndef PORYGONLANG_USERDATA_HPP
 #define PORYGONLANG_USERDATA_HPP
 
@@ -9,23 +11,30 @@ namespace Porygon::UserData {
     class UserData {
         std::unordered_map<uint32_t, UserDataField *> _fields;
     public:
-        explicit UserData(std::unordered_map<uint32_t, UserDataField *> fields) {
-            _fields = std::move(fields);
+        explicit UserData(std::unordered_map<uint32_t, UserDataField *> fields)
+            : _fields(std::move(fields))
+        {
         }
 
-        bool ContainsField(uint32_t fieldId) {
+        ~UserData(){
+            for (auto f: _fields){
+                delete f.second;
+            }
+        }
+
+        bool ContainsField(uint32_t fieldId) const{
             return _fields.find(fieldId) != _fields.end();
         }
 
-        UserDataField *GetField(uint32_t fieldId) {
-            return _fields[fieldId];
+        UserDataField *GetField(uint32_t fieldId) const {
+            return _fields.at(fieldId);
         }
 
         void CreateField(uint32_t fieldId, UserDataField *field) {
             _fields.insert({fieldId, field});
         }
 
-        int32_t GetFieldCount() {
+        int32_t GetFieldCount() const{
             return _fields.size();
         }
     };

src/UserData/UserDataScriptType.hpp

@@ -10,14 +10,14 @@
 
 namespace Porygon::UserData {
     class UserDataScriptType : public ScriptType {
-        shared_ptr<UserData> _userData;
+        UserData* _userData;
     public:
         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);
+        explicit UserDataScriptType(UserData* ud) : ScriptType(TypeClass::UserData) {
+            _userData = ud;
         }
 
         const bool CanBeIndexedWith(ScriptType *indexer) const final {

src/UserData/UserDataStorage.hpp

@@ -3,27 +3,46 @@
 #define PORYGONLANG_USERDATASTORAGE_HPP
 
 #include <unordered_map>
+#include <mutex>
 #include "UserData.hpp"
 
 namespace Porygon::UserData {
     class UserDataStorage {
         class _internalDataStorage {
         public:
-            std::unordered_map<uint32_t, shared_ptr<UserData>> _userData;
+            std::unordered_map<uint32_t, UserData*> _userData;
+            std::mutex _userDataMutex;
+
+            ~_internalDataStorage(){
+                std::lock_guard<std::mutex> guard(_userDataMutex);
+                for (auto u: _userData){
+                    delete u.second;
+                }
+                _userData.clear();
+            }
         };
 
         static _internalDataStorage _internal;
 
     public:
         static void RegisterType(uint32_t i, UserData *ud) {
-            UserDataStorage::_internal._userData.insert({i, shared_ptr<UserData>(ud)});
+            std::lock_guard<std::mutex> guard(_internal._userDataMutex);
+            UserDataStorage::_internal._userData.insert({i, ud});
+        }
+
+        static void ClearTypes(){
+            std::lock_guard<std::mutex> guard(_internal._userDataMutex);
+            for (auto u: _internal._userData){
+                delete u.second;
+            }
+            _internal._userData.clear();
         }
 
         static bool HasUserDataType(uint32_t i) {
             return UserDataStorage::_internal._userData.find(i) != UserDataStorage::_internal._userData.end();
         }
 
-        static shared_ptr<UserData> GetUserDataType(uint32_t i) {
+        static UserData* GetUserDataType(uint32_t i) {
             return UserDataStorage::_internal._userData[i];
         }
     };

src/UserData/UserDataValue.hpp

@@ -9,11 +9,11 @@
 
 namespace Porygon::UserData {
     class UserDataValue : public Evaluation::EvalValue {
-        const shared_ptr<UserData> _userData;
+        const UserData* _userData;
         void *_obj;
     public:
-        UserDataValue(shared_ptr<UserData> userData, void *obj)
-                : _userData(std::move(userData)) {
+        UserDataValue(const UserData* userData, void *obj)
+                : _userData(userData) {
             _obj = obj;
         }