Add string functions

Author: adazem009

CMakeLists.txt

@@ -39,6 +39,7 @@ target_sources(scratchcpp
     include/scratchcpp/valuedata.h
     include/scratchcpp/value_functions.h
     include/scratchcpp/stringptr.h
+    include/scratchcpp/string_functions.h
     include/scratchcpp/entity.h
     include/scratchcpp/variable.h
     include/scratchcpp/list.h

include/scratchcpp/string_functions.h

@@ -0,0 +1,21 @@
+// 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);
+}
+
+} // namespace libscratchcpp

src/scratch/CMakeLists.txt

@@ -2,6 +2,7 @@ target_sources(scratchcpp
   PRIVATE
     value_functions.cpp
     value_functions_p.h
+    string_functions.cpp
     drawable.cpp
     drawable_p.cpp
     drawable_p.h

src/scratch/string_functions.cpp

@@ -0,0 +1,66 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include <scratchcpp/string_functions.h>
+#include <scratchcpp/stringptr.h>
+#include <cmath>
+#include <cstring>
+#include <cassert>
+#include <utf8.h>
+
+namespace libscratchcpp
+{
+
+extern "C"
+{
+
+    /*! Ensures at least the given size is allocated on str. */
+    void string_alloc(StringPtr *str, size_t size)
+    {
+        size++; // null terminator
+
+        if (str->allocatedSize < size) {
+            // TODO: Use std::bit_ceil() in C++20
+            const size_t newSize = std::pow(2, std::ceil(std::log2(size)));
+            assert((str->data && str->allocatedSize > 0) || (!str->data && str->allocatedSize == 0));
+
+            if (str->data)
+                str->data = (typeof(str->data))realloc(str->data, newSize * sizeof(typeof(*str->data)));
+            else
+                str->data = (typeof(str->data))malloc(newSize * sizeof(typeof(*str->data)));
+
+            str->allocatedSize = newSize;
+        }
+    }
+
+    /*! Assigns the given string to str. */
+    void string_assign(StringPtr *str, const StringPtr *another)
+    {
+        if (another->size == 0) {
+            str->size = 0;
+            return;
+        }
+
+        string_alloc(str, another->size);
+        str->size = another->size;
+        memcpy(str->data, another->data, (another->size + 1) * sizeof(typeof(*str->data)));
+    }
+
+    /*! Assigns the given string to str. */
+    void string_assign_cstring(StringPtr *str, const char *another)
+    {
+        if (!another) {
+            str->size = 0;
+            string_alloc(str, 0);
+            str->data[0] = u'\0';
+            return;
+        }
+
+        // TODO: Use a library to map characters
+        std::u16string converted = utf8::utf8to16(std::string(another));
+        string_alloc(str, converted.size());
+        str->size = converted.size();
+        memcpy(str->data, converted.data(), (converted.size() + 1) * sizeof(typeof(*str->data)));
+    }
+}
+
+} // namespace libscratchcpp

test/scratch_classes/CMakeLists.txt

@@ -121,6 +121,20 @@ target_link_libraries(
 
 gtest_discover_tests(value_test)
 
+# string_functions_test
+add_executable(
+  string_functions_test
+  string_functions_test.cpp
+)
+
+target_link_libraries(
+  string_functions_test
+  GTest::gtest_main
+  scratchcpp
+)
+
+gtest_discover_tests(string_functions_test)
+
 # entity_test
 add_executable(
   entity_test

test/scratch_classes/string_functions_test.cpp

@@ -0,0 +1,72 @@
+#include <scratchcpp/string_functions.h>
+#include <scratchcpp/stringptr.h>
+
+#include "../common.h"
+
+using namespace libscratchcpp;
+
+TEST(StringFunctionsTest, AssignAlloc)
+{
+    StringPtr str1;
+    ASSERT_FALSE(str1.data);
+    ASSERT_EQ(str1.size, 0);
+    ASSERT_EQ(str1.allocatedSize, 0);
+
+    string_assign_cstring(&str1, "test");
+    ASSERT_EQ(str1.size, 4);
+    ASSERT_GE(str1.allocatedSize, 5);
+    ASSERT_TRUE(str1.data);
+    ASSERT_EQ(str1.data[0], u't');
+    ASSERT_EQ(str1.data[1], u'e');
+    ASSERT_EQ(str1.data[2], u's');
+    ASSERT_EQ(str1.data[3], u't');
+    ASSERT_EQ(str1.data[4], u'\0');
+
+    string_assign_cstring(&str1, "Hello world");
+    ASSERT_EQ(str1.size, 11);
+    ASSERT_GE(str1.allocatedSize, 12);
+    ASSERT_TRUE(str1.data);
+    ASSERT_EQ(str1.data[0], u'H');
+    ASSERT_EQ(str1.data[1], u'e');
+    ASSERT_EQ(str1.data[2], u'l');
+    ASSERT_EQ(str1.data[3], u'l');
+    ASSERT_EQ(str1.data[4], u'o');
+    ASSERT_EQ(str1.data[5], u' ');
+    ASSERT_EQ(str1.data[6], u'w');
+    ASSERT_EQ(str1.data[7], u'o');
+    ASSERT_EQ(str1.data[8], u'r');
+    ASSERT_EQ(str1.data[9], u'l');
+    ASSERT_EQ(str1.data[10], u'd');
+    ASSERT_EQ(str1.data[11], u'\0');
+
+    StringPtr str2;
+    string_alloc(&str2, 8);
+    ASSERT_GE(str2.allocatedSize, 9);
+    ASSERT_TRUE(str2.data);
+    str2.data[0] = u'a';
+    str2.data[1] = u'b';
+    str2.data[2] = u'c';
+    str2.data[3] = u'd';
+    str2.data[4] = u'e';
+    str2.data[5] = u'f';
+    str2.data[6] = u'g';
+    str2.data[7] = u'h';
+    str2.data[8] = u'\0';
+    str2.size = 8;
+    ASSERT_EQ(str2.data[0], u'a');
+    ASSERT_EQ(str2.data[1], u'b');
+    ASSERT_EQ(str2.data[2], u'c');
+    ASSERT_EQ(str2.data[3], u'd');
+    ASSERT_EQ(str2.data[4], u'e');
+    ASSERT_EQ(str2.data[5], u'f');
+    ASSERT_EQ(str2.data[6], u'g');
+    ASSERT_EQ(str2.data[7], u'h');
+    ASSERT_EQ(str2.data[8], u'\0');
+
+    string_assign(&str1, &str2);
+    ASSERT_EQ(str2.size, str1.size);
+    ASSERT_GE(str2.allocatedSize, str1.size + 1);
+    ASSERT_TRUE(str2.data);
+    ASSERT_NE(str2.data, str1.data);
+    ASSERT_EQ(memcmp(str2.data, str1.data, (str2.size + 1) * sizeof(typeof(*str2.data))), 0);
+}