Unify normal/shortened, null-terminated/with-length comparisons

Change-Id: Ie154efd1e0d9b49601200ac896d5d5dd0422d504
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/130832
Tested-by: Jenkins
Reviewed-by: Mike Kaganski <mike.kaganski@collabora.com>

3 files changed, 131 insertions, 165 deletions

diff --git a/sal/rtl/string.cxx b/sal/rtl/string.cxx
index c5d535075354..9927451c8f9e 100644
--- a/sal/rtl/string.cxx
+++ b/sal/rtl/string.cxx
@@ -325,15 +325,17 @@ sal_Int32 SAL_CALL rtl_str_getLength(const char* pStr) SAL_THROW_EXTERN_C()
 
 sal_Int32 SAL_CALL rtl_str_compare(const char* pStr1, const char* pStr2) SAL_THROW_EXTERN_C()
 {
-    return rtl::str::compare(pStr1, pStr2, rtl::str::CompareNormal());
+    return rtl::str::compare(rtl::str::null_terminated(pStr1), rtl::str::null_terminated(pStr2),
+                             rtl::str::CompareNormal(), rtl::str::noShortening);
 }
 
 sal_Int32 SAL_CALL rtl_str_compare_WithLength(const char* pStr1, sal_Int32 nStr1Len,
                                               const char* pStr2, sal_Int32 nStr2Len)
     SAL_THROW_EXTERN_C()
 {
-    return rtl::str::compare_WithLengths(pStr1, nStr1Len, pStr2, nStr2Len,
-                                         rtl::str::CompareNormal());
+    return rtl::str::compare(rtl::str::with_length(pStr1, nStr1Len),
+                             rtl::str::with_length(pStr2, nStr2Len),
+                             rtl::str::CompareNormal(), rtl::str::noShortening);
 }
 
 sal_Int32 SAL_CALL rtl_str_shortenedCompare_WithLength(const char* pStr1, sal_Int32 nStr1Len,
@@ -341,8 +343,9 @@ sal_Int32 SAL_CALL rtl_str_shortenedCompare_WithLength(const char* pStr1, sal_In
                                                        sal_Int32 nShortenedLength)
     SAL_THROW_EXTERN_C()
 {
-    return rtl::str::shortenedCompare_WithLengths(pStr1, nStr1Len, pStr2, nStr2Len,
-                                                  nShortenedLength, rtl::str::CompareNormal());
+    return rtl::str::compare(rtl::str::with_length(pStr1, nStr1Len),
+                             rtl::str::with_length(pStr2, nStr2Len),
+                             rtl::str::CompareNormal(), nShortenedLength);
 }
 
 sal_Int32 SAL_CALL rtl_str_reverseCompare_WithLength(const char* pStr1, sal_Int32 nStr1Len,
@@ -356,23 +359,26 @@ sal_Int32 SAL_CALL rtl_str_reverseCompare_WithLength(const char* pStr1, sal_Int3
 sal_Int32 SAL_CALL rtl_str_compareIgnoreAsciiCase(const char* pStr1, const char* pStr2)
     SAL_THROW_EXTERN_C()
 {
-    return rtl::str::compare(pStr1, pStr2, rtl::str::CompareIgnoreAsciiCase());
+    return rtl::str::compare(rtl::str::null_terminated(pStr1), rtl::str::null_terminated(pStr2),
+                             rtl::str::CompareIgnoreAsciiCase(), rtl::str::noShortening);
 }
 
 sal_Int32 SAL_CALL rtl_str_compareIgnoreAsciiCase_WithLength(const char* pStr1, sal_Int32 nStr1Len,
                                                              const char* pStr2, sal_Int32 nStr2Len)
     SAL_THROW_EXTERN_C()
 {
-    return rtl::str::compare_WithLengths(pStr1, nStr1Len, pStr2, nStr2Len,
-                                         rtl::str::CompareIgnoreAsciiCase());
+    return rtl::str::compare(rtl::str::with_length(pStr1, nStr1Len),
+                             rtl::str::with_length(pStr2, nStr2Len),
+                             rtl::str::CompareIgnoreAsciiCase(), rtl::str::noShortening);
 }
 
 sal_Int32 SAL_CALL rtl_str_shortenedCompareIgnoreAsciiCase_WithLength(
     const char* pStr1, sal_Int32 nStr1Len, const char* pStr2, sal_Int32 nStr2Len,
     sal_Int32 nShortenedLength) SAL_THROW_EXTERN_C()
 {
-    return rtl::str::shortenedCompare_WithLengths(
-        pStr1, nStr1Len, pStr2, nStr2Len, nShortenedLength, rtl::str::CompareIgnoreAsciiCase());
+    return rtl::str::compare(rtl::str::with_length(pStr1, nStr1Len),
+                             rtl::str::with_length(pStr2, nStr2Len),
+                             rtl::str::CompareIgnoreAsciiCase(), nShortenedLength);
 }
 
 sal_Int32 SAL_CALL rtl_str_hashCode(const char* pStr) SAL_THROW_EXTERN_C()
@@ -506,33 +512,28 @@ sal_Bool SAL_CALL rtl_str_toBoolean(const char* pStr) SAL_THROW_EXTERN_C()
 
 sal_Int32 SAL_CALL rtl_str_toInt32(const char* pStr, sal_Int16 nRadix) SAL_THROW_EXTERN_C()
 {
-    assert(pStr);
-    return rtl::str::toInt<sal_Int32>(pStr, nRadix);
+    return rtl::str::toInt<sal_Int32>(rtl::str::null_terminated(pStr), nRadix);
 }
 
 sal_Int64 SAL_CALL rtl_str_toInt64(const char* pStr, sal_Int16 nRadix) SAL_THROW_EXTERN_C()
 {
-    assert(pStr);
-    return rtl::str::toInt<sal_Int64>(pStr, nRadix);
+    return rtl::str::toInt<sal_Int64>(rtl::str::null_terminated(pStr), nRadix);
 }
 
 sal_Int64 SAL_CALL rtl_str_toInt64_WithLength(const char* pStr, sal_Int16 nRadix,
                                               sal_Int32 nStrLength) SAL_THROW_EXTERN_C()
 {
-    assert(pStr || nStrLength == 0);
-    return rtl::str::toInt<sal_Int64>(std::basic_string_view(pStr, nStrLength), nRadix);
+    return rtl::str::toInt<sal_Int64>(rtl::str::with_length(pStr, nStrLength), nRadix);
 }
 
 sal_uInt32 SAL_CALL rtl_str_toUInt32(const char* pStr, sal_Int16 nRadix) SAL_THROW_EXTERN_C()
 {
-    assert(pStr);
-    return rtl::str::toInt<sal_uInt32>(pStr, nRadix);
+    return rtl::str::toInt<sal_uInt32>(rtl::str::null_terminated(pStr), nRadix);
 }
 
 sal_uInt64 SAL_CALL rtl_str_toUInt64(const char* pStr, sal_Int16 nRadix) SAL_THROW_EXTERN_C()
 {
-    assert(pStr);
-    return rtl::str::toInt<sal_uInt64>(pStr, nRadix);
+    return rtl::str::toInt<sal_uInt64>(rtl::str::null_terminated(pStr), nRadix);
 }
 
 rtl_String* rtl_string_ImplAlloc(sal_Int32 nLen) { return rtl::str::Alloc<rtl_String>(nLen); }
diff --git a/sal/rtl/strtmpl.hxx b/sal/rtl/strtmpl.hxx
index 6988865e8f11..945aaa54a6e2 100644
--- a/sal/rtl/strtmpl.hxx
+++ b/sal/rtl/strtmpl.hxx
@@ -30,6 +30,7 @@
 
 #include "strimp.hxx"
 
+#include <o3tl/safeint.hxx>
 #include <osl/diagnose.h>
 #include <sal/log.hxx>
 #include <rtl/character.hxx>
@@ -44,6 +45,35 @@ namespace rtl::str
 {
 template <typename C> auto IMPL_RTL_USTRCODE(C c) { return std::make_unsigned_t<C>(c); }
 
+// Wrappers around null-terminated/known-length strings, that allow to generalize algorithms
+// without overhead (e.g., without need to get length of null-terminated strings).
+
+template <typename C> struct null_terminated
+{
+    C* p;
+    null_terminated(C* pStr)
+        : p(pStr)
+    {
+        assert(pStr);
+    }
+    auto getIter() const { return p; }
+    static auto getEndDetector() { return [](C* iter) { return *iter == 0; }; }
+};
+
+template <typename C> struct with_length
+{
+    C* p;
+    sal_Int32 len;
+    with_length(C* pStr, sal_Int32 nLength)
+        : p(pStr)
+        , len(nLength)
+    {
+        assert(len >= 0);
+    }
+    auto getIter() const { return p; }
+    auto getEndDetector() const { return [pEnd = p + len](C* iter) { return iter == pEnd; }; }
+};
+
 template <typename C> void Copy(C* _pDest, const C* _pSrc, sal_Int32 _nCount)
 {
     // take advantage of builtin optimisations
@@ -124,16 +154,33 @@ struct CompareIgnoreAsciiCase
 
 /* ----------------------------------------------------------------------- */
 
-template <typename C1, typename C2, class Compare>
-sal_Int32 compare(const C1* pStr1, const C2* pStr2, Compare)
+struct NoShortening
+{
+    constexpr bool operator>=(int) { return true; } // for assert
+    constexpr bool operator==(int) { return false; } // for loop break check
+    constexpr void operator--() {} // for decrement in loop
+} constexpr noShortening;
+
+template <class S1, class S2, class Compare, typename Shorten_t>
+sal_Int32 compare(S1 s1, S2 s2, Compare, Shorten_t shortenedLength)
 {
-    assert(pStr1);
-    assert(pStr2);
+    static_assert(std::is_same_v<Shorten_t, NoShortening> || std::is_same_v<Shorten_t, sal_Int32>);
+    assert(shortenedLength >= 0);
+    auto pStr1 = s1.getIter();
+    const auto atEnd1 = s1.getEndDetector();
+    auto pStr2 = s2.getIter();
+    const auto atEnd2 = s2.getEndDetector();
     for (;;)
     {
-        const sal_Int32 nRet = Compare::compare(*pStr1, *pStr2);
-        if (!(nRet == 0 && *pStr2))
+        if (shortenedLength == 0)
+            return 0;
+        if (atEnd2(pStr2))
+            return atEnd1(pStr1) ? 0 : 1;
+        if (atEnd1(pStr1))
+            return -1;
+        if (const sal_Int32 nRet = Compare::compare(*pStr1, *pStr2))
             return nRet;
+        --shortenedLength;
         ++pStr1;
         ++pStr2;
     }
@@ -141,115 +188,28 @@ sal_Int32 compare(const C1* pStr1, const C2* pStr2, Compare)
 
 // take advantage of builtin optimisations
 template <typename C, std::enable_if_t<sizeof(C) == sizeof(wchar_t), int> = 0>
-sal_Int32 compare(const C* pStr1, const C* pStr2, CompareNormal)
-{
-    assert(pStr1);
-    assert(pStr2);
-    return wcscmp(reinterpret_cast<wchar_t const*>(pStr1), reinterpret_cast<wchar_t const*>(pStr2));
-}
-inline sal_Int32 compare(const char* pStr1, const char* pStr2, CompareNormal)
+sal_Int32 compare(null_terminated<C> s1, null_terminated<C> s2, CompareNormal, NoShortening)
 {
-    assert(pStr1);
-    assert(pStr2);
-    return strcmp(pStr1, pStr2);
+    return wcscmp(reinterpret_cast<wchar_t const*>(s1.p), reinterpret_cast<wchar_t const*>(s2.p));
 }
-
-/* ----------------------------------------------------------------------- */
-
-template <typename C1, typename C2, class Compare>
-sal_Int32 compare_WithLength(const C1* pStr1, sal_Int32 nStr1Len, const C2* pStr2, Compare)
+template <typename C, std::enable_if_t<sizeof(C) == sizeof(char), int> = 0>
+sal_Int32 compare(null_terminated<C> s1, null_terminated<C> s2, CompareNormal, NoShortening)
 {
-    assert(pStr1 || nStr1Len == 0);
-    assert(nStr1Len >= 0);
-    assert(pStr2);
-    for (;;)
-    {
-        if (*pStr2 == '\0')
-            return nStr1Len;
-        if (nStr1Len == 0)
-            return -1;
-        if (const sal_Int32 nRet = Compare::compare(*pStr1, *pStr2))
-            return nRet;
-        pStr1++;
-        pStr2++;
-        nStr1Len--;
-    }
+    return strcmp(reinterpret_cast<char const*>(s1.p), reinterpret_cast<char const*>(s2.p));
 }
-
-/* ----------------------------------------------------------------------- */
-
-template <typename C1, typename C2, class Compare>
-sal_Int32 compare_WithLengths(const C1* pStr1, sal_Int32 nStr1Len,
-                              const C2* pStr2, sal_Int32 nStr2Len, Compare)
-{
-    assert(pStr1 || nStr1Len == 0);
-    assert(nStr1Len >= 0);
-    assert(pStr2 || nStr2Len == 0);
-    assert(nStr2Len >= 0);
-    // TODO: use std::lexicographical_compare_three_way when C++20 is available
-    const C1* pStr1End = pStr1 + nStr1Len;
-    const C2* pStr2End = pStr2 + nStr2Len;
-    while ((pStr1 < pStr1End) && (pStr2 < pStr2End))
-    {
-        if (const sal_Int32 nRet = Compare::compare(*pStr1, *pStr2))
-            return nRet;
-        pStr1++;
-        pStr2++;
-    }
-
-    return nStr1Len - nStr2Len;
-}
-
 template <typename C>
-sal_Int32 compare_WithLengths(const C* pStr1, sal_Int32 nStr1Len,
-                              const C* pStr2, sal_Int32 nStr2Len, CompareNormal)
+sal_Int32 compare(with_length<C> s1, with_length<C> s2, CompareNormal, NoShortening)
 {
-    assert(pStr1 || nStr1Len == 0);
-    assert(nStr1Len >= 0);
-    assert(pStr2 || nStr2Len == 0);
-    assert(nStr2Len >= 0);
-    // take advantage of builtin optimisations
-    std::basic_string_view<C> aView1(pStr1, nStr1Len);
-    std::basic_string_view<C> aView2(pStr2, nStr2Len);
-    return aView1.compare(aView2);
+    std::basic_string_view sv1(s1.p, s1.len);
+    return sv1.compare(std::basic_string_view(s2.p, s2.len));
 }
-
-/* ----------------------------------------------------------------------- */
-
 template <typename C1, typename C2, class Compare>
-sal_Int32 shortenedCompare_WithLength(const C1* pStr1, sal_Int32 nStr1Len, const C2* pStr2,
-                                      sal_Int32 nShortenedLength, Compare)
+sal_Int32 compare(with_length<C1> s1, with_length<C2> s2, Compare cf, sal_Int32 nShortenedLength)
 {
-    assert(pStr1);
-    assert(nStr1Len >= 0);
-    assert(pStr2);
     assert(nShortenedLength >= 0);
-    const C1* pStr1End = pStr1 + nStr1Len;
-    for (;;)
-    {
-        if (nShortenedLength == 0)
-            return 0;
-        if (*pStr2 == '\0')
-            return pStr1End - pStr1;
-        if (pStr1 == pStr1End)
-            return -1; // first is a substring of the second string => less (negative value)
-        if (const sal_Int32 nRet = Compare::compare(*pStr1, *pStr2))
-            return nRet;
-        nShortenedLength--;
-        pStr1++;
-        pStr2++;
-    }
-}
-
-/* ----------------------------------------------------------------------- */
-
-template <typename C1, typename C2, class Compare>
-sal_Int32 shortenedCompare_WithLengths(const C1* pStr1, sal_Int32 nStr1Len,
-                                       const C2* pStr2, sal_Int32 nStr2Len,
-                                       sal_Int32 nShortenedLength, Compare cf)
-{
-    return compare_WithLengths(pStr1, std::min(nStr1Len, nShortenedLength),
-                               pStr2, std::min(nStr2Len, nShortenedLength), cf);
+    s1.len = std::min(s1.len, nShortenedLength);
+    s2.len = std::min(s2.len, nShortenedLength);
+    return compare(s1, s2, cf, noShortening);
 }
 
 /* ----------------------------------------------------------------------- */
@@ -786,12 +746,6 @@ template <typename T> std::pair<T, sal_Int16> DivMod(sal_Int16 nRadix, [[maybe_u
     return { std::numeric_limits<T>::max() / nRadix, std::numeric_limits<T>::max() % nRadix };
 }
 
-template <class SV> auto getIter(const SV& sv) { return sv.begin(); }
-template <typename C> auto getIter(const C* pStr) { return pStr; }
-
-template <class SV> auto good(typename SV::iterator iter, const SV& sv) { return iter != sv.end(); }
-template <typename C> auto good(const C* pStr, const C*) { return *pStr != 0; }
-
 template <typename T, class S> T toInt(S str, sal_Int16 nRadix)
 {
     assert( nRadix >= RTL_STR_MIN_RADIX && nRadix <= RTL_STR_MAX_RADIX );
@@ -799,12 +753,13 @@ template <typename T, class S> T toInt(S str, sal_Int16 nRadix)
     if ( (nRadix < RTL_STR_MIN_RADIX) || (nRadix > RTL_STR_MAX_RADIX) )
         nRadix = 10;
 
-    auto pStr = getIter(str);
+    auto pStr = str.getIter();
+    const auto atEnd = str.getEndDetector();
 
     /* Skip whitespaces */
-    while (good(pStr, str) && rtl_ImplIsWhitespace(IMPL_RTL_USTRCODE(*pStr)))
+    while (!atEnd(pStr) && rtl_ImplIsWhitespace(IMPL_RTL_USTRCODE(*pStr)))
         pStr++;
-    if (!good(pStr, str))
+    if (atEnd(pStr))
         return 0;
 
     const bool bNeg = HandleSignChar<T>(pStr);
@@ -812,7 +767,7 @@ template <typename T, class S> T toInt(S str, sal_Int16 nRadix)
     assert(nDiv > 0);
 
     std::make_unsigned_t<T> n = 0;
-    while (good(pStr, str))
+    while (!atEnd(pStr))
     {
         sal_Int16 nDigit = rtl_ImplGetDigit(IMPL_RTL_USTRCODE(*pStr), nRadix);
         if ( nDigit < 0 )
diff --git a/sal/rtl/ustring.cxx b/sal/rtl/ustring.cxx
index 4451866e4588..99f4575b1240 100644
--- a/sal/rtl/ustring.cxx
+++ b/sal/rtl/ustring.cxx
@@ -164,7 +164,8 @@ sal_Int32 SAL_CALL rtl_ustr_ascii_compare( const sal_Unicode* pStr1,
                                            const char* pStr2 )
     SAL_THROW_EXTERN_C()
 {
-    return rtl::str::compare(pStr1, pStr2, rtl::str::CompareNormal());
+    return rtl::str::compare(rtl::str::null_terminated(pStr1), rtl::str::null_terminated(pStr2),
+                             rtl::str::CompareNormal(), rtl::str::noShortening);
 }
 
 /* ----------------------------------------------------------------------- */
@@ -174,7 +175,9 @@ sal_Int32 SAL_CALL rtl_ustr_ascii_compare_WithLength( const sal_Unicode* pStr1,
                                                       const char* pStr2 )
     SAL_THROW_EXTERN_C()
 {
-    return rtl::str::compare_WithLength(pStr1, nStr1Len, pStr2, rtl::str::CompareNormal());
+    return rtl::str::compare(rtl::str::with_length(pStr1, nStr1Len),
+                             rtl::str::null_terminated(pStr2),
+                             rtl::str::CompareNormal(), rtl::str::noShortening);
 }
 
 /* ----------------------------------------------------------------------- */
@@ -185,8 +188,9 @@ sal_Int32 SAL_CALL rtl_ustr_ascii_shortenedCompare_WithLength( const sal_Unicode
                                                                sal_Int32 nShortenedLength )
     SAL_THROW_EXTERN_C()
 {
-    return rtl::str::shortenedCompare_WithLength(pStr1, nStr1Len, pStr2, nShortenedLength,
-                                                 rtl::str::CompareNormal());
+    return rtl::str::compare(rtl::str::with_length(pStr1, nStr1Len),
+                             rtl::str::null_terminated(pStr2),
+                             rtl::str::CompareNormal(), nShortenedLength);
 }
 
 /* ----------------------------------------------------------------------- */
@@ -230,7 +234,8 @@ sal_Int32 SAL_CALL rtl_ustr_ascii_compareIgnoreAsciiCase( const sal_Unicode* pSt
                                                           const char* pStr2 )
     SAL_THROW_EXTERN_C()
 {
-    return rtl::str::compare(pStr1, pStr2, rtl::str::CompareIgnoreAsciiCase());
+    return rtl::str::compare(rtl::str::null_terminated(pStr1), rtl::str::null_terminated(pStr2),
+                             rtl::str::CompareIgnoreAsciiCase(), rtl::str::noShortening);
 }
 
 /* ----------------------------------------------------------------------- */
@@ -240,15 +245,18 @@ sal_Int32 SAL_CALL rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( const sal_U
                                                                      const char* pStr2 )
     SAL_THROW_EXTERN_C()
 {
-    return rtl::str::compare_WithLength(pStr1, nStr1Len, pStr2, rtl::str::CompareIgnoreAsciiCase());
+    return rtl::str::compare(rtl::str::with_length(pStr1, nStr1Len),
+                             rtl::str::null_terminated(pStr2),
+                             rtl::str::CompareIgnoreAsciiCase(), rtl::str::noShortening);
 }
 
 sal_Int32 rtl_ustr_ascii_compareIgnoreAsciiCase_WithLengths(
     sal_Unicode const * first, sal_Int32 firstLen,
     char const * second, sal_Int32 secondLen) SAL_THROW_EXTERN_C()
 {
-    return rtl::str::compare_WithLengths(first, firstLen, second, secondLen,
-                                         rtl::str::CompareIgnoreAsciiCase());
+    return rtl::str::compare(rtl::str::with_length(first, firstLen),
+                             rtl::str::with_length(second, secondLen),
+                             rtl::str::CompareIgnoreAsciiCase(), rtl::str::noShortening);
 }
 
 /* ----------------------------------------------------------------------- */
@@ -259,8 +267,9 @@ sal_Int32 SAL_CALL rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( co
                                                                               sal_Int32 nShortenedLength )
     SAL_THROW_EXTERN_C()
 {
-    return rtl::str::shortenedCompare_WithLength(pStr1, nStr1Len, pStr2, nShortenedLength,
-                                                 rtl::str::CompareIgnoreAsciiCase());
+    return rtl::str::compare(rtl::str::with_length(pStr1, nStr1Len),
+                             rtl::str::null_terminated(pStr2),
+                             rtl::str::CompareIgnoreAsciiCase(), nShortenedLength);
 }
 
 /* ----------------------------------------------------------------------- */
@@ -981,23 +990,26 @@ sal_Int32 SAL_CALL rtl_ustr_getLength(const sal_Unicode* pStr) SAL_THROW_EXTERN_
 sal_Int32 SAL_CALL rtl_ustr_compare(const sal_Unicode* pStr1, const sal_Unicode* pStr2)
     SAL_THROW_EXTERN_C()
 {
-    return rtl::str::compare(pStr1, pStr2, rtl::str::CompareNormal());
+    return rtl::str::compare(rtl::str::null_terminated(pStr1), rtl::str::null_terminated(pStr2),
+                             rtl::str::CompareNormal(), rtl::str::noShortening);
 }
 
 sal_Int32 SAL_CALL rtl_ustr_compare_WithLength(const sal_Unicode* pStr1, sal_Int32 nStr1Len,
                                                const sal_Unicode* pStr2, sal_Int32 nStr2Len)
     SAL_THROW_EXTERN_C()
 {
-    return rtl::str::compare_WithLengths(pStr1, nStr1Len, pStr2, nStr2Len,
-                                         rtl::str::CompareNormal());
+    return rtl::str::compare(rtl::str::with_length(pStr1, nStr1Len),
+                             rtl::str::with_length(pStr2, nStr2Len), rtl::str::CompareNormal(),
+                             rtl::str::noShortening);
 }
 
 sal_Int32 SAL_CALL rtl_ustr_shortenedCompare_WithLength(
     const sal_Unicode* pStr1, sal_Int32 nStr1Len, const sal_Unicode* pStr2, sal_Int32 nStr2Len,
     sal_Int32 nShortenedLength) SAL_THROW_EXTERN_C()
 {
-    return rtl::str::shortenedCompare_WithLengths(pStr1, nStr1Len, pStr2, nStr2Len,
-                                                  nShortenedLength, rtl::str::CompareNormal());
+    return rtl::str::compare(rtl::str::with_length(pStr1, nStr1Len),
+                             rtl::str::with_length(pStr2, nStr2Len), rtl::str::CompareNormal(),
+                             nShortenedLength);
 }
 
 sal_Int32 SAL_CALL rtl_ustr_reverseCompare_WithLength(const sal_Unicode* pStr1, sal_Int32 nStr1Len,
@@ -1011,7 +1023,8 @@ sal_Int32 SAL_CALL rtl_ustr_reverseCompare_WithLength(const sal_Unicode* pStr1,
 sal_Int32 SAL_CALL rtl_ustr_compareIgnoreAsciiCase(const sal_Unicode* pStr1,
                                                    const sal_Unicode* pStr2) SAL_THROW_EXTERN_C()
 {
-    return rtl::str::compare(pStr1, pStr2, rtl::str::CompareIgnoreAsciiCase());
+    return rtl::str::compare(rtl::str::null_terminated(pStr1), rtl::str::null_terminated(pStr2),
+                             rtl::str::CompareIgnoreAsciiCase(), rtl::str::noShortening);
 }
 
 sal_Int32 SAL_CALL rtl_ustr_compareIgnoreAsciiCase_WithLength(const sal_Unicode* pStr1,
@@ -1020,16 +1033,18 @@ sal_Int32 SAL_CALL rtl_ustr_compareIgnoreAsciiCase_WithLength(const sal_Unicode*
                                                               sal_Int32 nStr2Len)
     SAL_THROW_EXTERN_C()
 {
-    return rtl::str::compare_WithLengths(pStr1, nStr1Len, pStr2, nStr2Len,
-                                         rtl::str::CompareIgnoreAsciiCase());
+    return rtl::str::compare(rtl::str::with_length(pStr1, nStr1Len),
+                             rtl::str::with_length(pStr2, nStr2Len),
+                             rtl::str::CompareIgnoreAsciiCase(), rtl::str::noShortening);
 }
 
 sal_Int32 SAL_CALL rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength(
     const sal_Unicode* pStr1, sal_Int32 nStr1Len, const sal_Unicode* pStr2, sal_Int32 nStr2Len,
     sal_Int32 nShortenedLength) SAL_THROW_EXTERN_C()
 {
-    return rtl::str::shortenedCompare_WithLengths(
-        pStr1, nStr1Len, pStr2, nStr2Len, nShortenedLength, rtl::str::CompareIgnoreAsciiCase());
+    return rtl::str::compare(rtl::str::with_length(pStr1, nStr1Len),
+                             rtl::str::with_length(pStr2, nStr2Len),
+                             rtl::str::CompareIgnoreAsciiCase(), nShortenedLength);
 }
 
 sal_Int32 SAL_CALL rtl_ustr_hashCode(const sal_Unicode* pStr) SAL_THROW_EXTERN_C()
@@ -1171,35 +1186,30 @@ sal_Bool SAL_CALL rtl_ustr_toBoolean(const sal_Unicode* pStr) SAL_THROW_EXTERN_C
 
 sal_Int32 SAL_CALL rtl_ustr_toInt32(const sal_Unicode* pStr, sal_Int16 nRadix) SAL_THROW_EXTERN_C()
 {
-    assert(pStr);
-    return rtl::str::toInt<sal_Int32>(pStr, nRadix);
+    return rtl::str::toInt<sal_Int32>(rtl::str::null_terminated(pStr), nRadix);
 }
 
 sal_Int64 SAL_CALL rtl_ustr_toInt64(const sal_Unicode* pStr, sal_Int16 nRadix) SAL_THROW_EXTERN_C()
 {
-    assert(pStr);
-    return rtl::str::toInt<sal_Int64>(pStr, nRadix);
+    return rtl::str::toInt<sal_Int64>(rtl::str::null_terminated(pStr), nRadix);
 }
 
 sal_Int64 SAL_CALL rtl_ustr_toInt64_WithLength(const sal_Unicode* pStr, sal_Int16 nRadix,
                                                sal_Int32 nStrLength) SAL_THROW_EXTERN_C()
 {
-    assert(pStr || nStrLength == 0);
-    return rtl::str::toInt<sal_Int64>(std::basic_string_view(pStr, nStrLength), nRadix);
+    return rtl::str::toInt<sal_Int64>(rtl::str::with_length(pStr, nStrLength), nRadix);
 }
 
 sal_uInt32 SAL_CALL rtl_ustr_toUInt32(const sal_Unicode* pStr, sal_Int16 nRadix)
     SAL_THROW_EXTERN_C()
 {
-    assert(pStr);
-    return rtl::str::toInt<sal_uInt32>(pStr, nRadix);
+    return rtl::str::toInt<sal_uInt32>(rtl::str::null_terminated(pStr), nRadix);
 }
 
 sal_uInt64 SAL_CALL rtl_ustr_toUInt64(const sal_Unicode* pStr, sal_Int16 nRadix)
     SAL_THROW_EXTERN_C()
 {
-    assert(pStr);
-    return rtl::str::toInt<sal_uInt64>(pStr, nRadix);
+    return rtl::str::toInt<sal_uInt64>(rtl::str::null_terminated(pStr), nRadix);
 }
 
 rtl_uString* rtl_uString_ImplAlloc(sal_Int32 nLen)