feat(libSceIcu): implement UTF-32, Java UTF-8, comparison and configuration exports

core/libs/prx/libSceIcu/CMakeLists.txt

@@ -1,4 +1,4 @@
-add_library(libSceIcu SHARED EXCLUDE_FROM_ALL Export.cpp Invariant.cpp Version.cpp Unescape.cpp)
+add_library(libSceIcu SHARED EXCLUDE_FROM_ALL Export.cpp Invariant.cpp Version.cpp Unescape.cpp Utf32.cpp JavaUtf8.cpp Compare.cpp Search.cpp Character.cpp Configuration.cpp)
 target_include_directories(libSceIcu PRIVATE ${LIBS_INCLUDE_DIR})
 configure_windows_unwind(libSceIcu)
 target_sources(libSceIcu PRIVATE CString.cpp)
@@ -41,3 +41,81 @@ if(BUILD_TESTING)
             "PATH=path_list_prepend:$<TARGET_FILE_DIR:libSceIcu>")
     endif()
 endif()
+
+if(BUILD_TESTING)
+    add_test_executable(guest_icu_utf32_tests ${CMAKE_CURRENT_SOURCE_DIR}/tests/Utf32.cpp)
+    target_include_directories(guest_icu_utf32_tests PRIVATE ${LIBS_INCLUDE_DIR})
+    target_link_libraries(guest_icu_utf32_tests PRIVATE libSceIcu)
+    configure_windows_unwind(guest_icu_utf32_tests)
+    add_test(NAME guest_icu_utf32 COMMAND guest_icu_utf32_tests)
+    set_tests_properties(guest_icu_utf32 PROPERTIES TIMEOUT 30)
+    if(WIN32)
+        set_tests_properties(guest_icu_utf32 PROPERTIES ENVIRONMENT_MODIFICATION
+            "PATH=path_list_prepend:$<TARGET_FILE_DIR:libSceIcu>")
+    endif()
+endif()
+
+if(BUILD_TESTING)
+    add_test_executable(guest_icu_java_utf8_tests ${CMAKE_CURRENT_SOURCE_DIR}/tests/JavaUtf8.cpp)
+    target_include_directories(guest_icu_java_utf8_tests PRIVATE ${LIBS_INCLUDE_DIR})
+    target_link_libraries(guest_icu_java_utf8_tests PRIVATE libSceIcu)
+    configure_windows_unwind(guest_icu_java_utf8_tests)
+    add_test(NAME guest_icu_java_utf8 COMMAND guest_icu_java_utf8_tests)
+    set_tests_properties(guest_icu_java_utf8 PROPERTIES TIMEOUT 30)
+    if(WIN32)
+        set_tests_properties(guest_icu_java_utf8 PROPERTIES ENVIRONMENT_MODIFICATION
+            "PATH=path_list_prepend:$<TARGET_FILE_DIR:libSceIcu>")
+    endif()
+endif()
+
+if(BUILD_TESTING)
+    add_test_executable(guest_icu_compare_tests ${CMAKE_CURRENT_SOURCE_DIR}/tests/Compare.cpp)
+    target_include_directories(guest_icu_compare_tests PRIVATE ${LIBS_INCLUDE_DIR})
+    target_link_libraries(guest_icu_compare_tests PRIVATE libSceIcu)
+    configure_windows_unwind(guest_icu_compare_tests)
+    add_test(NAME guest_icu_compare COMMAND guest_icu_compare_tests)
+    set_tests_properties(guest_icu_compare PROPERTIES TIMEOUT 30)
+    if(WIN32)
+        set_tests_properties(guest_icu_compare PROPERTIES ENVIRONMENT_MODIFICATION
+            "PATH=path_list_prepend:$<TARGET_FILE_DIR:libSceIcu>")
+    endif()
+endif()
+
+if(BUILD_TESTING)
+    add_test_executable(guest_icu_search_tests ${CMAKE_CURRENT_SOURCE_DIR}/tests/Search.cpp)
+    target_include_directories(guest_icu_search_tests PRIVATE ${LIBS_INCLUDE_DIR})
+    target_link_libraries(guest_icu_search_tests PRIVATE libSceIcu)
+    configure_windows_unwind(guest_icu_search_tests)
+    add_test(NAME guest_icu_search COMMAND guest_icu_search_tests)
+    set_tests_properties(guest_icu_search PROPERTIES TIMEOUT 30)
+    if(WIN32)
+        set_tests_properties(guest_icu_search PROPERTIES ENVIRONMENT_MODIFICATION
+            "PATH=path_list_prepend:$<TARGET_FILE_DIR:libSceIcu>")
+    endif()
+endif()
+
+if(BUILD_TESTING)
+    add_test_executable(guest_icu_character_tests ${CMAKE_CURRENT_SOURCE_DIR}/tests/Character.cpp)
+    target_include_directories(guest_icu_character_tests PRIVATE ${LIBS_INCLUDE_DIR})
+    target_link_libraries(guest_icu_character_tests PRIVATE libSceIcu)
+    configure_windows_unwind(guest_icu_character_tests)
+    add_test(NAME guest_icu_character COMMAND guest_icu_character_tests)
+    set_tests_properties(guest_icu_character PROPERTIES TIMEOUT 30)
+    if(WIN32)
+        set_tests_properties(guest_icu_character PROPERTIES ENVIRONMENT_MODIFICATION
+            "PATH=path_list_prepend:$<TARGET_FILE_DIR:libSceIcu>")
+    endif()
+endif()
+
+if(BUILD_TESTING)
+    add_test_executable(guest_icu_configuration_tests ${CMAKE_CURRENT_SOURCE_DIR}/tests/Configuration.cpp)
+    target_include_directories(guest_icu_configuration_tests PRIVATE ${LIBS_INCLUDE_DIR})
+    target_link_libraries(guest_icu_configuration_tests PRIVATE libSceIcu)
+    configure_windows_unwind(guest_icu_configuration_tests)
+    add_test(NAME guest_icu_configuration COMMAND guest_icu_configuration_tests)
+    set_tests_properties(guest_icu_configuration PROPERTIES TIMEOUT 30)
+    if(WIN32)
+        set_tests_properties(guest_icu_configuration PROPERTIES ENVIRONMENT_MODIFICATION
+            "PATH=path_list_prepend:$<TARGET_FILE_DIR:libSceIcu>")
+    endif()
+endif()

core/libs/prx/libSceIcu/Character.cpp

@@ -0,0 +1,27 @@
+#include "prx/libSceIcu/libSceIcu.hpp"
+#include "prx/libSceIcu/Status.hpp"
+#include <cstdint>
+
+extern "C" {
+
+std::int8_t APS5_VABI u_isISOControl_nid_postfix(std::int32_t character) {
+    return static_cast<std::uint32_t>(character) <= 0x9f && (character <= 0x1f || character >= 0x7f);
+}
+
+std::int32_t APS5_VABI u_forDigit_nid_postfix(std::int32_t digit, std::int8_t radix) {
+    if (radix < 2 || radix > 36 || digit < 0 || digit >= radix) return 0;
+    return digit < 10 ? '0' + digit : 'a' - 10 + digit;
+}
+
+
+std::int32_t APS5_VABI u_getISOComment_nid_postfix(std::int32_t, char* destination, std::int32_t capacity, std::int32_t* status) {
+    if (!status || *status > 0) return 0;
+    if (capacity < 0 || (capacity > 0 && !destination)) {
+        *status = Icu::IllegalArgument;
+        return 0;
+    }
+    Icu::Terminate(destination, capacity, 0, status);
+    return 0;
+}
+
+}

core/libs/prx/libSceIcu/Character.hpp

@@ -0,0 +1,9 @@
+#pragma once
+#include "prx/libc/include/general/VabiMacros.hpp"
+#include <cstdint>
+
+extern "C" {
+std::int8_t APS5_VABI u_isISOControl_nid_postfix(std::int32_t);
+std::int32_t APS5_VABI u_forDigit_nid_postfix(std::int32_t, std::int8_t);
+std::int32_t APS5_VABI u_getISOComment_nid_postfix(std::int32_t, char*, std::int32_t, std::int32_t*);
+}

core/libs/prx/libSceIcu/Compare.cpp

@@ -0,0 +1,58 @@
+#include "prx/libSceIcu/libSceIcu.hpp"
+#include "prx/libSceIcu/Status.hpp"
+#include <cstdint>
+
+namespace {
+
+bool Lead(std::int32_t unit) { return unit >= 0xd800 && unit <= 0xdbff; }
+bool Trail(std::int32_t unit) { return unit >= 0xdc00 && unit <= 0xdfff; }
+
+std::int64_t Measure(const char16_t* text) {
+    std::int64_t length = 0;
+    while (text[length] != 0) ++length;
+    return length;
+}
+
+std::int32_t CodePointOrder(const char16_t* text, std::int64_t index, std::int64_t length) {
+    std::int32_t unit = text[index];
+    const bool pair = (Lead(unit) && (length < 0 || index + 1 < length) && Trail(text[index + 1])) ||
+                      (Trail(unit) && index > 0 && Lead(text[index - 1]));
+    return pair ? unit : unit - 0x2800;
+}
+
+}
+
+extern "C" {
+
+std::int32_t APS5_VABI u_strCompare_nid_postfix(const char16_t* first, std::int32_t firstLength, const char16_t* second,
+                                                std::int32_t secondLength, std::int8_t codePointOrder) {
+    if (!first || firstLength < -1 || !second || secondLength < -1) return 0;
+    const bool terminated = firstLength < 0 && secondLength < 0;
+    std::int64_t limit1 = firstLength;
+    std::int64_t limit2 = secondLength;
+    std::int32_t equalResult = 0;
+    std::int64_t index = 0;
+    if (terminated) {
+        if (first == second) return 0;
+        for (; first[index] == second[index]; ++index) {
+            if (first[index] == 0) return 0;
+        }
+    } else {
+        if (limit1 < 0) limit1 = Measure(first);
+        if (limit2 < 0) limit2 = Measure(second);
+        const auto common = limit1 < limit2 ? limit1 : limit2;
+        equalResult = limit1 < limit2 ? -1 : limit1 > limit2 ? 1 : 0;
+        if (first == second) return equalResult;
+        for (; index < common && first[index] == second[index]; ++index) {}
+        if (index == common) return equalResult;
+    }
+    std::int32_t unit1 = first[index];
+    std::int32_t unit2 = second[index];
+    if (unit1 >= 0xd800 && unit2 >= 0xd800 && codePointOrder) {
+        unit1 = CodePointOrder(first, index, terminated ? -1 : limit1);
+        unit2 = CodePointOrder(second, index, terminated ? -1 : limit2);
+    }
+    return unit1 - unit2;
+}
+
+}

core/libs/prx/libSceIcu/Compare.hpp

@@ -0,0 +1,7 @@
+#pragma once
+#include "prx/libc/include/general/VabiMacros.hpp"
+#include <cstdint>
+
+extern "C" {
+std::int32_t APS5_VABI u_strCompare_nid_postfix(const char16_t*, std::int32_t, const char16_t*, std::int32_t, std::int8_t);
+}

core/libs/prx/libSceIcu/Configuration.cpp

@@ -0,0 +1,88 @@
+#include "prx/libSceIcu/libSceIcu.hpp"
+#include "prx/libSceIcu/Status.hpp"
+#include <cstdint>
+#include <mutex>
+#include <string>
+#include <utility>
+
+namespace {
+
+struct MemoryFunctions {
+    const void* context = nullptr;
+    Icu::MemoryAllocate allocate = nullptr;
+    Icu::MemoryReallocate reallocate = nullptr;
+    Icu::MemoryFree release = nullptr;
+};
+
+std::mutex MemoryLock;
+MemoryFunctions Memory;
+std::mutex DirectoryLock;
+std::string DataDirectory;
+std::string TimeZoneDirectory;
+
+}
+
+extern "C" {
+
+void APS5_VABI u_setMutexFunctions_nid_postfix(const void*, const void*, const void*, const void*, const void*, std::int32_t* status) {
+    if (!Icu::Failure(status)) *status = Icu::UnsupportedError;
+}
+
+void APS5_VABI u_setAtomicIncDecFunctions_nid_postfix(const void*, const void*, const void*, std::int32_t* status) {
+    if (!Icu::Failure(status)) *status = Icu::UnsupportedError;
+}
+
+
+void APS5_VABI u_setMemoryFunctions_nid_postfix(const void* context, Icu::MemoryAllocate allocate, Icu::MemoryReallocate reallocate,
+                                                Icu::MemoryFree release, std::int32_t* status) {
+    if (Icu::Failure(status)) return;
+    if (!allocate || !reallocate || !release) {
+        *status = Icu::IllegalArgument;
+        return;
+    }
+    const std::lock_guard lock(MemoryLock);
+    Memory = {context, allocate, reallocate, release};
+}
+
+
+const char* APS5_VABI u_getDataDirectory_nid_postfix() {
+    const std::lock_guard lock(DirectoryLock);
+    return DataDirectory.c_str();
+}
+
+void APS5_VABI u_setDataDirectory_nid_postfix(const char* directory) {
+    std::string copy = directory ? directory : "";
+    const std::lock_guard lock(DirectoryLock);
+    DataDirectory = std::move(copy);
+}
+
+
+const char* APS5_VABI u_getTimeZoneFilesDirectory_nid_postfix(std::int32_t* status) {
+    if (Icu::Failure(status)) return "";
+    const std::lock_guard lock(DirectoryLock);
+    return TimeZoneDirectory.c_str();
+}
+
+void APS5_VABI u_setTimeZoneFilesDirectory_nid_postfix(const char* path, std::int32_t* status) {
+    if (Icu::Failure(status)) return;
+    const std::lock_guard lock(DirectoryLock);
+    TimeZoneDirectory.clear();
+    if (!path) {
+        *status = Icu::IllegalArgument;
+        return;
+    }
+    TimeZoneDirectory = path;
+}
+
+
+void APS5_VABI u_cleanup_nid_postfix() {
+    {
+        const std::lock_guard lock(MemoryLock);
+        Memory = {};
+    }
+    const std::lock_guard lock(DirectoryLock);
+    DataDirectory.clear();
+    TimeZoneDirectory.clear();
+}
+
+}

core/libs/prx/libSceIcu/Configuration.hpp

@@ -0,0 +1,21 @@
+#pragma once
+#include "prx/libc/include/general/VabiMacros.hpp"
+#include <cstddef>
+#include <cstdint>
+
+namespace Icu {
+using MemoryAllocate = void* (APS5_VABI*)(const void*, std::size_t);
+using MemoryReallocate = void* (APS5_VABI*)(const void*, void*, std::size_t);
+using MemoryFree = void (APS5_VABI*)(const void*, void*);
+} // namespace Icu
+
+extern "C" {
+void APS5_VABI u_setMutexFunctions_nid_postfix(const void*, const void*, const void*, const void*, const void*, std::int32_t*);
+void APS5_VABI u_setAtomicIncDecFunctions_nid_postfix(const void*, const void*, const void*, std::int32_t*);
+void APS5_VABI u_setMemoryFunctions_nid_postfix(const void*, Icu::MemoryAllocate, Icu::MemoryReallocate, Icu::MemoryFree, std::int32_t*);
+const char* APS5_VABI u_getDataDirectory_nid_postfix();
+void APS5_VABI u_setDataDirectory_nid_postfix(const char*);
+const char* APS5_VABI u_getTimeZoneFilesDirectory_nid_postfix(std::int32_t*);
+void APS5_VABI u_setTimeZoneFilesDirectory_nid_postfix(const char*, std::int32_t*);
+void APS5_VABI u_cleanup_nid_postfix();
+}