Changeset 80835 in vbox

Timestamp:

Sep 16, 2019 8:30:40 PM (6 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

133405

Message:

Main/glue: Added bstr testcase and fixed printf bugs. Introduced jolt, joltNoThrow, reserve and reserveNoThrow for the low level allocation operations needed by printf.

Location:

trunk

Files:

• include/VBox/com/string.h (modified) (1 diff)
• src/VBox/Main/glue/string.cpp (modified) (4 diffs)
• src/VBox/Main/testcase/Makefile.kmk (modified) (2 diffs)
• src/VBox/Main/testcase/tstBstr.cpp (added)

trunk/include/VBox/com/string.h

@@ -386 +386 @@
 
     /**
-     *  Returns a non-const raw pointer that allows to modify the string directly.
-     *  As opposed to raw(), this DOES return NULL if the member string is empty
-     *  because we cannot return a mutable pointer to the global variable with the
-     *  empty string.
-     *
-     *  @warning
-     *      Be sure not to modify data beyond the allocated memory! The
-     *      guaranteed size of the allocated memory is at least #length()
-     *      bytes after creation and after every assignment operation.
+     * Returns a non-const raw pointer that allows modifying the string directly.
+     *
+     * @note As opposed to raw(), this DOES return NULL if the member string is
+     *       empty because we cannot return a mutable pointer to the global variable
+     *       with the empty string.
+     *
+     * @note If modifying the string size (only shrinking it is allows), #jolt() or
+     *       #joltNoThrow() must be called!
+     *
+     * @note Do not modify memory beyond the #length() of the string!
+     *
+     * @sa   joltNoThrow(), mutalbleRaw(), reserve(), reserveNoThrow()
      */
     BSTR mutableRaw() { return m_bstr; }
+
+    /**
+     * Correct the embedded length after using mutableRaw().
+     *
+     * This is needed on COM (Windows) to update the embedded string length.  It is
+     * a stub on hosts using XPCOM.
+     *
+     * @param   cwcNew      The new string length, if handy, otherwise a negative
+     *                      number.
+     * @sa      joltNoThrow(), mutalbleRaw(), reserve(), reserveNoThrow()
+     */
+#ifndef VBOX_WITH_XPCOM
+    void jolt(ssize_t cwcNew = -1);
+#else
+    void jolt(ssize_t cwcNew = -1)
+    {
+        Assert(cwcNew < 0 || (cwcNew == 0 && !m_bstr) || m_bstr[cwcNew] == '\0'); RT_NOREF(cwcNew);
+    }
+#endif
+
+    /**
+     * Correct the embedded length after using mutableRaw().
+     *
+     * This is needed on COM (Windows) to update the embedded string length.  It is
+     * a stub on hosts using XPCOM.
+     *
+     * @returns S_OK on success, E_OUTOFMEMORY if shrinking the string failed.
+     * @param   cwcNew      The new string length, if handy, otherwise a negative
+     *                      number.
+     * @sa      jolt(), mutalbleRaw(), reserve(), reserveNoThrow()
+     */
+#ifndef VBOX_WITH_XPCOM
+    HRESULT joltNoThrow(ssize_t cwcNew = -1) RT_NOEXCEPT;
+#else
+    HRESULT joltNoThrow(ssize_t cwcNew = -1) RT_NOEXCEPT
+    {
+        Assert(cwcNew < 0 || (cwcNew == 0 && !m_bstr) || m_bstr[cwcNew] == '\0'); RT_NOREF(cwcNew);
+        return S_OK;
+    }
+#endif
+
+    /**
+     * Make sure at that least @a cwc of buffer space is reserved.
+     *
+     * Requests that the contained memory buffer have at least cb bytes allocated.
+     * This may expand or shrink the string's storage, but will never truncate the
+     * contained string.  In other words, cb will be ignored if it's smaller than
+     * length() + 1.
+     *
+     * @param   cwcMin  The new minimum string length that the can be stored. This
+     *                  does not include the terminator.
+     * @param   fForce  Force this size.
+     *
+     * @throws  std::bad_alloc  On allocation error.  The object is left unchanged.
+     */
+    void reserve(size_t cwcMin, bool fForce = false);
+
+    /**
+     * A C like version of the #reserve() method, i.e. return code instead of throw.
+     *
+     * @returns S_OK or E_OUTOFMEMORY.
+     * @param   cwcMin  The new minimum string length that the can be stored.  This
+     *                  does not include the terminator.
+    * @param   fForce  Force this size.
+     */
+    HRESULT reserveNoThrow(size_t cwcMin, bool fForce = false) RT_NOEXCEPT;
 
     /**

trunk/src/VBox/Main/glue/string.cpp

@@ -112 +112 @@
                 if (cwcAlloc <= cwcBoth)
                     cwcAlloc = RT_ALIGN_Z(cwcBoth + 1, 512);
-                if (pArgs->cwcAlloc)
-                    AssertMsgReturnStmt(::SysReAllocStringLen(&pThis->m_bstr, NULL, (unsigned)cwcAlloc),
-                                        ("cwcAlloc=%#zx\n", cwcAlloc), pArgs->hrc = E_OUTOFMEMORY, 0);
-                else
-                {
-                    Assert(pThis->m_bstr == NULL);
-                    pThis->m_bstr = ::SysAllocStringLen(NULL, (unsigned)cwcAlloc);
-                    AssertMsgReturnStmt(pThis->m_bstr, ("cwcAlloc=%#zx\n", cwcAlloc), pArgs->hrc = E_OUTOFMEMORY, 0);
-                }
+                pArgs->hrc = pThis->reserveNoThrow(cwcAlloc, true /*fForce*/);
+                AssertMsgReturn(pArgs->hrc == S_OK, ("cwcAlloc=%#zx\n", cwcAlloc), 0);
                 pArgs->cwcAlloc = cwcAlloc;
             }
@@ -134 +127 @@
         rc = ::RTStrToUtf16Ex(pachChars, cbChars, &pwszDst, pArgs->cwcAlloc - pArgs->offDst, &cwcAppend);
         AssertRCReturnStmt(rc, pArgs->hrc = E_UNEXPECTED, 0);
+        pArgs->offDst += cwcAppend;
     }
     return cbChars;
@@ -142 +136 @@
     cleanup();
     BSTRNOTHROW Args = { this, 0, 0, S_OK };
-    RTStrFormatV(printfOutputCallbackNoThrow, this, NULL, NULL, pszFormat, va);
+    RTStrFormatV(printfOutputCallbackNoThrow, &Args, NULL, NULL, pszFormat, va);
     if (Args.hrc == S_OK)
     {
-#ifdef RT_OS_WINDOWS
-        if (Args.offDst + 1 == Args.cwcAlloc)
+        Args.hrc = joltNoThrow(Args.offDst);
+        if (Args.hrc == S_OK)
             return S_OK;
-
-        /* Official way: Reallocate the string.   We could of course just update the size-prefix if we dare... */
-        if (SysReAllocStringLen(&m_bstr, NULL, (unsigned)(Args.offDst + 1)))
-            return S_OK;
-        AssertMsgFailed(("offDst=%#zx\n", Args.offDst));
-        Args.hrc = E_OUTOFMEMORY;
-#else
-        return S_OK;
-#endif
     }
     cleanup();
@@ -244 +229 @@
 
 
+#ifndef VBOX_WITH_XPCOM
+
+HRESULT Bstr::joltNoThrow(ssize_t cwcNew /* = -1*/)
+{
+    if (m_bstr)
+    {
+        size_t const cwcAlloc  = ::SysStringLen(m_bstr);
+        size_t const cwcActual = cwcNew < 0 ? ::RTUtf16Len(m_bstr) : (size_t)cwcNew;
+        Assert(cwcNew < 0 || cwcActual == ::RTUtf16Len(m_bstr));
+        if (cwcActual != cwcAlloc)
+        {
+            Assert(cwcActual <= cwcAlloc);
+            Assert((unsigned int)cwcActual == cwcActual);
+
+            /* Official way: Reallocate the string.   We could of course just update the size-prefix if we dared... */
+            if (!::SysReAllocStringLen(&m_bstr, NULL, (unsigned int)cwcActual))
+            {
+                AssertFailed();
+                return E_OUTOFMEMORY;
+            }
+        }
+    }
+    else
+        Assert(cwcNew <= 0);
+    return S_OK;
+}
+
+
+void Bstr::jolt(ssize_t cwcNew /* = -1*/)
+{
+    HRESULT hrc = joltNoThrow(cwcNew);
+    if (hrc != S_OK)
+        throw std::bad_alloc();
+}
+
+#endif /* !VBOX_WITH_XPCOM */
+
+
+HRESULT Bstr::reserveNoThrow(size_t cwcMin, bool fForce /*= false*/) RT_NOEXCEPT
+{
+    /* If not forcing the string to the cwcMin length, check cwcMin against the
+       current string length: */
+    if (!fForce)
+    {
+        size_t cwcCur = m_bstr ? ::SysStringLen(m_bstr) : 0;
+        if (cwcCur >= cwcMin)
+            return S_OK;
+    }
+
+    /* The documentation for SysReAllocStringLen hints about it being allergic
+       to NULL in some way or another, so we call SysAllocStringLen directly
+       when appropriate: */
+    if (m_bstr)
+        AssertReturn(::SysReAllocStringLen(&m_bstr, NULL, (unsigned int)cwcMin) != FALSE, E_OUTOFMEMORY);
+    else if (cwcMin > 0)
+    {
+        m_bstr = ::SysAllocStringLen(NULL, (unsigned int)cwcMin);
+        AssertReturn(m_bstr, E_OUTOFMEMORY);
+    }
+
+    return S_OK;
+}
+
+
+void Bstr::reserve(size_t cwcMin, bool fForce /*= false*/)
+{
+    HRESULT hrc = reserveNoThrow(cwcMin, fForce);
+    if (hrc != S_OK)
+        throw std::bad_alloc();
+}
+
+
 /* static */
 const Utf8Str Utf8Str::Empty; /* default ctor is OK */

trunk/src/VBox/Main/testcase/Makefile.kmk

@@ -36 +36 @@
         $(if $(VBOX_WITH_GUEST_CONTROL),tstGuestCtrlContextID,) \
         tstMediumLock \
+        tstBstr \
         tstGuid
   PROGRAMS.linux += \
@@ -254 +255 @@
 
 #
+# tstBstr
+#
+tstBstr_TEMPLATE = VBOXMAINCLIENTTSTEXE
+tstBstr_SOURCES  = tstBstr.cpp
+
+
+#
 # tstGuid
 #