Drop internal string tracking

Author: adazem009

include/scratchcpp/string_pool.h

@@ -11,7 +11,7 @@ struct StringPtr;
 
 extern "C"
 {
-    LIBSCRATCHCPP_EXPORT StringPtr *string_pool_new(bool internal = true);
+    LIBSCRATCHCPP_EXPORT StringPtr *string_pool_new();
     LIBSCRATCHCPP_EXPORT void string_pool_free(StringPtr *str);
 }
 

src/engine/internal/engine.cpp

@@ -50,7 +50,7 @@ Engine::Engine() :
     m_clock(Clock::instance().get()),
     m_audioEngine(IAudioEngine::instance())
 {
-    m_answer = string_pool_new(false);
+    m_answer = string_pool_new();
     string_assign_cstring(m_answer, "");
 
     m_questionAnswered.connect([this](const std::string &answer) {

src/engine/internal/llvm/llvmbuildutils.cpp

@@ -815,7 +815,7 @@ void LLVMBuildUtils::createValueStore(
 
             // Create a new string, change type and assign
             llvm::Value *ptr = m_builder.CreateStructGEP(m_valueDataType, destPtr, 0);
-            llvm::Value *destStringPtr = m_builder.CreateCall(m_functions.resolve_string_pool_new(), m_builder.getInt1(false));
+            llvm::Value *destStringPtr = m_builder.CreateCall(m_functions.resolve_string_pool_new());
 
             m_builder.CreateStore(m_builder.getInt32(static_cast<uint32_t>(ValueType::String)), destTypePtr);
             m_builder.CreateStore(destStringPtr, ptr);
@@ -879,7 +879,7 @@ void LLVMBuildUtils::createValueStore(
 
             // Create a new string, change type and assign
             llvm::Value *ptr = m_builder.CreateStructGEP(m_valueDataType, destPtr, 0);
-            llvm::Value *destStringPtr = m_builder.CreateCall(m_functions.resolve_string_pool_new(), m_builder.getInt1(false));
+            llvm::Value *destStringPtr = m_builder.CreateCall(m_functions.resolve_string_pool_new());
 
             m_builder.CreateStore(m_builder.getInt32(static_cast<uint32_t>(ValueType::String)), destTypePtr);
             m_builder.CreateStore(destStringPtr, ptr);

src/engine/internal/llvm/llvmfunctions.cpp

@@ -284,7 +284,7 @@ llvm::FunctionCallee LLVMFunctions::resolve_llvm_get_string_array()
 
 llvm::FunctionCallee LLVMFunctions::resolve_string_pool_new()
 {
-    return resolveFunction("string_pool_new", llvm::FunctionType::get(m_stringPtrType->getPointerTo(), { m_builder->getInt1Ty() }, false));
+    return resolveFunction("string_pool_new", llvm::FunctionType::get(m_stringPtrType->getPointerTo(), false));
 }
 
 llvm::FunctionCallee LLVMFunctions::resolve_string_pool_free()

src/scratch/string_pool.cpp

@@ -5,40 +5,30 @@
 #include <scratchcpp/string_functions.h>
 #include <memory>
 #include <unordered_set>
-#include <unordered_map>
 #include <map>
 #include <cassert>
 #include <algorithm>
 
 namespace libscratchcpp
 {
 
-class Thread;
-
 static std::unordered_set<std::unique_ptr<StringPtr>> strings;
 static std::multimap<size_t, StringPtr *> freeStrings; // sorted by allocated space
 
-static std::unordered_map<Thread *, std::unordered_set<StringPtr *>> threadStrings;
-static Thread *currentThread = nullptr;
-
 extern "C"
 {
     /*!
      * Use this instead of dynamically allocating StringPtr.
-     * \param[in] internal Whether the string should be deallocated when the current thread is removed (it's only used within the thread).
      * \note The returned string is uninitialized. Use e. g. string_assign_cstring() to initialize it.
      */
-    StringPtr *string_pool_new(bool internal)
+    StringPtr *string_pool_new()
     {
         if (freeStrings.empty()) {
             auto str = std::make_unique<StringPtr>();
             StringPtr *ptr = str.get();
             assert(strings.find(str) == strings.cend());
             strings.insert(std::move(str));
 
-            if (internal && currentThread)
-                threadStrings[currentThread].insert(ptr);
-
             return ptr;
         }
 
@@ -47,51 +37,16 @@ extern "C"
         StringPtr *ptr = last->second;
         freeStrings.erase(last);
 
-        if (internal && currentThread)
-            threadStrings[currentThread].insert(ptr);
-
         return ptr;
     }
 
     /*! Invalidates the given StringPtr so that it can be used for new strings later. */
     void string_pool_free(StringPtr *str)
     {
-        if (currentThread)
-            threadStrings[currentThread].erase(str);
-
         assert(std::find_if(freeStrings.begin(), freeStrings.end(), [str](const std::pair<size_t, StringPtr *> &p) { return p.second == str; }) == freeStrings.end());
         assert(std::find_if(strings.begin(), strings.end(), [str](const std::unique_ptr<StringPtr> &p) { return p.get() == str; }) != strings.end());
         freeStrings.insert(std::pair<size_t, StringPtr *>(str->allocatedSize, str));
     }
 }
 
-/* string_pool_p.h */
-
-void string_pool_add_thread(Thread *thread)
-{
-    // Start capturing allocated strings in the thread
-    assert(threadStrings.find(thread) == threadStrings.cend());
-    threadStrings[thread] = {};
-}
-
-void string_pool_remove_thread(Thread *thread)
-{
-    // Free all strings in the thread (garbage collection)
-    assert(threadStrings.find(thread) != threadStrings.cend());
-    auto &strings = threadStrings[thread];
-
-    for (StringPtr *str : strings)
-        freeStrings.insert(std::pair<size_t, StringPtr *>(str->allocatedSize, str));
-
-    threadStrings.erase(thread);
-
-    if (currentThread == thread)
-        currentThread = nullptr;
-}
-
-void string_pool_set_thread(Thread *thread)
-{
-    currentThread = thread;
-}
-
 } // namespace libscratchcpp

src/scratch/value_functions.cpp

@@ -63,7 +63,7 @@ extern "C"
     void value_assign_cstring(ValueData *v, const char *stringValue)
     {
         if (v->type != ValueType::String) {
-            v->stringValue = string_pool_new(false);
+            v->stringValue = string_pool_new();
             v->type = ValueType::String;
         }
 
@@ -74,7 +74,7 @@ extern "C"
     void value_assign_stringPtr(ValueData *v, const StringPtr *stringValue)
     {
         if (v->type != ValueType::String) {
-            v->stringValue = string_pool_new(false);
+            v->stringValue = string_pool_new();
             v->type = ValueType::String;
         }
 
@@ -103,7 +103,7 @@ extern "C"
             if (v->type == ValueType::String)
                 string_assign(v->stringValue, another->stringValue);
             else {
-                v->stringValue = string_pool_new(false);
+                v->stringValue = string_pool_new();
                 string_assign(v->stringValue, another->stringValue);
                 v->type = ValueType::String;
             }