Refactor strings

CMakeLists.txt

@@ -38,6 +38,9 @@ target_sources(scratchcpp
     include/scratchcpp/value.h
     include/scratchcpp/valuedata.h
     include/scratchcpp/value_functions.h
+    include/scratchcpp/stringptr.h
+    include/scratchcpp/string_functions.h
+    include/scratchcpp/string_pool.h
     include/scratchcpp/entity.h
     include/scratchcpp/variable.h
     include/scratchcpp/list.h
@@ -77,6 +80,10 @@ target_link_libraries(scratchcpp PRIVATE zip)
 set(UTFCPP_SRC thirdparty/utfcpp/source)
 target_include_directories(scratchcpp PUBLIC ${UTFCPP_SRC})
 
+# cpp-unicodelib
+add_subdirectory(thirdparty/cpp-unicodelib)
+target_link_libraries(scratchcpp PRIVATE cpp-unicodelib)
+
 # spimpl
 include_directories(thirdparty/spimpl)
 

include/scratchcpp/compiler.h

@@ -56,6 +56,8 @@ class LIBSCRATCHCPP_EXPORT Compiler
         CompilerValue *addTargetFunctionCall(const std::string &functionName, StaticType returnType = StaticType::Void, const ArgTypes &argTypes = {}, const Args &args = {});
         CompilerValue *addFunctionCallWithCtx(const std::string &functionName, StaticType returnType = StaticType::Void, const ArgTypes &argTypes = {}, const Args &args = {});
         CompilerConstant *addConstValue(const Value &value);
+        CompilerValue *addStringChar(CompilerValue *string, CompilerValue *index);
+        CompilerValue *addStringLength(CompilerValue *string);
         CompilerValue *addLoopIndex();
         CompilerValue *addLocalVariableValue(CompilerLocalVariable *variable);
         CompilerValue *addVariableValue(Variable *variable);
@@ -104,6 +106,8 @@ class LIBSCRATCHCPP_EXPORT Compiler
         CompilerValue *createExp(CompilerValue *num);
         CompilerValue *createExp10(CompilerValue *num);
 
+        CompilerValue *createStringConcat(CompilerValue *string1, CompilerValue *string2);
+
         CompilerValue *createSelect(CompilerValue *cond, CompilerValue *trueValue, CompilerValue *falseValue, Compiler::StaticType valueType);
 
         CompilerLocalVariable *createLocalVariable(Compiler::StaticType type);

include/scratchcpp/list.h

@@ -3,10 +3,13 @@
 #pragma once
 
 #include <string>
-#include <scratchcpp/veque.h>
 
 #include "value.h"
 #include "entity.h"
+#include "string_pool.h"
+#include "string_functions.h"
+#include "stringptr.h"
+#include "veque.h"
 
 namespace libscratchcpp
 {
@@ -143,21 +146,21 @@ class LIBSCRATCHCPP_EXPORT List : public Entity
             return m_dataPtr->operator[](index);
         }
 
-        /*! Joins the list items with spaces or without any separator if there are only digits and stores the result in dst. */
-        inline void toString(std::string &dst) const
+        /*! Joins the list items with spaces or without any separator if there are only digits and returns the result as StringPtr. */
+        inline StringPtr *toStringPtr() const
         {
-            dst.clear();
-            veque::veque<std::string> strings;
+            veque::veque<StringPtr *> strings;
+            size_t size = 0;
             strings.reserve(m_size);
             bool digits = true;
             size_t i;
 
             for (i = 0; i < m_size; i++) {
                 const ValueData *item = &m_dataPtr->operator[](i);
-                strings.push_back(std::string());
-                value_toString(item, &strings.back());
+                strings.push_back(value_toStringPtr(item));
+                size += strings.back()->size;
 
-                if (value_isValidNumber(item) && !value_isBool(item) && !strings.back().empty()) {
+                if (value_isValidNumber(item) && !value_isBool(item) && strings.back()->size > 0) {
                     double doubleNum = value_toDouble(item);
                     long num = value_toLong(item);
 
@@ -176,42 +179,58 @@ class LIBSCRATCHCPP_EXPORT List : public Entity
                 }
             }
 
-            std::string s;
+            StringPtr *ret = string_pool_new();
+            ret->size = 0;
 
             if (digits) {
-                for (i = 0; i < strings.size(); i++)
-                    dst.append(strings[i]);
+                string_alloc(ret, size);
+
+                for (i = 0; i < strings.size(); i++) {
+                    memcpy(ret->data + ret->size, strings[i]->data, strings[i]->size * sizeof(char16_t));
+                    ret->size += strings[i]->size;
+                    string_pool_free(strings[i]);
+                }
 
                 for (; i < m_size; i++) {
-                    value_toString(&m_dataPtr->operator[](i), &s);
-                    dst.append(s);
+                    StringPtr *item = value_toStringPtr(&m_dataPtr->operator[](i));
+                    size += item->size + 1;
+                    string_alloc(ret, size);
+                    memcpy(ret->data + ret->size, item->data, item->size * sizeof(char16_t));
+                    ret->size += item->size;
+                    string_pool_free(item);
                 }
             } else {
+                size += strings.size() - 1;
+                string_alloc(ret, size);
+
                 for (i = 0; i < strings.size(); i++) {
-                    dst.append(strings[i]);
+                    memcpy(ret->data + ret->size, strings[i]->data, strings[i]->size * sizeof(char16_t));
+                    ret->size += strings[i]->size;
+                    string_pool_free(strings[i]);
 
                     if (i + 1 < m_size)
-                        dst.push_back(' ');
+                        ret->data[ret->size++] = u' ';
                 }
 
                 for (; i < m_size; i++) {
-                    value_toString(&m_dataPtr->operator[](i), &s);
-                    dst.append(s);
+                    StringPtr *item = value_toStringPtr(&m_dataPtr->operator[](i));
+                    size += item->size + 1;
+                    string_alloc(ret, size);
+                    memcpy(ret->data + ret->size, item->data, item->size * sizeof(char16_t));
+                    ret->size += item->size;
+                    string_pool_free(item);
 
                     if (i + 1 < m_size)
-                        dst.push_back(' ');
+                        ret->data[ret->size++] = u' ';
                 }
             }
-        }
 
-        /*! Same as the other method, but returns the result directly. */
-        inline std::string toString() const
-        {
-            std::string ret;
-            toString(ret);
+            ret->data[ret->size] = u'\0';
             return ret;
         }
 
+        std::string toString() const;
+
         std::shared_ptr<List> clone();
 
     private:

include/scratchcpp/string_functions.h

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <cstddef>
+
+#include "global.h"
+
+namespace libscratchcpp
+{
+
+struct StringPtr;
+
+extern "C"
+{
+    LIBSCRATCHCPP_EXPORT void string_alloc(StringPtr *str, size_t size);
+
+    LIBSCRATCHCPP_EXPORT void string_assign(StringPtr *str, const StringPtr *another);
+    LIBSCRATCHCPP_EXPORT void string_assign_cstring(StringPtr *str, const char *another);
+
+    LIBSCRATCHCPP_EXPORT int string_compare_raw_case_sensitive(const char16_t *str1, size_t n1, const char16_t *str2, size_t n2);
+    LIBSCRATCHCPP_EXPORT int string_compare_case_sensitive(const StringPtr *str1, const StringPtr *str2);
+
+    LIBSCRATCHCPP_EXPORT int string_compare_raw_case_insensitive(const char16_t *str1, size_t n1, const char16_t *str2, size_t n2);
+    LIBSCRATCHCPP_EXPORT int string_compare_case_insensitive(const StringPtr *str1, const StringPtr *str2);
+
+    LIBSCRATCHCPP_EXPORT bool string_contains_raw_case_sensitive(const char16_t *str, const char16_t *substr);
+    LIBSCRATCHCPP_EXPORT bool string_contains_case_sensitive(const StringPtr *str, const StringPtr *substr);
+
+    LIBSCRATCHCPP_EXPORT bool string_contains_raw_case_insensitive(const char16_t *str, const char16_t *substr);
+    LIBSCRATCHCPP_EXPORT bool string_contains_case_insensitive(const StringPtr *str, const StringPtr *substr);
+}
+
+} // namespace libscratchcpp

include/scratchcpp/string_pool.h

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "global.h"
+
+namespace libscratchcpp
+{
+
+struct StringPtr;
+
+extern "C"
+{
+    LIBSCRATCHCPP_EXPORT StringPtr *string_pool_new(bool internal = false);
+    LIBSCRATCHCPP_EXPORT void string_pool_free(StringPtr *str);
+}
+
+} // namespace libscratchcpp

include/scratchcpp/stringptr.h

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "global.h"
+#include "string_functions.h"
+
+namespace libscratchcpp
+{
+
+extern "C"
+{
+    /*! \brief The StringPtr struct holds a string data pointer and string size */
+    struct LIBSCRATCHCPP_EXPORT StringPtr
+    {
+            // NOTE: Constructors and destructors only work in C++ code and are not supposed to be used in LLVM IR
+            StringPtr() = default;
+            StringPtr(const std::string &str) { string_assign_cstring(this, str.c_str()); }
+            StringPtr(const StringPtr &) = delete;
+
+            ~StringPtr()
+            {
+                if (data && allocatedSize > 0)
+                    free(data);
+            }
+
+            // NOTE: Any changes must also be done in the LLVM code builder!
+            char16_t *data = nullptr;
+            size_t size = 0;
+            size_t allocatedSize = 0;
+    };
+}
+
+} // namespace libscratchcpp

include/scratchcpp/thread.h

@@ -20,6 +20,7 @@ class LIBSCRATCHCPP_EXPORT Thread
     public:
         Thread(Target *target, IEngine *engine, Script *script);
         Thread(const Thread &) = delete;
+        ~Thread();
 
         Target *target() const;
         IEngine *engine() const;

include/scratchcpp/value.h

@@ -132,7 +132,7 @@ class LIBSCRATCHCPP_EXPORT Value
         };
 
         /*! Returns the UTF-16 representation of the value. */
-        std::u16string toUtf16()
+        std::u16string toUtf16() const
         {
             std::u16string ret;
             value_toUtf16(&m_data, &ret);

include/scratchcpp/value_functions.h

@@ -54,6 +54,7 @@ extern "C"
     LIBSCRATCHCPP_EXPORT void value_assign_bool(ValueData *v, bool boolValue);
     LIBSCRATCHCPP_EXPORT void value_assign_string(ValueData *v, const std::string &stringValue);
     LIBSCRATCHCPP_EXPORT void value_assign_cstring(ValueData *v, const char *stringValue);
+    LIBSCRATCHCPP_EXPORT void value_assign_stringPtr(ValueData *v, const StringPtr *stringValue);
     LIBSCRATCHCPP_EXPORT void value_assign_copy(ValueData *v, const ValueData *another);
 
     LIBSCRATCHCPP_EXPORT bool value_isInfinity(const ValueData *v);
@@ -70,16 +71,16 @@ extern "C"
     LIBSCRATCHCPP_EXPORT double value_toDouble(const ValueData *v);
     LIBSCRATCHCPP_EXPORT bool value_toBool(const ValueData *v);
     LIBSCRATCHCPP_EXPORT void value_toString(const ValueData *v, std::string *dst);
-    LIBSCRATCHCPP_EXPORT char *value_toCString(const ValueData *v);
+    LIBSCRATCHCPP_EXPORT StringPtr *value_toStringPtr(const ValueData *v);
     LIBSCRATCHCPP_EXPORT void value_toUtf16(const ValueData *v, std::u16string *dst);
     LIBSCRATCHCPP_EXPORT Rgb value_toRgba(const ValueData *v);
 
     LIBSCRATCHCPP_EXPORT bool value_doubleIsInt(double v);
 
-    LIBSCRATCHCPP_EXPORT char *value_doubleToCString(double v);
-    LIBSCRATCHCPP_EXPORT const char *value_boolToCString(bool v);
-    LIBSCRATCHCPP_EXPORT double value_stringToDouble(const char *s);
-    LIBSCRATCHCPP_EXPORT bool value_stringToBool(const char *s);
+    LIBSCRATCHCPP_EXPORT StringPtr *value_doubleToStringPtr(double v);
+    LIBSCRATCHCPP_EXPORT const StringPtr *value_boolToStringPtr(bool v);
+    LIBSCRATCHCPP_EXPORT double value_stringToDouble(const StringPtr *s);
+    LIBSCRATCHCPP_EXPORT bool value_stringToBool(const StringPtr *s);
 
     LIBSCRATCHCPP_EXPORT void value_add(const ValueData *v1, const ValueData *v2, ValueData *dst);
     LIBSCRATCHCPP_EXPORT void value_subtract(const ValueData *v1, const ValueData *v2, ValueData *dst);

include/scratchcpp/valuedata.h

@@ -9,6 +9,8 @@
 namespace libscratchcpp
 {
 
+struct StringPtr;
+
 enum class LIBSCRATCHCPP_EXPORT ValueType
 {
     Number = 0,
@@ -26,11 +28,10 @@ extern "C"
             {
                     double numberValue;
                     bool boolValue;
-                    char *stringValue;
+                    StringPtr *stringValue;
             };
 
             ValueType type;
-            size_t stringSize; // allocated size, not length
     };
 }
 

src/blocks/controlblocks.cpp

@@ -11,6 +11,9 @@
 #include <scratchcpp/istacktimer.h>
 #include <scratchcpp/variable.h>
 #include <scratchcpp/sprite.h>
+#include <scratchcpp/stringptr.h>
+#include <scratchcpp/string_functions.h>
+#include <utf8.h>
 
 #include "controlblocks.h"
 
@@ -215,13 +218,15 @@ extern "C" void control_create_clone_by_index(ExecutionContext *ctx, double inde
         static_cast<Sprite *>(target)->clone();
 }
 
-extern "C" void control_create_clone(ExecutionContext *ctx, const char *spriteName)
+extern "C" void control_create_clone(ExecutionContext *ctx, const StringPtr *spriteName)
 {
-    if (strcmp(spriteName, "_myself_") == 0)
+    static const StringPtr myself("_myself_");
+    if (string_compare_case_sensitive(spriteName, &myself) == 0)
         control_create_clone_of_myself(ctx->thread()->target());
     else {
         IEngine *engine = ctx->engine();
-        auto index = engine->findTarget(spriteName);
+        // TODO: Use UTF-16 in engine
+        auto index = engine->findTarget(utf8::utf16to8(std::u16string(spriteName->data)));
         Target *target = engine->targetAt(index);
 
         if (!target->isStage())

src/blocks/eventblocks.cpp

@@ -9,6 +9,8 @@
 #include <scratchcpp/thread.h>
 #include <scratchcpp/compilerconstant.h>
 #include <scratchcpp/promise.h>
+#include <scratchcpp/stringptr.h>
+#include <utf8.h>
 
 #include "eventblocks.h"
 
@@ -125,11 +127,12 @@ CompilerValue *EventBlocks::compileWhenKeyPressed(Compiler *compiler)
     return nullptr;
 }
 
-extern "C" void event_broadcast(ExecutionContext *ctx, const char *name, bool wait)
+extern "C" void event_broadcast(ExecutionContext *ctx, const StringPtr *name, bool wait)
 {
     Thread *thread = ctx->thread();
     IEngine *engine = thread->engine();
-    std::vector<int> broadcasts = engine->findBroadcasts(name);
+    // TODO: Use UTF-16 in engine
+    std::vector<int> broadcasts = engine->findBroadcasts(utf8::utf16to8(std::u16string(name->data)));
 
     for (int index : broadcasts)
         engine->broadcast(index, thread, wait);