Adding upstream version 6.0.4-dfsg.upstream/6.0.4-dfsgupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1140 insertions, 0 deletions

diff --git a/src/VBox/Runtime/common/string/ministring.cpp b/src/VBox/Runtime/common/string/ministring.cpp
new file mode 100644
index 00000000..dcd37697
--- /dev/null
+++ b/src/VBox/Runtime/common/string/ministring.cpp
@@ -0,0 +1,1140 @@
+/* $Id: ministring.cpp $ */
+/** @file
+ * IPRT - Mini C++ string class.
+ *
+ * This is a base for both Utf8Str and other places where IPRT may want to use
+ * a lean C++ string class.
+ */
+
+/*
+ * Copyright (C) 2007-2019 Oracle Corporation
+ *
+ * This file is part of VirtualBox Open Source Edition (OSE), as
+ * available from http://www.virtualbox.org. This file is free software;
+ * you can redistribute it and/or modify it under the terms of the GNU
+ * General Public License (GPL) as published by the Free Software
+ * Foundation, in version 2 as it comes in the "COPYING" file of the
+ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
+ * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
+ *
+ * The contents of this file may alternatively be used under the terms
+ * of the Common Development and Distribution License Version 1.0
+ * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
+ * VirtualBox OSE distribution, in which case the provisions of the
+ * CDDL are applicable instead of those of the GPL.
+ *
+ * You may elect to license modified versions of this file under the
+ * terms and conditions of either the GPL or the CDDL or both.
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include <iprt/cpp/ministring.h>
+#include "internal/iprt.h"
+
+#include <iprt/ctype.h>
+#include <iprt/uni.h>
+#include <iprt/err.h>
+
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+const size_t RTCString::npos = ~(size_t)0;
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+/** Allocation block alignment used when appending bytes to a string. */
+#define IPRT_MINISTRING_APPEND_ALIGNMENT    64
+
+
+RTCString &RTCString::assign(const RTCString &a_rSrc)
+{
+    size_t const cchSrc = a_rSrc.length();
+    if (cchSrc > 0)
+    {
+        reserve(cchSrc + 1);
+        memcpy(m_psz, a_rSrc.c_str(), cchSrc);
+        m_psz[cchSrc] = '\0';
+        m_cch = cchSrc;
+        return *this;
+    }
+    setNull();
+    return *this;
+
+}
+
+int RTCString::assignNoThrow(const RTCString &a_rSrc) RT_NOEXCEPT
+{
+    AssertReturn(&a_rSrc != this, VINF_SUCCESS);
+    size_t const cchSrc = a_rSrc.length();
+    if (cchSrc > 0)
+    {
+        int rc = reserveNoThrow(cchSrc + 1);
+        if (RT_SUCCESS(rc))
+        {
+            memcpy(m_psz, a_rSrc.c_str(), cchSrc);
+            m_psz[cchSrc] = '\0';
+            m_cch = cchSrc;
+            return VINF_SUCCESS;
+        }
+        return rc;
+    }
+    setNull();
+    return VINF_SUCCESS;
+
+}
+
+RTCString &RTCString::assign(const char *a_pszSrc)
+{
+    if (a_pszSrc)
+    {
+        size_t cchSrc = strlen(a_pszSrc);
+        if (cchSrc)
+        {
+            reserve(cchSrc + 1);
+            memcpy(m_psz, a_pszSrc, cchSrc);
+            m_psz[cchSrc] = '\0';
+            m_cch = cchSrc;
+            return *this;
+        }
+    }
+    setNull();
+    return *this;
+}
+
+int RTCString::assignNoThrow(const char *a_pszSrc) RT_NOEXCEPT
+{
+    if (a_pszSrc)
+    {
+        size_t cchSrc = strlen(a_pszSrc);
+        if (cchSrc)
+        {
+            int rc = reserveNoThrow(cchSrc + 1);
+            if (RT_SUCCESS(rc))
+            {
+                memcpy(m_psz, a_pszSrc, cchSrc);
+                m_psz[cchSrc] = '\0';
+                m_cch = cchSrc;
+                return VINF_SUCCESS;
+            }
+            return rc;
+        }
+    }
+    setNull();
+    return VINF_SUCCESS;
+}
+
+RTCString &RTCString::assign(const RTCString &a_rSrc, size_t a_offSrc, size_t a_cchSrc /*= npos*/)
+{
+    AssertReturn(&a_rSrc != this, *this);
+    if (a_offSrc < a_rSrc.length())
+    {
+        size_t cchMax = a_rSrc.length() - a_offSrc;
+        if (a_cchSrc > cchMax)
+            a_cchSrc = cchMax;
+        reserve(a_cchSrc + 1);
+        memcpy(m_psz, a_rSrc.c_str() + a_offSrc, a_cchSrc);
+        m_psz[a_cchSrc] = '\0';
+        m_cch = a_cchSrc;
+    }
+    else
+        setNull();
+    return *this;
+}
+
+int RTCString::assignNoThrow(const RTCString &a_rSrc, size_t a_offSrc, size_t a_cchSrc /*= npos*/) RT_NOEXCEPT
+{
+    AssertReturn(&a_rSrc != this, VINF_SUCCESS);
+    if (a_offSrc < a_rSrc.length())
+    {
+        size_t cchMax = a_rSrc.length() - a_offSrc;
+        if (a_cchSrc > cchMax)
+            a_cchSrc = cchMax;
+        int rc = reserveNoThrow(a_cchSrc + 1);
+        if (RT_SUCCESS(rc))
+        {
+            memcpy(m_psz, a_rSrc.c_str() + a_offSrc, a_cchSrc);
+            m_psz[a_cchSrc] = '\0';
+            m_cch = a_cchSrc;
+            return VINF_SUCCESS;
+        }
+        return rc;
+    }
+    setNull();
+    return VINF_SUCCESS;
+}
+
+RTCString &RTCString::assign(const char *a_pszSrc, size_t a_cchSrc)
+{
+    if (a_cchSrc)
+    {
+        a_cchSrc = RTStrNLen(a_pszSrc, a_cchSrc);
+        reserve(a_cchSrc + 1);
+        memcpy(m_psz, a_pszSrc, a_cchSrc);
+        m_psz[a_cchSrc] = '\0';
+        m_cch = a_cchSrc;
+    }
+    else
+        setNull();
+    return *this;
+}
+
+int RTCString::assignNoThrow(const char *a_pszSrc, size_t a_cchSrc) RT_NOEXCEPT
+{
+    if (a_cchSrc)
+    {
+        a_cchSrc = RTStrNLen(a_pszSrc, a_cchSrc);
+        int rc = reserveNoThrow(a_cchSrc + 1);
+        if (RT_SUCCESS(rc))
+        {
+            memcpy(m_psz, a_pszSrc, a_cchSrc);
+            m_psz[a_cchSrc] = '\0';
+            m_cch = a_cchSrc;
+            return VINF_SUCCESS;
+        }
+        return rc;
+    }
+    setNull();
+    return VINF_SUCCESS;
+}
+
+RTCString &RTCString::assign(size_t a_cTimes, char a_ch)
+{
+    reserve(a_cTimes + 1);
+    memset(m_psz, a_ch, a_cTimes);
+    m_psz[a_cTimes] = '\0';
+    m_cch = a_cTimes;
+    return *this;
+}
+
+
+int RTCString::assignNoThrow(size_t a_cTimes, char a_ch) RT_NOEXCEPT
+{
+    int rc = reserveNoThrow(a_cTimes + 1);
+    if (RT_SUCCESS(rc))
+    {
+        memset(m_psz, a_ch, a_cTimes);
+        m_psz[a_cTimes] = '\0';
+        m_cch = a_cTimes;
+        return VINF_SUCCESS;
+    }
+    return rc;
+}
+
+
+RTCString &RTCString::printf(const char *pszFormat, ...)
+{
+    va_list va;
+    va_start(va, pszFormat);
+    printfV(pszFormat, va);
+    va_end(va);
+    return *this;
+}
+
+int RTCString::printfNoThrow(const char *pszFormat, ...) RT_NOEXCEPT
+{
+    va_list va;
+    va_start(va, pszFormat);
+    int rc = printfVNoThrow(pszFormat, va);
+    va_end(va);
+    return rc;
+}
+
+/**
+ * Callback used with RTStrFormatV by RTCString::printfV.
+ *
+ * @returns The number of bytes added (not used).
+ *
+ * @param   pvArg           The string object.
+ * @param   pachChars       The characters to append.
+ * @param   cbChars         The number of characters.  0 on the final callback.
+ */
+/*static*/ DECLCALLBACK(size_t)
+RTCString::printfOutputCallback(void *pvArg, const char *pachChars, size_t cbChars)
+{
+    RTCString *pThis = (RTCString *)pvArg;
+    if (cbChars)
+    {
+        size_t const cchBoth = pThis->m_cch + cbChars;
+        if (cchBoth >= pThis->m_cbAllocated)
+        {
+            /* Double the buffer size, if it's less that _4M. Align sizes like
+               for append. */
+            size_t cbAlloc = RT_ALIGN_Z(pThis->m_cbAllocated, IPRT_MINISTRING_APPEND_ALIGNMENT);
+            cbAlloc += RT_MIN(cbAlloc, _4M);
+            if (cbAlloc <= cchBoth)
+                cbAlloc = RT_ALIGN_Z(cchBoth + 1, IPRT_MINISTRING_APPEND_ALIGNMENT);
+            pThis->reserve(cbAlloc);
+#ifndef RT_EXCEPTIONS_ENABLED
+            AssertReleaseReturn(pThis->capacity() > cchBoth, 0);
+#endif
+        }
+
+        memcpy(&pThis->m_psz[pThis->m_cch], pachChars, cbChars);
+        pThis->m_cch = cchBoth;
+        pThis->m_psz[cchBoth] = '\0';
+    }
+    return cbChars;
+}
+
+RTCString &RTCString::printfV(const char *pszFormat, va_list va)
+{
+    cleanup();
+    RTStrFormatV(printfOutputCallback, this, NULL, NULL, pszFormat, va);
+    return *this;
+}
+
+RTCString &RTCString::appendPrintfV(const char *pszFormat, va_list va)
+{
+    RTStrFormatV(printfOutputCallback, this, NULL, NULL, pszFormat, va);
+    return *this;
+}
+
+struct RTCSTRINGOTHROW
+{
+    RTCString  *pThis;
+    int         rc;
+};
+
+/**
+ * Callback used with RTStrFormatV by RTCString::printfVNoThrow.
+ *
+ * @returns The number of bytes added (not used).
+ *
+ * @param   pvArg           Pointer to a RTCSTRINGOTHROW structure.
+ * @param   pachChars       The characters to append.
+ * @param   cbChars         The number of characters.  0 on the final callback.
+ */
+/*static*/ DECLCALLBACK(size_t)
+RTCString::printfOutputCallbackNoThrow(void *pvArg, const char *pachChars, size_t cbChars) RT_NOEXCEPT
+{
+    RTCString *pThis = ((RTCSTRINGOTHROW *)pvArg)->pThis;
+    if (cbChars)
+    {
+        size_t const cchBoth = pThis->m_cch + cbChars;
+        if (cchBoth >= pThis->m_cbAllocated)
+        {
+            /* Double the buffer size, if it's less that _4M. Align sizes like
+               for append. */
+            size_t cbAlloc = RT_ALIGN_Z(pThis->m_cbAllocated, IPRT_MINISTRING_APPEND_ALIGNMENT);
+            cbAlloc += RT_MIN(cbAlloc, _4M);
+            if (cbAlloc <= cchBoth)
+                cbAlloc = RT_ALIGN_Z(cchBoth + 1, IPRT_MINISTRING_APPEND_ALIGNMENT);
+            int rc = pThis->reserveNoThrow(cbAlloc);
+            if (RT_SUCCESS(rc))
+            { /* likely */ }
+            else
+            {
+                ((RTCSTRINGOTHROW *)pvArg)->rc = rc;
+                return cbChars;
+            }
+        }
+
+        memcpy(&pThis->m_psz[pThis->m_cch], pachChars, cbChars);
+        pThis->m_cch = cchBoth;
+        pThis->m_psz[cchBoth] = '\0';
+    }
+    return cbChars;
+}
+
+int RTCString::printfVNoThrow(const char *pszFormat, va_list va) RT_NOEXCEPT
+{
+    cleanup();
+    RTCSTRINGOTHROW Args = { this, VINF_SUCCESS };
+    RTStrFormatV(printfOutputCallbackNoThrow, &Args, NULL, NULL, pszFormat, va);
+    return Args.rc;
+}
+
+int RTCString::appendPrintfVNoThrow(const char *pszFormat, va_list va) RT_NOEXCEPT
+{
+    RTCSTRINGOTHROW Args = { this, VINF_SUCCESS };
+    RTStrFormatV(printfOutputCallbackNoThrow, &Args, NULL, NULL, pszFormat, va);
+    return Args.rc;
+}
+
+RTCString &RTCString::appendPrintf(const char *pszFormat, ...)
+{
+    va_list va;
+    va_start(va, pszFormat);
+    appendPrintfV(pszFormat, va);
+    va_end(va);
+    return *this;
+}
+
+int RTCString::appendPrintfNoThrow(const char *pszFormat, ...) RT_NOEXCEPT
+{
+    va_list va;
+    va_start(va, pszFormat);
+    int rc = appendPrintfVNoThrow(pszFormat, va);
+    va_end(va);
+    return rc;
+}
+
+RTCString &RTCString::append(const RTCString &that)
+{
+    Assert(&that != this);
+    return appendWorker(that.c_str(), that.length());
+}
+
+int RTCString::appendNoThrow(const RTCString &that) RT_NOEXCEPT
+{
+    Assert(&that != this);
+    return appendWorkerNoThrow(that.c_str(), that.length());
+}
+
+RTCString &RTCString::append(const char *pszThat)
+{
+    return appendWorker(pszThat, strlen(pszThat));
+}
+
+int RTCString::appendNoThrow(const char *pszThat) RT_NOEXCEPT
+{
+    return appendWorkerNoThrow(pszThat, strlen(pszThat));
+}
+
+RTCString &RTCString::append(const RTCString &rThat, size_t offStart, size_t cchMax /*= RTSTR_MAX*/)
+{
+    if (offStart < rThat.length())
+    {
+        size_t cchLeft = rThat.length() - offStart;
+        return appendWorker(rThat.c_str() + offStart, RT_MIN(cchLeft, cchMax));
+    }
+    return *this;
+}
+
+int RTCString::appendNoThrow(const RTCString &rThat, size_t offStart, size_t cchMax /*= RTSTR_MAX*/) RT_NOEXCEPT
+{
+    if (offStart < rThat.length())
+    {
+        size_t cchLeft = rThat.length() - offStart;
+        return appendWorkerNoThrow(rThat.c_str() + offStart, RT_MIN(cchLeft, cchMax));
+    }
+    return VINF_SUCCESS;
+}
+
+RTCString &RTCString::append(const char *pszThat, size_t cchMax)
+{
+    return appendWorker(pszThat, RTStrNLen(pszThat, cchMax));
+}
+
+int RTCString::appendNoThrow(const char *pszThat, size_t cchMax) RT_NOEXCEPT
+{
+    return appendWorkerNoThrow(pszThat, RTStrNLen(pszThat, cchMax));
+}
+
+RTCString &RTCString::appendWorker(const char *pszSrc, size_t cchSrc)
+{
+    if (cchSrc)
+    {
+        size_t cchThis = length();
+        size_t cchBoth = cchThis + cchSrc;
+
+        if (cchBoth >= m_cbAllocated)
+        {
+            reserve(RT_ALIGN_Z(cchBoth + 1, IPRT_MINISTRING_APPEND_ALIGNMENT));
+            // calls realloc(cchBoth + 1) and sets m_cbAllocated; may throw bad_alloc.
+#ifndef RT_EXCEPTIONS_ENABLED
+            AssertRelease(capacity() > cchBoth);
+#endif
+        }
+
+        memcpy(&m_psz[cchThis], pszSrc, cchSrc);
+        m_psz[cchBoth] = '\0';
+        m_cch = cchBoth;
+    }
+    return *this;
+}
+
+int RTCString::appendWorkerNoThrow(const char *pszSrc, size_t cchSrc) RT_NOEXCEPT
+{
+    if (cchSrc)
+    {
+        size_t cchThis = length();
+        size_t cchBoth = cchThis + cchSrc;
+
+        if (cchBoth >= m_cbAllocated)
+        {
+            int rc = reserveNoThrow(RT_ALIGN_Z(cchBoth + 1, IPRT_MINISTRING_APPEND_ALIGNMENT));
+            if (RT_SUCCESS(rc))
+            { /* likely */ }
+            else
+                return rc;
+        }
+
+        memcpy(&m_psz[cchThis], pszSrc, cchSrc);
+        m_psz[cchBoth] = '\0';
+        m_cch = cchBoth;
+    }
+    return VINF_SUCCESS;
+}
+
+RTCString &RTCString::append(char ch)
+{
+    Assert((unsigned char)ch < 0x80);                  /* Don't create invalid UTF-8. */
+    if (ch)
+    {
+        // allocate in chunks of 20 in case this gets called several times
+        if (m_cch + 1 >= m_cbAllocated)
+        {
+            reserve(RT_ALIGN_Z(m_cch + 2, IPRT_MINISTRING_APPEND_ALIGNMENT));
+            // calls realloc(cbBoth) and sets m_cbAllocated; may throw bad_alloc.
+#ifndef RT_EXCEPTIONS_ENABLED
+            AssertRelease(capacity() > m_cch + 1);
+#endif
+        }
+
+        m_psz[m_cch] = ch;
+        m_psz[++m_cch] = '\0';
+    }
+    return *this;
+}
+
+int RTCString::appendNoThrow(char ch) RT_NOEXCEPT
+{
+    Assert((unsigned char)ch < 0x80);                  /* Don't create invalid UTF-8. */
+    if (ch)
+    {
+        // allocate in chunks of 20 in case this gets called several times
+        if (m_cch + 1 >= m_cbAllocated)
+        {
+            int rc = reserveNoThrow(RT_ALIGN_Z(m_cch + 2, IPRT_MINISTRING_APPEND_ALIGNMENT));
+            if (RT_SUCCESS(rc))
+            { /* likely */ }
+            else
+                return rc;
+        }
+
+        m_psz[m_cch] = ch;
+        m_psz[++m_cch] = '\0';
+    }
+    return VINF_SUCCESS;
+}
+
+RTCString &RTCString::appendCodePoint(RTUNICP uc)
+{
+    /*
+     * Single byte encoding.
+     */
+    if (uc < 0x80)
+        return RTCString::append((char)uc);
+
+    /*
+     * Multibyte encoding.
+     * Assume max encoding length when resizing the string, that's simpler.
+     */
+    AssertReturn(uc <= UINT32_C(0x7fffffff), *this);
+
+    if (m_cch + 6 >= m_cbAllocated)
+    {
+        reserve(RT_ALIGN_Z(m_cch + 6 + 1, IPRT_MINISTRING_APPEND_ALIGNMENT));
+        // calls realloc(cbBoth) and sets m_cbAllocated; may throw bad_alloc.
+#ifndef RT_EXCEPTIONS_ENABLED
+        AssertRelease(capacity() > m_cch + 6);
+#endif
+    }
+
+    char *pszNext = RTStrPutCp(&m_psz[m_cch], uc);
+    m_cch = pszNext - m_psz;
+    *pszNext = '\0';
+
+    return *this;
+}
+
+int RTCString::appendCodePointNoThrow(RTUNICP uc) RT_NOEXCEPT
+{
+    /*
+     * Single byte encoding.
+     */
+    if (uc < 0x80)
+        return RTCString::appendNoThrow((char)uc);
+
+    /*
+     * Multibyte encoding.
+     * Assume max encoding length when resizing the string, that's simpler.
+     */
+    AssertReturn(uc <= UINT32_C(0x7fffffff), VERR_INVALID_UTF8_ENCODING);
+
+    if (m_cch + 6 >= m_cbAllocated)
+    {
+        int rc = reserveNoThrow(RT_ALIGN_Z(m_cch + 6 + 1, IPRT_MINISTRING_APPEND_ALIGNMENT));
+        if (RT_SUCCESS(rc))
+        { /* likely */ }
+        else
+            return rc;
+    }
+
+    char *pszNext = RTStrPutCp(&m_psz[m_cch], uc);
+    m_cch = pszNext - m_psz;
+    *pszNext = '\0';
+
+    return VINF_SUCCESS;
+}
+
+RTCString &RTCString::erase(size_t offStart /*= 0*/, size_t cchLength /*= npos*/) RT_NOEXCEPT
+{
+    size_t cch = length();
+    if (offStart < cch)
+    {
+        if (cchLength >= cch - offStart)
+        {
+            /* Trail removal, nothing to move.  */
+            m_cch = offStart;
+            m_psz[offStart] = '\0';
+        }
+        else if (cchLength > 0)
+        {
+            /* Pull up the tail to offStart. */
+            size_t cchAfter = cch - offStart - cchLength;
+            memmove(&m_psz[offStart], &m_psz[offStart + cchLength], cchAfter);
+            m_cch = cch -= cchLength;
+            m_psz[cch] = '\0';
+        }
+    }
+    return *this;
+}
+
+RTCString &RTCString::replace(size_t offStart, size_t cchLength, const RTCString &rStrReplacement)
+{
+    return replaceWorker(offStart, cchLength, rStrReplacement.c_str(), rStrReplacement.length());
+}
+
+int RTCString::replaceNoThrow(size_t offStart, size_t cchLength, const RTCString &rStrReplacement) RT_NOEXCEPT
+{
+    return replaceWorkerNoThrow(offStart, cchLength, rStrReplacement.c_str(), rStrReplacement.length());
+}
+
+RTCString &RTCString::replace(size_t offStart, size_t cchLength, const RTCString &rStrReplacement,
+                              size_t offReplacement, size_t cchReplacement)
+{
+    Assert(this != &rStrReplacement);
+    if (cchReplacement > 0)
+    {
+        if (offReplacement < rStrReplacement.length())
+        {
+            size_t cchMaxReplacement = rStrReplacement.length() - offReplacement;
+            return replaceWorker(offStart, cchLength, rStrReplacement.c_str() + offReplacement,
+                                 RT_MIN(cchReplacement, cchMaxReplacement));
+        }
+        /* Our non-standard handling of out_of_range situations. */
+        AssertMsgFailed(("offReplacement=%zu (cchReplacement=%zu) rStrReplacement.length()=%zu\n",
+                         offReplacement, cchReplacement, rStrReplacement.length()));
+    }
+    return replaceWorker(offStart, cchLength, "", 0);
+}
+
+int RTCString::replaceNoThrow(size_t offStart, size_t cchLength, const RTCString &rStrReplacement,
+                              size_t offReplacement, size_t cchReplacement) RT_NOEXCEPT
+{
+    Assert(this != &rStrReplacement);
+    if (cchReplacement > 0)
+    {
+        if (offReplacement < rStrReplacement.length())
+        {
+            size_t cchMaxReplacement = rStrReplacement.length() - offReplacement;
+            return replaceWorkerNoThrow(offStart, cchLength, rStrReplacement.c_str() + offReplacement,
+                                        RT_MIN(cchReplacement, cchMaxReplacement));
+        }
+        return VERR_OUT_OF_RANGE;
+    }
+    return replaceWorkerNoThrow(offStart, cchLength, "", 0);
+}
+
+RTCString &RTCString::replace(size_t offStart, size_t cchLength, const char *pszReplacement)
+{
+    return replaceWorker(offStart, cchLength, pszReplacement, strlen(pszReplacement));
+}
+
+int RTCString::replaceNoThrow(size_t offStart, size_t cchLength, const char *pszReplacement) RT_NOEXCEPT
+{
+    return replaceWorkerNoThrow(offStart, cchLength, pszReplacement, strlen(pszReplacement));
+}
+
+RTCString &RTCString::replace(size_t offStart, size_t cchLength, const char *pszReplacement, size_t cchReplacement)
+{
+    return replaceWorker(offStart, cchLength, pszReplacement, RTStrNLen(pszReplacement, cchReplacement));
+}
+
+int RTCString::replaceNoThrow(size_t offStart, size_t cchLength, const char *pszReplacement, size_t cchReplacement) RT_NOEXCEPT
+{
+    return replaceWorkerNoThrow(offStart, cchLength, pszReplacement, RTStrNLen(pszReplacement, cchReplacement));
+}
+
+RTCString &RTCString::replaceWorker(size_t offStart, size_t cchLength, const char *pszSrc, size_t cchSrc)
+{
+    /*
+     * Our non-standard handling of out_of_range situations.
+     */
+    size_t const cchOldLength = length();
+    AssertMsgReturn(offStart < cchOldLength, ("offStart=%zu (cchLength=%zu); length()=%zu\n", offStart, cchLength, cchOldLength),
+                    *this);
+
+    /*
+     * Correct the length parameter.
+     */
+    size_t cchMaxLength = cchOldLength - offStart;
+    if (cchMaxLength < cchLength)
+        cchLength = cchMaxLength;
+
+    /*
+     * Adjust string allocation if necessary.
+     */
+    size_t cchNew = cchOldLength - cchLength + cchSrc;
+    if (cchNew >= m_cbAllocated)
+    {
+        reserve(RT_ALIGN_Z(cchNew + 1, IPRT_MINISTRING_APPEND_ALIGNMENT));
+        // calls realloc(cchBoth + 1) and sets m_cbAllocated; may throw bad_alloc.
+#ifndef RT_EXCEPTIONS_ENABLED
+        AssertRelease(capacity() > cchNew);
+#endif
+    }
+
+    /*
+     * Make the change.
+     */
+    size_t cchAfter = cchOldLength - offStart - cchLength;
+    if (cchAfter > 0)
+        memmove(&m_psz[offStart + cchSrc], &m_psz[offStart + cchLength], cchAfter);
+    memcpy(&m_psz[offStart], pszSrc, cchSrc);
+    m_psz[cchNew] = '\0';
+    m_cch = cchNew;
+
+    return *this;
+}
+
+int RTCString::replaceWorkerNoThrow(size_t offStart, size_t cchLength, const char *pszSrc, size_t cchSrc) RT_NOEXCEPT
+{
+    /*
+     * Our non-standard handling of out_of_range situations.
+     */
+    size_t const cchOldLength = length();
+    AssertMsgReturn(offStart < cchOldLength, ("offStart=%zu (cchLength=%zu); length()=%zu\n", offStart, cchLength, cchOldLength),
+                    VERR_OUT_OF_RANGE);
+
+    /*
+     * Correct the length parameter.
+     */
+    size_t cchMaxLength = cchOldLength - offStart;
+    if (cchMaxLength < cchLength)
+        cchLength = cchMaxLength;
+
+    /*
+     * Adjust string allocation if necessary.
+     */
+    size_t cchNew = cchOldLength - cchLength + cchSrc;
+    if (cchNew >= m_cbAllocated)
+    {
+        int rc = reserveNoThrow(RT_ALIGN_Z(cchNew + 1, IPRT_MINISTRING_APPEND_ALIGNMENT));
+        if (RT_SUCCESS(rc))
+        { /* likely */ }
+        else
+            return rc;
+    }
+
+    /*
+     * Make the change.
+     */
+    size_t cchAfter = cchOldLength - offStart - cchLength;
+    if (cchAfter > 0)
+        memmove(&m_psz[offStart + cchSrc], &m_psz[offStart + cchLength], cchAfter);
+    memcpy(&m_psz[offStart], pszSrc, cchSrc);
+    m_psz[cchNew] = '\0';
+    m_cch = cchNew;
+
+    return VINF_SUCCESS;
+}
+
+
+size_t RTCString::find(const char *pszNeedle, size_t offStart /*= 0*/) const RT_NOEXCEPT
+{
+    if (offStart < length())
+    {
+        const char *pszThis = c_str();
+        if (pszThis)
+        {
+            if (pszNeedle && *pszNeedle != '\0')
+            {
+                const char *pszHit = strstr(pszThis + offStart, pszNeedle);
+                if (pszHit)
+                    return pszHit - pszThis;
+            }
+        }
+    }
+
+    return npos;
+}
+
+size_t RTCString::find(const RTCString *pStrNeedle, size_t offStart /*= 0*/) const RT_NOEXCEPT
+{
+    if (offStart < length())
+    {
+        const char *pszThis = c_str();
+        if (pszThis)
+        {
+            if (pStrNeedle)
+            {
+                const char *pszNeedle = pStrNeedle->c_str();
+                if (pszNeedle && *pszNeedle != '\0')
+                {
+                    const char *pszHit = strstr(pszThis + offStart, pszNeedle);
+                    if (pszHit)
+                        return pszHit - pszThis;
+                }
+            }
+        }
+    }
+
+    return npos;
+}
+
+
+size_t RTCString::find(const RTCString &rStrNeedle, size_t offStart /*= 0*/) const RT_NOEXCEPT
+{
+    return find(&rStrNeedle, offStart);
+}
+
+
+size_t RTCString::find(const char chNeedle, size_t offStart /*= 0*/) const RT_NOEXCEPT
+{
+    Assert((unsigned int)chNeedle < 128U);
+    if (offStart < length())
+    {
+        const char *pszThis = c_str();
+        if (pszThis)
+        {
+            const char *pszHit = (const char *)memchr(&pszThis[offStart], chNeedle, length() - offStart);
+            if (pszHit)
+                return pszHit - pszThis;
+        }
+    }
+    return npos;
+}
+
+
+void RTCString::findReplace(char chFind, char chReplace) RT_NOEXCEPT
+{
+    Assert((unsigned int)chFind    < 128U);
+    Assert((unsigned int)chReplace < 128U);
+
+    for (size_t i = 0; i < length(); ++i)
+    {
+        char *p = &m_psz[i];
+        if (*p == chFind)
+            *p = chReplace;
+    }
+}
+
+size_t RTCString::count(char ch) const RT_NOEXCEPT
+{
+    Assert((unsigned int)ch < 128U);
+
+    size_t      c   = 0;
+    const char *psz = m_psz;
+    if (psz)
+    {
+        char    chCur;
+        while ((chCur = *psz++) != '\0')
+            if (chCur == ch)
+                c++;
+    }
+    return c;
+}
+
+#if 0  /** @todo implement these when needed. */
+size_t RTCString::count(const char *psz, CaseSensitivity cs = CaseSensitive) const RT_NOEXCEPT
+{
+}
+
+size_t RTCString::count(const RTCString *pStr, CaseSensitivity cs = CaseSensitive) const RT_NOEXCEPT
+{
+
+}
+#endif
+
+
+RTCString &RTCString::strip() RT_NOEXCEPT
+{
+    stripRight();
+    return stripLeft();
+}
+
+
+RTCString &RTCString::stripLeft() RT_NOEXCEPT
+{
+    char        *psz = m_psz;
+    size_t const cch = m_cch;
+    size_t       off = 0;
+    while (off < cch && RT_C_IS_SPACE(psz[off]))
+        off++;
+    if (off > 0)
+    {
+        if (off != cch)
+        {
+            memmove(psz, &psz[off], cch - off + 1);
+            m_cch = cch - off;
+        }
+        else
+            setNull();
+    }
+    return *this;
+}
+
+
+RTCString &RTCString::stripRight() RT_NOEXCEPT
+{
+    char  *psz = m_psz;
+    size_t cch = m_cch;
+    while (cch > 0 && RT_C_IS_SPACE(psz[cch - 1]))
+        cch--;
+    if (m_cch != cch)
+    {
+        m_cch = cch;
+        psz[cch] = '\0';
+    }
+    return *this;
+}
+
+
+
+RTCString RTCString::substrCP(size_t pos /*= 0*/, size_t n /*= npos*/) const
+{
+    RTCString ret;
+
+    if (n)
+    {
+        const char *psz;
+
+        if ((psz = c_str()))
+        {
+            RTUNICP cp;
+
+            // walk the UTF-8 characters until where the caller wants to start
+            size_t i = pos;
+            while (*psz && i--)
+                if (RT_FAILURE(RTStrGetCpEx(&psz, &cp)))
+                    return ret;     // return empty string on bad encoding
+
+            const char *pFirst = psz;
+
+            if (n == npos)
+                // all the rest:
+                ret = pFirst;
+            else
+            {
+                i = n;
+                while (*psz && i--)
+                    if (RT_FAILURE(RTStrGetCpEx(&psz, &cp)))
+                        return ret;     // return empty string on bad encoding
+
+                size_t cbCopy = psz - pFirst;
+                if (cbCopy)
+                {
+                    ret.reserve(cbCopy + 1); // may throw bad_alloc
+#ifndef RT_EXCEPTIONS_ENABLED
+                    AssertRelease(capacity() >= cbCopy + 1);
+#endif
+                    memcpy(ret.m_psz, pFirst, cbCopy);
+                    ret.m_cch = cbCopy;
+                    ret.m_psz[cbCopy] = '\0';
+                }
+            }
+        }
+    }
+
+    return ret;
+}
+
+bool RTCString::endsWith(const RTCString &that, CaseSensitivity cs /*= CaseSensitive*/) const RT_NOEXCEPT
+{
+    size_t l1 = length();
+    if (l1 == 0)
+        return false;
+
+    size_t l2 = that.length();
+    if (l1 < l2)
+        return false;
+    /** @todo r=bird: If l2 is 0, then m_psz can be NULL and we will crash. See
+     *        also handling of l2 == in startsWith. */
+
+    size_t l = l1 - l2;
+    if (cs == CaseSensitive)
+        return ::RTStrCmp(&m_psz[l], that.m_psz) == 0;
+    return ::RTStrICmp(&m_psz[l], that.m_psz) == 0;
+}
+
+bool RTCString::startsWith(const RTCString &that, CaseSensitivity cs /*= CaseSensitive*/) const RT_NOEXCEPT
+{
+    size_t l1 = length();
+    size_t l2 = that.length();
+    if (l1 == 0 || l2 == 0) /** @todo r=bird: this differs from endsWith, and I think other IPRT code. If l2 == 0, it matches anything. */
+        return false;
+
+    if (l1 < l2)
+        return false;
+
+    if (cs == CaseSensitive)
+        return ::RTStrNCmp(m_psz, that.m_psz, l2) == 0;
+    return ::RTStrNICmp(m_psz, that.m_psz, l2) == 0;
+}
+
+bool RTCString::startsWithWord(const char *pszWord, CaseSensitivity enmCase /*= CaseSensitive*/) const RT_NOEXCEPT
+{
+    const char *pszSrc  = RTStrStripL(c_str()); /** @todo RTStrStripL doesn't use RTUniCpIsSpace (nbsp) */
+    size_t      cchWord = strlen(pszWord);
+    if (  enmCase == CaseSensitive
+        ? RTStrNCmp(pszSrc, pszWord, cchWord) == 0
+        : RTStrNICmp(pszSrc, pszWord, cchWord) == 0)
+    {
+        if (   pszSrc[cchWord] == '\0'
+            || RT_C_IS_SPACE(pszSrc[cchWord])
+            || RT_C_IS_PUNCT(pszSrc[cchWord]) )
+            return true;
+        RTUNICP uc = RTStrGetCp(&pszSrc[cchWord]);
+        if (RTUniCpIsSpace(uc))
+            return true;
+    }
+    return false;
+}
+
+bool RTCString::startsWithWord(const RTCString &rThat, CaseSensitivity enmCase /*= CaseSensitive*/) const RT_NOEXCEPT
+{
+    return startsWithWord(rThat.c_str(), enmCase);
+}
+
+bool RTCString::contains(const RTCString &that, CaseSensitivity cs /*= CaseSensitive*/) const RT_NOEXCEPT
+{
+    /** @todo r-bird: Not checking for NULL strings like startsWith does (and
+     *        endsWith only does half way). */
+    if (cs == CaseSensitive)
+        return ::RTStrStr(m_psz, that.m_psz) != NULL;
+    return ::RTStrIStr(m_psz, that.m_psz) != NULL;
+}
+
+bool RTCString::contains(const char *pszNeedle, CaseSensitivity cs /*= CaseSensitive*/) const RT_NOEXCEPT
+{
+    /** @todo r-bird: Not checking for NULL strings like startsWith does (and
+     *        endsWith only does half way). */
+    if (cs == CaseSensitive)
+        return ::RTStrStr(m_psz, pszNeedle) != NULL;
+    return ::RTStrIStr(m_psz, pszNeedle) != NULL;
+}
+
+int RTCString::toInt(uint64_t &i) const RT_NOEXCEPT
+{
+    if (!m_psz)
+        return VERR_NO_DIGITS;
+    return RTStrToUInt64Ex(m_psz, NULL, 0, &i);
+}
+
+int RTCString::toInt(uint32_t &i) const RT_NOEXCEPT
+{
+    if (!m_psz)
+        return VERR_NO_DIGITS;
+    return RTStrToUInt32Ex(m_psz, NULL, 0, &i);
+}
+
+RTCList<RTCString, RTCString *>
+RTCString::split(const RTCString &a_rstrSep, SplitMode mode /* = RemoveEmptyParts */) const
+{
+    RTCList<RTCString> strRet;
+    if (!m_psz)
+        return strRet;
+    if (a_rstrSep.isEmpty())
+    {
+        strRet.append(RTCString(m_psz));
+        return strRet;
+    }
+
+    size_t      cch    = m_cch;
+    char const *pszTmp = m_psz;
+    while (cch > 0)
+    {
+        char const *pszNext = strstr(pszTmp, a_rstrSep.c_str());
+        if (!pszNext)
+        {
+            strRet.append(RTCString(pszTmp, cch));
+            break;
+        }
+        size_t cchNext = pszNext - pszTmp;
+        if (   cchNext > 0
+            || mode == KeepEmptyParts)
+            strRet.append(RTCString(pszTmp, cchNext));
+        pszTmp += cchNext + a_rstrSep.length();
+        cch    -= cchNext + a_rstrSep.length();
+    }
+
+    return strRet;
+}
+
+/* static */
+RTCString
+RTCString::joinEx(const RTCList<RTCString, RTCString *> &a_rList,
+                  const RTCString &a_rstrPrefix /* = "" */,
+                  const RTCString &a_rstrSep /* = "" */)
+{
+    RTCString strRet;
+    if (a_rList.size() > 1)
+    {
+        /* calc the required size */
+        size_t cbNeeded = a_rstrSep.length() * (a_rList.size() - 1) + 1;
+        cbNeeded += a_rstrPrefix.length() * (a_rList.size() - 1) + 1;
+        for (size_t i = 0; i < a_rList.size(); ++i)
+            cbNeeded += a_rList.at(i).length();
+        strRet.reserve(cbNeeded);
+
+        /* do the appending. */
+        for (size_t i = 0; i < a_rList.size() - 1; ++i)
+        {
+            if (a_rstrPrefix.isNotEmpty())
+                strRet.append(a_rstrPrefix);
+            strRet.append(a_rList.at(i));
+            strRet.append(a_rstrSep);
+        }
+        strRet.append(a_rList.last());
+    }
+    /* special case: one list item. */
+    else if (a_rList.size() > 0)
+    {
+        if (a_rstrPrefix.isNotEmpty())
+            strRet.append(a_rstrPrefix);
+        strRet.append(a_rList.last());
+    }
+
+    return strRet;
+}
+
+/* static */
+RTCString
+RTCString::join(const RTCList<RTCString, RTCString *> &a_rList,
+                const RTCString &a_rstrSep /* = "" */)
+{
+    return RTCString::joinEx(a_rList,
+                             "" /* a_rstrPrefix */, a_rstrSep);
+}
+
+const RTCString operator+(const RTCString &a_rStr1, const RTCString &a_rStr2)
+{
+    RTCString strRet(a_rStr1);
+    strRet += a_rStr2;
+    return strRet;
+}
+
+const RTCString operator+(const RTCString &a_rStr1, const char *a_pszStr2)
+{
+    RTCString strRet(a_rStr1);
+    strRet += a_pszStr2;
+    return strRet;
+}
+
+const RTCString operator+(const char *a_psz1, const RTCString &a_rStr2)
+{
+    RTCString strRet(a_psz1);
+    strRet += a_rStr2;
+    return strRet;
+}
+