Deduplicate more comparison functions

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

3 files changed, 154 insertions, 232 deletions

diff --git a/sal/rtl/string.cxx b/sal/rtl/string.cxx
index 2b118a57aada..4b08b5e2c39f 100644
--- a/sal/rtl/string.cxx
+++ b/sal/rtl/string.cxx
@@ -337,14 +337,15 @@ 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);
+    return rtl::str::compare(pStr1, pStr2, rtl::str::CompareNormal());
 }
 
 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_WithLength(pStr1, nStr1Len, pStr2, nStr2Len);
+    return rtl::str::compare_WithLengths(pStr1, nStr1Len, pStr2, nStr2Len,
+                                         rtl::str::CompareNormal());
 }
 
 sal_Int32 SAL_CALL rtl_str_shortenedCompare_WithLength(const char* pStr1, sal_Int32 nStr1Len,
@@ -352,35 +353,38 @@ sal_Int32 SAL_CALL rtl_str_shortenedCompare_WithLength(const char* pStr1, sal_In
                                                        sal_Int32 nShortenedLength)
     SAL_THROW_EXTERN_C()
 {
-    return rtl::str::shortenedCompare_WithLength(pStr1, nStr1Len, pStr2, nStr2Len, nShortenedLength);
+    return rtl::str::shortenedCompare_WithLengths(pStr1, nStr1Len, pStr2, nStr2Len,
+                                                  nShortenedLength, rtl::str::CompareNormal());
 }
 
 sal_Int32 SAL_CALL rtl_str_reverseCompare_WithLength(const char* pStr1, sal_Int32 nStr1Len,
                                                      const char* pStr2, sal_Int32 nStr2Len)
     SAL_THROW_EXTERN_C()
 {
-    return rtl::str::reverseCompare_WithLength(pStr1, nStr1Len, pStr2, nStr2Len);
+    return rtl::str::reverseCompare_WithLengths(pStr1, nStr1Len, pStr2, nStr2Len,
+                                                rtl::str::CompareNormal());
 }
 
 sal_Int32 SAL_CALL rtl_str_compareIgnoreAsciiCase(const char* pStr1, const char* pStr2)
     SAL_THROW_EXTERN_C()
 {
-    return rtl::str::compareIgnoreAsciiCase(pStr1, pStr2);
+    return rtl::str::compare(pStr1, pStr2, rtl::str::CompareIgnoreAsciiCase());
 }
 
 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::compareIgnoreAsciiCase_WithLength(pStr1, nStr1Len, pStr2, nStr2Len);
+    return rtl::str::compare_WithLengths(pStr1, nStr1Len, pStr2, nStr2Len,
+                                         rtl::str::CompareIgnoreAsciiCase());
 }
 
 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::shortenedCompareIgnoreAsciiCase_WithLength(pStr1, nStr1Len, pStr2, nStr2Len,
-                                                              nShortenedLength);
+    return rtl::str::shortenedCompare_WithLengths(
+        pStr1, nStr1Len, pStr2, nStr2Len, nShortenedLength, rtl::str::CompareIgnoreAsciiCase());
 }
 
 sal_Int32 SAL_CALL rtl_str_hashCode(const char* pStr) SAL_THROW_EXTERN_C()
diff --git a/sal/rtl/strtmpl.hxx b/sal/rtl/strtmpl.hxx
index 256c0cc99dd0..c5cdc23fbc84 100644
--- a/sal/rtl/strtmpl.hxx
+++ b/sal/rtl/strtmpl.hxx
@@ -98,143 +98,173 @@ template <typename C1, typename C2> void warnIfOneIsCharAndNotAscii(C1 c1, C2 c2
     }
 }
 
-/* ----------------------------------------------------------------------- */
-
-template <typename C1, typename C2> sal_Int32 compare(const C1* pStr1, const C2* pStr2)
+struct CompareNormal
 {
-    assert(pStr1);
-    assert(pStr2);
-    if constexpr (sizeof(C1) == sizeof(char) && sizeof(C2) == sizeof(char))
+    template <typename C1, typename C2> static sal_Int32 compare(C1 c1, C2 c2)
     {
-        // take advantage of builtin optimisations
-        return strcmp( pStr1, pStr2);
+        warnIfOneIsCharAndNotAscii(c1, c2);
+        return static_cast<sal_Int32>(IMPL_RTL_USTRCODE(c1))
+               - static_cast<sal_Int32>(IMPL_RTL_USTRCODE(c2));
     }
-    else if constexpr (sizeof(C1) == sizeof(wchar_t) && sizeof(C2) == sizeof(wchar_t))
+};
+
+struct CompareIgnoreAsciiCase
+{
+    template <typename C1, typename C2> static sal_Int32 compare(C1 c1, C2 c2)
     {
-        // take advantage of builtin optimisations
-        return wcscmp(reinterpret_cast<wchar_t const *>(pStr1), reinterpret_cast<wchar_t const *>(pStr2));
+        warnIfOneIsCharAndNotAscii(c1, c2);
+        return rtl::compareIgnoreAsciiCase(IMPL_RTL_USTRCODE(c1), IMPL_RTL_USTRCODE(c2));
     }
-    else // including C1 != C2
-    {
-        sal_Int32 nRet;
-        for (;;)
-        {
-            warnIfOneIsCharAndNotAscii(*pStr1, *pStr2);
-
-            nRet = static_cast<sal_Int32>(IMPL_RTL_USTRCODE(*pStr1)) -
-                   static_cast<sal_Int32>(IMPL_RTL_USTRCODE(*pStr2));
-            if (!(nRet == 0 && *pStr2 ))
-                break;
-            pStr1++;
-            pStr2++;
-        }
+};
 
-        return nRet;
+/* ----------------------------------------------------------------------- */
+
+template <typename C1, typename C2, class Compare>
+sal_Int32 compare(const C1* pStr1, const C2* pStr2, Compare)
+{
+    assert(pStr1);
+    assert(pStr2);
+    for (;;)
+    {
+        const sal_Int32 nRet = Compare::compare(*pStr1, *pStr2);
+        if (!(nRet == 0 && *pStr2))
+            return nRet;
+        ++pStr1;
+        ++pStr2;
     }
 }
 
-/* ----------------------------------------------------------------------- */
-
-template <typename IMPL_RTL_STRCODE>
-sal_Int32 compare_WithLength                             ( const IMPL_RTL_STRCODE* pStr1,
-                                                           sal_Int32 nStr1Len,
-                                                           const IMPL_RTL_STRCODE* pStr2,
-                                                           sal_Int32 nStr2Len )
+// 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(nStr1Len >= 0);
-    assert(nStr2Len >= 0);
-    // take advantage of builtin optimisations
-    std::basic_string_view<IMPL_RTL_STRCODE> aView1(pStr1, nStr1Len);
-    std::basic_string_view<IMPL_RTL_STRCODE> aView2(pStr2, nStr2Len);
-    return aView1.compare(aView2);
+    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)
+{
+    assert(pStr1);
+    assert(pStr2);
+    return strcmp(pStr1, pStr2);
 }
 
 /* ----------------------------------------------------------------------- */
 
-template <typename IMPL_RTL_STRCODE>
-sal_Int32 shortenedCompare_WithLength                             ( const IMPL_RTL_STRCODE* pStr1,
-                                                                    sal_Int32 nStr1Len,
-                                                                    const IMPL_RTL_STRCODE* pStr2,
-                                                                    sal_Int32 nStr2Len,
-                                                                    sal_Int32 nShortenedLength )
+template <typename C1, typename C2, class Compare>
+sal_Int32 compare_WithLength(const C1* pStr1, sal_Int32 nStr1Len, const C2* pStr2, Compare)
 {
-    return compare_WithLength(pStr1, std::min(nStr1Len, nShortenedLength),
-                              pStr2, std::min(nStr2Len, nShortenedLength));
+    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--;
+    }
 }
 
 /* ----------------------------------------------------------------------- */
 
-template <typename C1, typename C2>
-sal_Int32 reverseCompare_WithLength(const C1* pStr1, sal_Int32 nStr1Len,
-                                    const C2* pStr2, sal_Int32 nStr2Len)
+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);
-    const C1* pStr1Run = pStr1+nStr1Len;
-    const C2* pStr2Run = pStr2+nStr2Len;
-    sal_Int32               nRet;
-    while ( (pStr1 < pStr1Run) && (pStr2 < pStr2Run) )
+    // 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))
     {
-        warnIfOneIsCharAndNotAscii(*pStr1, *pStr2);
-
-        pStr1Run--;
-        pStr2Run--;
-        nRet = static_cast<sal_Int32>(IMPL_RTL_USTRCODE( *pStr1Run ))-
-               static_cast<sal_Int32>(IMPL_RTL_USTRCODE( *pStr2Run ));
-        if ( nRet )
+        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)
+{
+    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);
+}
+
 /* ----------------------------------------------------------------------- */
 
-template <typename C1, typename C2>
-sal_Int32 compareIgnoreAsciiCase(const C1* pStr1, const C2* pStr2)
+template <typename C1, typename C2, class Compare>
+sal_Int32 shortenedCompare_WithLength(const C1* pStr1, sal_Int32 nStr1Len, const C2* pStr2,
+                                      sal_Int32 nShortenedLength, Compare)
 {
     assert(pStr1);
+    assert(nStr1Len >= 0);
     assert(pStr2);
-    sal_uInt32 c1;
-    do
+    assert(nShortenedLength >= 0);
+    const C1* pStr1End = pStr1 + nStr1Len;
+    for (;;)
     {
-        warnIfOneIsCharAndNotAscii(*pStr1, *pStr2);
-
-        c1 = IMPL_RTL_USTRCODE(*pStr1);
-        sal_Int32 nRet = rtl::compareIgnoreAsciiCase(
-            c1, IMPL_RTL_USTRCODE(*pStr2));
-        if ( nRet != 0 )
+        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++;
     }
-    while (c1);
+}
 
-    return 0;
+/* ----------------------------------------------------------------------- */
+
+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);
 }
 
 /* ----------------------------------------------------------------------- */
 
-template <typename C1, typename C2>
-sal_Int32 compareIgnoreAsciiCase_WithLength(const C1* pStr1, sal_Int32 nStr1Len,
-                                            const C2* pStr2, sal_Int32 nStr2Len)
+template <typename C1, typename C2, class Compare>
+sal_Int32 reverseCompare_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);
-    const C1* pStr1End = pStr1 + nStr1Len;
-    const C2* pStr2End = pStr2 + nStr2Len;
-    while ( (pStr1 < pStr1End) && (pStr2 < pStr2End) )
+    const C1* pStr1Run = pStr1+nStr1Len;
+    const C2* pStr2Run = pStr2+nStr2Len;
+    while ((pStr1 < pStr1Run) && (pStr2 < pStr2Run))
     {
-        warnIfOneIsCharAndNotAscii(*pStr1, *pStr2);
-
-        sal_Int32 nRet = rtl::compareIgnoreAsciiCase(
-            IMPL_RTL_USTRCODE(*pStr1), IMPL_RTL_USTRCODE(*pStr2));
-        if ( nRet != 0 )
+        pStr1Run--;
+        pStr2Run--;
+        if (const sal_Int32 nRet = Compare::compare(*pStr1Run, *pStr2Run))
             return nRet;
-
-        pStr1++;
-        pStr2++;
     }
 
     return nStr1Len - nStr2Len;
@@ -243,19 +273,6 @@ sal_Int32 compareIgnoreAsciiCase_WithLength(const C1* pStr1, sal_Int32 nStr1Len,
 /* ----------------------------------------------------------------------- */
 
 template <typename IMPL_RTL_STRCODE>
-sal_Int32 shortenedCompareIgnoreAsciiCase_WithLength                             ( const IMPL_RTL_STRCODE* pStr1,
-                                                                                   sal_Int32 nStr1Len,
-                                                                                   const IMPL_RTL_STRCODE* pStr2,
-                                                                                   sal_Int32 nStr2Len,
-                                                                                   sal_Int32 nShortenedLength )
-{
-    return compareIgnoreAsciiCase_WithLength(pStr1, std::min(nStr1Len, nShortenedLength),
-                                             pStr2, std::min(nStr2Len, nShortenedLength));
-}
-
-/* ----------------------------------------------------------------------- */
-
-template <typename IMPL_RTL_STRCODE>
 sal_Int32 hashCode_WithLength(const IMPL_RTL_STRCODE*, sal_Int32);
 
 template <typename IMPL_RTL_STRCODE> sal_Int32 hashCode( const IMPL_RTL_STRCODE* pStr )
diff --git a/sal/rtl/ustring.cxx b/sal/rtl/ustring.cxx
index b289ae2a3f21..f2503f5c2d06 100644
--- a/sal/rtl/ustring.cxx
+++ b/sal/rtl/ustring.cxx
@@ -175,7 +175,7 @@ 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);
+    return rtl::str::compare(pStr1, pStr2, rtl::str::CompareNormal());
 }
 
 /* ----------------------------------------------------------------------- */
@@ -185,24 +185,7 @@ sal_Int32 SAL_CALL rtl_ustr_ascii_compare_WithLength( const sal_Unicode* pStr1,
                                                       const char* pStr2 )
     SAL_THROW_EXTERN_C()
 {
-    assert(pStr1);
-    assert(nStr1Len >= 0);
-    assert(pStr2);
-    sal_Int32 nRet = 0;
-    for (;;)
-    {
-        nRet = (nStr1Len ? static_cast<sal_Int32>(*pStr1) : 0) -
-               static_cast<sal_Int32>(static_cast<unsigned char>(*pStr2));
-        if (!(nRet == 0 && nStr1Len && *pStr2 ))
-            break;
-        SAL_WARN_IF( !rtl::isAscii(static_cast<unsigned char>(*pStr2)), "rtl.string",
-                    "rtl_ustr_ascii_compare_WithLength - Found char > 127" );
-        pStr1++;
-        pStr2++;
-        nStr1Len--;
-    }
-
-    return nRet;
+    return rtl::str::compare_WithLength(pStr1, nStr1Len, pStr2, rtl::str::CompareNormal());
 }
 
 /* ----------------------------------------------------------------------- */
@@ -213,42 +196,8 @@ sal_Int32 SAL_CALL rtl_ustr_ascii_shortenedCompare_WithLength( const sal_Unicode
                                                                sal_Int32 nShortenedLength )
     SAL_THROW_EXTERN_C()
 {
-    assert(nStr1Len >= 0);
-    assert(nShortenedLength >= 0);
-    const sal_Unicode*  pStr1End = pStr1 + nStr1Len;
-    sal_Int32           nRet;
-    while ( (nShortenedLength > 0) &&
-            (pStr1 < pStr1End) && *pStr2 )
-    {
-        SAL_WARN_IF( !rtl::isAscii(static_cast<unsigned char>(*pStr2)), "rtl.string",
-                    "rtl_ustr_ascii_shortenedCompare_WithLength - Found char > 127" );
-
-        nRet = static_cast<sal_Int32>(*pStr1)-
-               static_cast<sal_Int32>(static_cast<unsigned char>(*pStr2));
-        if ( nRet != 0 )
-            return nRet;
-
-        nShortenedLength--;
-        pStr1++;
-        pStr2++;
-    }
-
-    if ( nShortenedLength <= 0 )
-        return 0;
-
-    if ( *pStr2 )
-    {
-        OSL_ENSURE( pStr1 == pStr1End, "pStr1 == pStr1End failed" );
-        // first is a substring of the second string => less (negative value)
-        nRet = -1;
-    }
-    else
-    {
-        // greater or equal
-        nRet = pStr1End - pStr1;
-    }
-
-    return nRet;
+    return rtl::str::shortenedCompare_WithLength(pStr1, nStr1Len, pStr2, nShortenedLength,
+                                                 rtl::str::CompareNormal());
 }
 
 /* ----------------------------------------------------------------------- */
@@ -259,7 +208,8 @@ sal_Int32 SAL_CALL rtl_ustr_asciil_reverseCompare_WithLength( const sal_Unicode*
                                                               sal_Int32 nStr2Len )
     SAL_THROW_EXTERN_C()
 {
-    return rtl::str::reverseCompare_WithLength(pStr1, nStr1Len, pStr2, nStr2Len);
+    return rtl::str::reverseCompare_WithLengths(pStr1, nStr1Len, pStr2, nStr2Len,
+                                                rtl::str::CompareNormal());
 }
 
 /* ----------------------------------------------------------------------- */
@@ -291,7 +241,7 @@ sal_Int32 SAL_CALL rtl_ustr_ascii_compareIgnoreAsciiCase( const sal_Unicode* pSt
                                                           const char* pStr2 )
     SAL_THROW_EXTERN_C()
 {
-    return rtl::str::compareIgnoreAsciiCase(pStr1, pStr2);
+    return rtl::str::compare(pStr1, pStr2, rtl::str::CompareIgnoreAsciiCase());
 }
 
 /* ----------------------------------------------------------------------- */
@@ -301,35 +251,15 @@ sal_Int32 SAL_CALL rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( const sal_U
                                                                      const char* pStr2 )
     SAL_THROW_EXTERN_C()
 {
-    assert(nStr1Len >= 0);
-    assert(pStr2);
-    unsigned char c2;
-    do
-    {
-        SAL_WARN_IF( !rtl::isAscii(static_cast<unsigned char>(*pStr2)), "rtl.string",
-                    "rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength - Found char > 127" );
-        if ( !nStr1Len )
-            return *pStr2 == '\0' ? 0 : -1;
-
-        c2 = static_cast<unsigned char>(*pStr2);
-        sal_Int32 nRet = rtl::compareIgnoreAsciiCase(*pStr1, c2);
-        if ( nRet != 0 )
-            return nRet;
-
-        pStr1++;
-        pStr2++;
-        nStr1Len--;
-    }
-    while( c2 );
-
-    return 0;
+    return rtl::str::compare_WithLength(pStr1, nStr1Len, pStr2, rtl::str::CompareIgnoreAsciiCase());
 }
 
 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::compareIgnoreAsciiCase_WithLength(first, firstLen, second, secondLen);
+    return rtl::str::compare_WithLengths(first, firstLen, second, secondLen,
+                                         rtl::str::CompareIgnoreAsciiCase());
 }
 
 /* ----------------------------------------------------------------------- */
@@ -340,41 +270,8 @@ sal_Int32 SAL_CALL rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( co
                                                                               sal_Int32 nShortenedLength )
     SAL_THROW_EXTERN_C()
 {
-    assert(nStr1Len >= 0);
-    assert(nShortenedLength >= 0);
-    const sal_Unicode*  pStr1End = pStr1 + nStr1Len;
-    sal_Int32           nRet;
-    while ( (nShortenedLength > 0) &&
-            (pStr1 < pStr1End) && *pStr2 )
-    {
-        SAL_WARN_IF( !rtl::isAscii(static_cast<unsigned char>(*pStr2)), "rtl.string",
-                    "rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength - Found char > 127" );
-
-        nRet = rtl::compareIgnoreAsciiCase(*pStr1, static_cast<unsigned char>(*pStr2));
-        if ( nRet != 0 )
-            return nRet;
-
-        nShortenedLength--;
-        pStr1++;
-        pStr2++;
-    }
-
-    if ( nShortenedLength <= 0 )
-        return 0;
-
-    if ( *pStr2 )
-    {
-        OSL_ENSURE( pStr1 == pStr1End, "pStr1 == pStr1End failed" );
-        // first is a substring of the second string => less (negative value)
-        nRet = -1;
-    }
-    else
-    {
-        // greater or equal
-        nRet = pStr1End - pStr1;
-    }
-
-    return nRet;
+    return rtl::str::shortenedCompare_WithLength(pStr1, nStr1Len, pStr2, nShortenedLength,
+                                                 rtl::str::CompareIgnoreAsciiCase());
 }
 
 /* ----------------------------------------------------------------------- */
@@ -1096,34 +993,37 @@ 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);
+    return rtl::str::compare(pStr1, pStr2, rtl::str::CompareNormal());
 }
 
 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_WithLength(pStr1, nStr1Len, pStr2, nStr2Len);
+    return rtl::str::compare_WithLengths(pStr1, nStr1Len, pStr2, nStr2Len,
+                                         rtl::str::CompareNormal());
 }
 
 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_WithLength(pStr1, nStr1Len, pStr2, nStr2Len, nShortenedLength);
+    return rtl::str::shortenedCompare_WithLengths(pStr1, nStr1Len, pStr2, nStr2Len,
+                                                  nShortenedLength, rtl::str::CompareNormal());
 }
 
 sal_Int32 SAL_CALL rtl_ustr_reverseCompare_WithLength(const sal_Unicode* pStr1, sal_Int32 nStr1Len,
                                                       const sal_Unicode* pStr2, sal_Int32 nStr2Len)
     SAL_THROW_EXTERN_C()
 {
-    return rtl::str::reverseCompare_WithLength(pStr1, nStr1Len, pStr2, nStr2Len);
+    return rtl::str::reverseCompare_WithLengths(pStr1, nStr1Len, pStr2, nStr2Len,
+                                                rtl::str::CompareNormal());
 }
 
 sal_Int32 SAL_CALL rtl_ustr_compareIgnoreAsciiCase(const sal_Unicode* pStr1,
                                                    const sal_Unicode* pStr2) SAL_THROW_EXTERN_C()
 {
-    return rtl::str::compareIgnoreAsciiCase(pStr1, pStr2);
+    return rtl::str::compare(pStr1, pStr2, rtl::str::CompareIgnoreAsciiCase());
 }
 
 sal_Int32 SAL_CALL rtl_ustr_compareIgnoreAsciiCase_WithLength(const sal_Unicode* pStr1,
@@ -1132,15 +1032,16 @@ sal_Int32 SAL_CALL rtl_ustr_compareIgnoreAsciiCase_WithLength(const sal_Unicode*
                                                               sal_Int32 nStr2Len)
     SAL_THROW_EXTERN_C()
 {
-    return rtl::str::compareIgnoreAsciiCase_WithLength(pStr1, nStr1Len, pStr2, nStr2Len);
+    return rtl::str::compare_WithLengths(pStr1, nStr1Len, pStr2, nStr2Len,
+                                         rtl::str::CompareIgnoreAsciiCase());
 }
 
 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::shortenedCompareIgnoreAsciiCase_WithLength(pStr1, nStr1Len, pStr2, nStr2Len,
-                                                              nShortenedLength);
+    return rtl::str::shortenedCompare_WithLengths(
+        pStr1, nStr1Len, pStr2, nStr2Len, nShortenedLength, rtl::str::CompareIgnoreAsciiCase());
 }
 
 sal_Int32 SAL_CALL rtl_ustr_hashCode(const sal_Unicode* pStr) SAL_THROW_EXTERN_C()