Changeset 21079 in vbox for trunk

Timestamp:

Jun 30, 2009 3:59:22 PM (16 years ago)

Author:

vboxsync

Message:

Main: move libxml2 to IPRT unconditionally (remove VBOX_WITH_LIBXML2_IN_VBOXRT); move xml classes to IPRT; introduce IPRT ministring class as base for both Utf8Str and xml.cpp, with better performance; introduce some Utf8Str helpers to avoid string buffer hacks in Main code; remove std::auto_ptr<> from some headers

Location:

trunk

Files:

• Config.kmk (modified) (3 diffs)
• include/VBox/com/string.h (modified) (16 diffs)
• include/VBox/settings.h (modified) (1 diff)
• include/iprt/xml_cpp.h (moved) (moved from trunk/include/VBox/xml.h ) (7 diffs)
• src/VBox/Main/ApplianceImpl.cpp (modified) (7 diffs)
• src/VBox/Main/ConsoleImpl.cpp (modified) (8 diffs)
• src/VBox/Main/ConsoleImpl2.cpp (modified) (2 diffs)
• src/VBox/Main/MachineImpl.cpp (modified) (6 diffs)
• src/VBox/Main/Makefile.kmk (modified) (1 diff)
• src/VBox/Main/SharedFolderImpl.cpp (modified) (2 diffs)
• src/VBox/Main/VirtualBoxErrorInfoImpl.cpp (modified) (1 diff)
• src/VBox/Main/VirtualBoxImpl.cpp (modified) (1 diff)
• src/VBox/Main/glue/ErrorInfo.cpp (modified) (1 diff)
• src/VBox/Main/glue/VirtualBoxErrorInfo.cpp (modified) (1 diff)
• src/VBox/Main/glue/string.cpp (modified) (3 diffs)
• src/VBox/Main/include/ApplianceImpl.h (modified) (1 diff)
• src/VBox/Main/webservice/vboxweb.cpp (modified) (1 diff)
• src/VBox/Runtime/Makefile.kmk (modified) (7 diffs)
• src/VBox/Runtime/VBox/VBoxRTDeps.cpp (modified) (4 diffs)
• src/VBox/Runtime/r3/xml.cpp (moved) (moved from trunk/src/VBox/Main/xml/xml.cpp ) (4 diffs)
• src/VBox/Runtime/testcase/tstUtf8.cpp (modified) (3 diffs)

trunk/Config.kmk

@@ -490 +490 @@
 ## Use the new version of liblzf. Remove with the old liblzf.
 #VBOX_WITH_NEW_LIBLZF = 1
-## For experimenting with linking libxml2 into VBoxRT.
-VBOX_WITH_LIBXML2_IN_VBOXRT = 1
 
 ## For experimenting with disabling preemption instead of interrupts
@@ -1799 +1797 @@
 #
 SDK_VBOX_LIBXML2          = .
-#if1of ($(KBUILD_TARGET),win os2 solaris)
- SDK_VBOX_LIBXML2_INCS   ?= $(PATH_ROOT)/src/libs/libxml2-2.6.30/include
- ifdef VBOX_WITH_LIBXML2_IN_VBOXRT
-  SDK_VBOX_LIBXML2_DEFS  ?= _REENTRANT
- else
-  SDK_VBOX_LIBXML2_DEFS  ?= LIBXML_STATIC _REENTRANT
-  SDK_VBOX_LIBXML2_LIBS  ?= $(PATH_LIB)/VBox-libxml2$(VBOX_SUFF_LIB)
- endif
- SDK_VBOX_LIBXML2_DEFS.win += WIN32 _WINDOWS _MBCS
-#else if1of ($(KBUILD_TARGET),linux)
-# SDK_VBOX_LIBXML2_INCS      ?=
-# SDK_VBOX_LIBXML2_LIBS      ?=
-# SDK_VBOX_LIBXML2_CFLAGS    ?= $(shell pkg-config libxml-2.0 --cflags)
-# SDK_VBOX_LIBXML2_CXXFLAGS  ?= $(SDK_VBOX_LIBXML2_CFLAGS)
-# SDK_VBOX_LIBXML2_LDFLAGS   ?= $(shell pkg-config libxml-2.0 --libs)
-#else
-# SDK_VBOX_LIBXML2_INCS   ?=
-# SDK_VBOX_LIBXML2_LIBS   ?= xml2
-#endif
+SDK_VBOX_LIBXML2_INCS   ?= $(PATH_ROOT)/src/libs/libxml2-2.6.30/include
+SDK_VBOX_LIBXML2_DEFS  ?= _REENTRANT
+SDK_VBOX_LIBXML2_DEFS.win += WIN32 _WINDOWS _MBCS
+# note: no linking to LIB here, we do that explicitly in src/VBox/Runtime/Makefile.kmk to link
+# libxml against VBoxRT
 
 SDK_VBOX_LIBXSLT          = .
@@ -1853 +1837 @@
 SDK_VBOX_OPENSSL_INCS ?= $(SDK_VBOX_OPENSSL_VBOX_DEFAULT_INCS)
 SDK_VBOX_OPENSSL_ORDERDEPS ?= $(crypto-headers_1_TARGET)
-ifndef VBOX_WITH_LIBXML2_IN_VBOXRT
- SDK_VBOX_OPENSSL_LIBS ?= $(PATH_LIB)/VBox-libcrypto$(VBOX_SUFF_LIB)
-endif
+SDK_VBOX_OPENSSL_LIBS ?= $(PATH_LIB)/VBox-libcrypto$(VBOX_SUFF_LIB)
 # Build entire openssl library, not just the minimal subset.
 if1of ($(KBUILD_TARGET), linux solaris)

trunk/include/VBox/com/string.h

@@ -49 +49 @@
 #include "VBox/com/assert.h"
 
-#include <iprt/string.h>
 #include <iprt/cpputils.h>
 #include <iprt/alloc.h>
+#include <iprt/ministring_cpp.h>
 
 namespace com
@@ -153 +153 @@
     }
 
-    bool operator == (const Bstr &that) const { return !compare (that.bstr); }
-    bool operator != (const Bstr &that) const { return !!compare (that.bstr); }
-    bool operator == (CBSTR that) const { return !compare (that); }
-    bool operator == (BSTR that) const { return !compare (that); }
+    bool operator==(const Bstr &that) const { return !compare (that.bstr); }
+    bool operator!=(const Bstr &that) const { return !!compare (that.bstr); }
+    bool operator==(CBSTR that) const { return !compare (that); }
+    bool operator==(BSTR that) const { return !compare (that); }
 
 #if defined (VBOX_WITH_XPCOM)
-    bool operator != (const wchar_t *that) const
+    bool operator!=(const wchar_t *that) const
     {
         AssertCompile (sizeof (wchar_t) == sizeof (OLECHAR));
         return !!compare ((CBSTR) that);
     }
-    bool operator == (const wchar_t *that) const
+    bool operator==(const wchar_t *that) const
     {
         AssertCompile (sizeof (wchar_t) == sizeof (OLECHAR));
@@ -171 +171 @@
 #endif
 
-    bool operator != (CBSTR that) const { return !!compare (that); }
-    bool operator != (BSTR that) const { return !!compare (that); }
-    bool operator < (const Bstr &that) const { return compare (that.bstr) < 0; }
-    bool operator < (CBSTR that) const { return compare (that) < 0; }
-    bool operator < (BSTR that) const { return compare (that) < 0; }
+    bool operator!=(CBSTR that) const { return !!compare (that); }
+    bool operator!=(BSTR that) const { return !!compare (that); }
+    bool operator<(const Bstr &that) const { return compare (that.bstr) < 0; }
+    bool operator<(CBSTR that) const { return compare (that) < 0; }
+    bool operator<(BSTR that) const { return compare (that) < 0; }
 #if defined (VBOX_WITH_XPCOM)
-    bool operator < (const wchar_t *that) const
+    bool operator<(const wchar_t *that) const
     {
         AssertCompile (sizeof (wchar_t) == sizeof (OLECHAR));
@@ -303 +303 @@
 
 /* symmetric compare operators */
-inline bool operator== (CBSTR l, const Bstr &r) { return r.operator== (l); }
-inline bool operator!= (CBSTR l, const Bstr &r) { return r.operator!= (l); }
-inline bool operator== (BSTR l, const Bstr &r) { return r.operator== (l); }
-inline bool operator!= (BSTR l, const Bstr &r) { return r.operator!= (l); }
+inline bool operator==(CBSTR l, const Bstr &r) { return r.operator== (l); }
+inline bool operator!=(CBSTR l, const Bstr &r) { return r.operator!= (l); }
+inline bool operator==(BSTR l, const Bstr &r) { return r.operator== (l); }
+inline bool operator!=(BSTR l, const Bstr &r) { return r.operator!= (l); }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -324 +324 @@
  *    afterwards.
  */
-class Utf8Str
+class Utf8Str : public ministring
 {
 public:
 
-    enum CaseSensitivity
-    {
-        CaseSensitive,
-        CaseInsensitive
-    };
-
-    typedef char *String;
-    typedef const char *ConstString;
-
-    Utf8Str () : str (NULL) {}
-
-    Utf8Str (const Utf8Str &that) : str (NULL) { raw_copy (str, that.str); }
-    Utf8Str (const char *that) : str (NULL) { raw_copy (str, that); }
-
-    Utf8Str (const Bstr &that) : str (NULL) { raw_copy (str, that); }
-    Utf8Str (CBSTR that) : str (NULL) { raw_copy (str, that); }
-
-    /** Shortcut that calls #alloc(aSize) right after object creation. */
-    Utf8Str (size_t aSize) : str (NULL) { alloc(aSize); }
-
-    virtual ~Utf8Str () { setNull(); }
-
-    Utf8Str &operator = (const Utf8Str &that) { safe_assign (that.str); return *this; }
-    Utf8Str &operator = (const char *that) { safe_assign (that); return *this; }
-
-    Utf8Str &operator = (const Bstr &that)
-    {
-        setNull();
-        raw_copy (str, that);
-        return *this;
-    }
-    Utf8Str &operator = (CBSTR that)
-    {
-        setNull();
-        raw_copy (str, that);
-        return *this;
-    }
-
-    Utf8Str &setNull()
-    {
-        if (str)
-        {
-#if !defined (VBOX_WITH_XPCOM)
-            ::RTStrFree (str);
-#else
-            nsMemory::Free (str);
-#endif
-            str = NULL;
-        }
-        return *this;
-    }
-
-    Utf8Str &setNullIfEmpty()
-    {
-        if (str && *str == 0)
-        {
-#if !defined (VBOX_WITH_XPCOM)
-            ::RTStrFree (str);
-#else
-            nsMemory::Free (str);
-#endif
-            str = NULL;
-        }
-        return *this;
-    }
-
-    /**
-     *  Allocates memory for a string capable to store \a aSize - 1 bytes (not characters!);
-     *  in other words, aSize includes the terminating zero character. If \a aSize
-     *  is zero, or if a memory allocation error occurs, this object will become null.
-     */
-    Utf8Str &alloc (size_t aSize)
-    {
-        setNull();
-        if (aSize)
-        {
-#if !defined (VBOX_WITH_XPCOM)
-            str = (char *) ::RTMemTmpAlloc (aSize);
-#else
-            str = (char *) nsMemory::Alloc (aSize);
-#endif
-            if (str)
-                str [0] = 0;
-        }
-        return *this;
-    }
-
-    void append(const Utf8Str &that)
-    {
-        size_t cbThis = length();
-        size_t cbThat = that.length();
-
-        if (cbThat)
-        {
-            size_t cbBoth = cbThis + cbThat + 1;
-
-            // @todo optimize with realloc() once the memory management is fixed
-            char *pszTemp;
-#if !defined (VBOX_WITH_XPCOM)
-            pszTemp = (char*)::RTMemTmpAlloc(cbBoth);
-#else
-            pszTemp = (char*)nsMemory::Alloc(cbBoth);
-#endif
-            if (str)
-            {
-                memcpy(pszTemp, str, cbThis);
-                setNull();
-            }
-            if (that.str)
-                memcpy(pszTemp + cbThis, that.str, cbThat);
-            pszTemp[cbThis + cbThat] = '\0';
-
-            str = pszTemp;
-        }
-    }
-
-    int compare (const char *pcsz, CaseSensitivity cs = CaseSensitive) const
-    {
-        if (str == pcsz)
-            return 0;
-        if (str == NULL)
-            return -1;
-        if (pcsz == NULL)
-            return 1;
-
-        if (cs == CaseSensitive)
-            return ::RTStrCmp(str, pcsz);
-        else
-            return ::RTStrICmp(str, pcsz);
-    }
-
-    int compare (const Utf8Str &that, CaseSensitivity cs = CaseSensitive) const
-    {
-        return compare (that.str, cs);
-    }
-
-    bool operator == (const Utf8Str &that) const { return !compare (that); }
-    bool operator != (const Utf8Str &that) const { return !!compare (that); }
-    bool operator == (const char *that) const { return !compare (that); }
-    bool operator != (const char *that) const { return !!compare (that); }
-    bool operator < (const Utf8Str &that) const { return compare (that) < 0; }
-    bool operator < (const char *that) const { return compare (that) < 0; }
-
-    bool endsWith (const Utf8Str &that, CaseSensitivity cs = CaseSensitive) const
-    {
-        if (isNull() || that.isNull())
-            return false;
-
-        size_t l1 = length();
-        size_t l2 = that.length();
-        if (l1 < l2)
-            return false;
-
-        size_t l = l1 - l2;
-        if (cs == CaseSensitive)
-            return ::RTStrCmp(&str[l], that.str) == 0;
-        else
-            return ::RTStrICmp(&str[l], that.str) == 0;
-    }
-
-    bool startsWith (const Utf8Str &that, CaseSensitivity cs = CaseSensitive) const
-    {
-        if (isNull() || that.isNull())
-            return false;
-
-        size_t l1 = length();
-        size_t l2 = that.length();
-        if (l1 < l2)
-            return false;
-
-        if (cs == CaseSensitive)
-            return ::RTStrNCmp(str, that.str, l2) == 0;
-        else
-            return ::RTStrNICmp(str, that.str, l2) == 0;
-    }
-
-    bool contains (const Utf8Str &that, CaseSensitivity cs = CaseSensitive) const
-    {
-        if (cs == CaseSensitive)
-            return ::RTStrStr (str, that.str) != NULL;
-        else
-            return ::RTStrIStr (str, that.str) != NULL;
-    }
-
-    Utf8Str& toLower()
-    {
-        if (isEmpty())
-            return *this;
-
-        ::RTStrToLower(str);
-
-        return *this;
-    }
-
-    Utf8Str& toUpper()
-    {
-        if (isEmpty())
-            return *this;
-
-        ::RTStrToUpper(str);
-
-        return *this;
-    }
-
-    bool isNull() const { return str == NULL; }
-    operator bool() const { return !isNull(); }
-
-    bool isEmpty() const { return isNull() || *str == 0; }
-
-    size_t length() const { return isNull() ? 0 : ::strlen (str); }
-
-    /** Intended to to pass instances as input (|char *|) parameters to methods. */
-    operator const char *() const { return str; }
-
-    /** The same as operator const char *(), but for situations where the compiler
-        cannot typecast implicitly (for example, in printf() argument list). */
-    const char *raw() const { return str; }
-
-    /** The same as operator const char *(), but for situations where the compiler
-        cannot typecast implicitly (for example, in printf() argument list). */
-    const char *c_str() const { return str; }
-
-    /**
-     *  Returns a non-const raw pointer that allows to modify the string directly.
-     *  @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.
-     */
-    char *mutableRaw() { return str; }
+    Utf8Str() {}
+
+    Utf8Str(const Utf8Str &that)
+        : ministring(that)
+    {}
+
+    Utf8Str(const char *that)
+        : ministring(that)
+    {}
+
+    Utf8Str(const Bstr &that)
+    {
+        copyFrom(that);
+    }
+
+    Utf8Str(CBSTR that)
+    {
+        copyFrom(that);
+    }
+
+    Utf8Str& operator=(const Utf8Str &that)
+    {
+        ministring::operator=(that);
+        return *this;
+    }
+
+    Utf8Str& operator=(const char *that)
+    {
+        ministring::operator=(that);
+        return *this;
+    }
+
+    Utf8Str& operator=(const Bstr &that)
+    {
+        cleanup();
+        copyFrom(that);
+        return *this;
+    }
+
+    Utf8Str& operator=(CBSTR that)
+    {
+        cleanup();
+        copyFrom(that);
+        return *this;
+    }
 
     /**
@@ -564 +379 @@
      *  caller.
      */
-    const Utf8Str &cloneTo (char **pstr) const
+    const Utf8Str& cloneTo(char **pstr) const
     {
         if (pstr)
-        {
-            *pstr = NULL;
-            raw_copy (*pstr, str);
-        }
+            *pstr = RTStrDup(m_psz);
         return *this;
     }
@@ -582 +394 @@
      *  string.
      */
-    Utf8Str &detachTo (char **pstr)
-    {
-        *pstr = str;
-        str = NULL;
+    Utf8Str& detachTo(char **pstr)
+    {
+        *pstr = m_psz;
+        m_psz = NULL;
+        m_cbAllocated = 0;
+        m_cbLength = 0;
         return *this;
     }
@@ -594 +408 @@
      *  caller.
      */
-    const Utf8Str &cloneTo (BSTR *pstr) const
+    const Utf8Str& cloneTo(BSTR *pstr) const
     {
         if (pstr)
         {
             *pstr = NULL;
-            Bstr::raw_copy (*pstr, str);
+            Bstr::raw_copy(*pstr, m_psz);
         }
         return *this;
@@ -623 +437 @@
 
     /**
-     * Attempts to convert the member string into an 32-bit integer.
+     * Returns true if "this" ends with "that".
+     * @param that
+     * @param cs
+     * @return
+     */
+    bool endsWith(const Utf8Str &that, CaseSensitivity cs = CaseSensitive) const;
+
+    /**
+     * Returns true if "this" begins with "that".
+     * @return
+     */
+    bool startsWith(const Utf8Str &that, CaseSensitivity cs = CaseSensitive) const;
+
+    /**
+     * Returns true if "this" contains "that" (strstr).
+     * @param that
+     * @param cs
+     * @return
+     */
+    bool contains(const Utf8Str &that, CaseSensitivity cs = CaseSensitive) const;
+
+    /**
+     * Converts "this" to lower case by calling RTStrToLower().
+     * @return
+     */
+    Utf8Str& toLower();
+
+    /**
+     * Converts "this" to upper case by calling RTStrToUpper().
+     * @return
+     */
+    Utf8Str& toUpper();
+
+    /**
+     * Removes a trailing slash from the member string, if present.
+     * Calls RTPathStripTrailingSlash() without having to mess with mutableRaw().
+     */
+    void stripTrailingSlash();
+
+    /**
+     * Removes a trailing filename from the member string, if present.
+     * Calls RTPathStripFilename() without having to mess with mutableRaw().
+     */
+    void stripFilename();
+
+    /**
+     * Removes a trailing file name extension from the member string, if present.
+     * Calls RTPathStripExt() without having to mess with mutableRaw().
+     */
+    void stripExt();
+
+    /**
+     * Attempts to convert the member string into a 32-bit integer.
      *
      * @returns 32-bit unsigned number on success.
@@ -630 +496 @@
     int toInt32() const
     {
-        return RTStrToInt32(str);
+        return RTStrToInt32(m_psz);
     }
 
@@ -641 +507 @@
     int toUInt32() const
     {
-        return RTStrToUInt32(str);
+        return RTStrToUInt32(m_psz);
     }
 
@@ -652 +518 @@
     int64_t toInt64() const
     {
-        return RTStrToInt64(str);
+        return RTStrToInt64(m_psz);
     }
 
@@ -663 +529 @@
     uint64_t toUInt64() const
     {
-        return RTStrToUInt64(str);
+        return RTStrToUInt64(m_psz);
     }
 
@@ -684 +550 @@
      *  Takes the ownership of the returned data.
      */
-    char **asOutParam() { setNull(); return &str; }
+    char **asOutParam()
+    {
+        cleanup();
+        return &m_psz;
+    }
 
     /**
@@ -693 +563 @@
 protected:
 
-    void safe_assign (const char *s)
-    {
-        if (str != s)
-        {
-            setNull();
-            raw_copy (str, s);
-        }
-    }
-
-    inline static void raw_copy (char *&ls, const char *rs)
-    {
-        if (rs)
-#if !defined (VBOX_WITH_XPCOM)
-            ::RTStrDupEx (&ls, rs);
-#else
-            ls = (char *) nsMemory::Clone (rs, strlen (rs) + 1);
-#endif
-    }
-
-    inline static void raw_copy (char *&ls, CBSTR rs)
-    {
-        if (rs)
-        {
-#if !defined (VBOX_WITH_XPCOM)
-            ::RTUtf16ToUtf8 ((PRTUTF16) rs, &ls);
-#else
-            char *s = NULL;
-            ::RTUtf16ToUtf8 ((PRTUTF16) rs, &s);
-            raw_copy (ls, s);
-            ::RTStrFree (s);
-#endif
-        }
-    }
-
-    char *str;
+    /**
+     * As with the ministring::copyFrom() variants, this unconditionally
+     * sets the members to a copy of the given other strings and makes
+     * no assumptions about previous contents. This can therefore be used
+     * both in copy constructors, when member variables have no defined
+     * value, and in assignments after having called cleanup().
+     *
+     * This variant converts from a UTF-16 string, most probably from
+     * a Bstr assignment.
+     *
+     * @param rs
+     */
+    void copyFrom(CBSTR s)
+    {
+        if (s)
+        {
+            RTUtf16ToUtf8((PRTUTF16)s, &m_psz);
+            m_cbLength = strlen(m_psz);             // TODO optimize by using a different RTUtf* function
+            m_cbAllocated = m_cbLength + 1;
+        }
+        else
+        {
+            m_cbLength = 0;
+            m_cbAllocated = 0;
+            m_psz = NULL;
+        }
+    }
 
     friend class Bstr; /* to access our raw_copy() */
 };
-
-// symmetric compare operators
-inline bool operator== (const char *l, const Utf8Str &r) { return r.operator== (l); }
-inline bool operator!= (const char *l, const Utf8Str &r) { return r.operator!= (l); }
 
 // work around error C2593 of the stupid MSVC 7.x ambiguity resolver
@@ -760 +618 @@
 }
 
-inline const Bstr &Bstr::cloneTo (char **pstr) const
-{
-    if (pstr) {
-        *pstr = NULL;
-        Utf8Str::raw_copy (*pstr, bstr);
+inline const Bstr& Bstr::cloneTo(char **pstr) const
+{
+    if (pstr)
+    {
+        Utf8Str ustr(*this);
+        ustr.detachTo(pstr);
     }
     return *this;

trunk/include/VBox/settings.h

@@ -31 +31 @@
 #define ___VBox_settings_h
 
+#include <limits>
+
 #include <iprt/cdefs.h>
 #include <iprt/cpputils.h>
-#include <iprt/string.h>
-
-#include <list>
-#include <memory>
-#include <limits>
-
 #include <iprt/time.h>
+#include <iprt/xml_cpp.h>
 
 #include <VBox/com/Guid.h>
-
-#include <VBox/xml.h>
-
-// #include <stdarg.h>
 
 /* these conflict with numeric_digits<>::min and max */

trunk/include/iprt/xml_cpp.h

@@ -4 +4 @@
 
 /*
- * Copyright (C) 2007-2008 Sun Microsystems, Inc.
+ * Copyright (C) 2007-2009 Sun Microsystems, Inc.
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -35 +35 @@
 #else /* IN_RING3 */
 
+#include <list>
+#include <memory>
+
+#include <iprt/ministring_cpp.h>
+
 /** @def IN_VBOXXML_R3
  * Used to indicate whether we're inside the same link module as the
@@ -54 +59 @@
 #endif
 
-/*
- * Shut up MSVC complaining that auto_ptr[_ref] template instantiations (as a
- * result of private data member declarations of some classes below) need to
- * be exported too to in order to be accessible by clients.
- *
- * The alternative is to instantiate a template before the data member
- * declaration with the VBOXXML_CLASS prefix, but the standard disables
- * explicit instantiations in a foreign namespace. In other words, a declaration
- * like:
- *
- *   template class VBOXXML_CLASS std::auto_ptr <Data>;
- *
- * right before the member declaration makes MSVC happy too, but this is not a
- * valid C++ construct (and G++ spits it out). So, for now we just disable the
- * warning and will come back to this problem one day later.
- *
- * We also disable another warning (4275) saying that a DLL-exported class
- * inherits form a non-DLL-exported one (e.g. settings::ENoMemory ->
- * std::bad_alloc). I can't get how it can harm yet.
- */
-#if defined(_MSC_VER)
-#pragma warning (disable:4251)
-#pragma warning (disable:4275)
-#endif
-
 /* Forwards */
 typedef struct _xmlParserInput xmlParserInput;
@@ -90 +70 @@
 {
 
-// Little string class for XML only
+// Exceptions
 //////////////////////////////////////////////////////////////////////////////
 
-class ministring
-{
-public:
-    ministring()
-        : m_psz(NULL)
+/**
+ * Base exception class.
+ */
+class VBOXXML_CLASS Error : public std::exception
+{
+public:
+
+    Error(const char *pcszMessage)
+        : m_s(pcszMessage)
     {
     }
 
-    ministring(const ministring &s)
-        : m_psz(NULL)
+    Error(const Error &s)
+        : std::exception(s),
+          m_s(s.what())
     {
-        copyFrom(s.c_str());
-    }
-
-    ministring(const char *pcsz)
-        : m_psz(NULL)
-    {
-        copyFrom(pcsz);
-    }
-
-    ~ministring()
-    {
-        cleanup();
-    }
-
-    void operator=(const char *pcsz)
-    {
-        cleanup();
-        copyFrom(pcsz);
-    }
-
-    void operator=(const ministring &s)
-    {
-        cleanup();
-        copyFrom(s.c_str());
-    }
-
-    const char* c_str() const
-    {
-        return m_psz;
-    }
-
-private:
-    void cleanup()
-    {
-        if (m_psz)
-        {
-            RTStrFree(m_psz);
-            m_psz = NULL;
-        }
-    }
-
-    void copyFrom(const char *pcsz)
-    {
-        if (pcsz)
-            m_psz = RTStrDup(pcsz);
-    }
-
-
-    char *m_psz;
-};
-
-// Exceptions
-//////////////////////////////////////////////////////////////////////////////
-
-/**
- * Base exception class.
- */
-class VBOXXML_CLASS Error : public std::exception
-{
-public:
-
-    Error(const char *pcszMessage)
-        : m_pcsz(NULL)
-    {
-        copyFrom(pcszMessage);
-    }
-
-    Error(const Error &s)
-        : std::exception(s)
-    {
-        copyFrom(s.what());
     }
 
     virtual ~Error() throw()
     {
-        cleanup();
     }
 
     void operator=(const Error &s)
     {
-        cleanup();
-        copyFrom(s.what());
+        m_s = s.what();
     }
 
     void setWhat(const char *pcszMessage)
     {
-        cleanup();
-        copyFrom(pcszMessage);
+        m_s = pcszMessage;
     }
 
     virtual const char* what() const throw()
     {
-        return m_pcsz;
+        return m_s.c_str();
     }
 
@@ -202 +113 @@
     Error() {};     // hide the default constructor to make sure the extended one above is always used
 
-    void cleanup()
-    {
-        if (m_pcsz)
-        {
-            RTStrFree(m_pcsz);
-            m_pcsz = NULL;
-        }
-    }
-
-    void copyFrom(const char *pcszMessage)
-    {
-        if (pcszMessage)
-            m_pcsz = RTStrDup(pcszMessage);
-    }
-
-    char *m_pcsz;
+    ministring m_s;
 };
 
@@ -468 +364 @@
     /* Obscure class data */
     struct Data;
-    std::auto_ptr <Data> m;
+    Data *m;
 
     /* auto_ptr data doesn't have proper copy semantics */
@@ -495 +391 @@
     /* Obscure class data */
     struct Data;
-    std::auto_ptr <Data> m;
+    Data *m;
 
     /* auto_ptr data doesn't have proper copy semantics */

trunk/src/VBox/Main/ApplianceImpl.cpp

@@ -26 +26 @@
 #include <iprt/file.h>
 #include <iprt/s3.h>
+#include "iprt/xml_cpp.h"
 
 #include <VBox/param.h>
@@ -39 +40 @@
 
 #include "Logging.h"
-
-#include "VBox/xml.h"
 
 using namespace std;
@@ -234 +233 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
-
-static Utf8Str stripFilename(const Utf8Str &strFile)
-{
-    Utf8Str str2(strFile);
-    RTPathStripFilename(str2.mutableRaw());
-    return str2;
-}
 
 static const struct
@@ -2246 +2238 @@
                     /* The disk image has to be on the same place as the OVF file. So
                      * strip the filename out of the full file path. */
-                    Utf8Str strSrcDir = stripFilename(pAppliance->m->strPath);
+                    Utf8Str strSrcDir(pAppliance->m->strPath);
+                    strSrcDir.stripFilename();
 
                     /* Iterate over all given disk images */
@@ -3522 +3515 @@
             const Utf8Str &strTargetFileNameOnly = pDiskEntry->strOvf;
             // target path needs to be composed from where the output OVF is
-            Utf8Str strTargetFilePath = stripFilename(m->strPath);
+            Utf8Str strTargetFilePath(m->strPath);
+            strTargetFilePath.stripFilename();
             strTargetFilePath.append("/");
             strTargetFilePath.append(strTargetFileNameOnly);
@@ -3721 +3715 @@
                 const Utf8Str &strTargetFileNameOnly = (*itH)->strOvf;
                 /* Target path needs to be composed from where the output OVF is */
-                Utf8Str strTargetFilePath = stripFilename(m->strPath);
+                Utf8Str strTargetFilePath(m->strPath);
+                strTargetFilePath.stripFilename();
                 strTargetFilePath.append("/");
                 strTargetFilePath.append(strTargetFileNameOnly);
@@ -4736 +4731 @@
 
             Utf8Str strTargetVmdkName(bstrName);
-            RTPathStripExt(strTargetVmdkName.mutableRaw());
+            strTargetVmdkName.stripExt();
             strTargetVmdkName.append(".vmdk");
 

trunk/src/VBox/Main/ConsoleImpl.cpp

@@ -1073 +1073 @@
     for (unsigned i = 0; i < 10 && (VERR_BUFFER_OVERFLOW == vrc); ++i)
     {
-        Utf8Buf.alloc(cchBuf + 1024);
+        Utf8Buf.reserve(cchBuf + 1024);
         if (Utf8Buf.isNull())
             return E_OUTOFMEMORY;
@@ -1081 +1081 @@
         vrc = mVMMDev->hgcmHostCall ("VBoxGuestPropSvc", ENUM_PROPS_HOST, 3,
                                      &parm[0]);
+        Utf8Buf.jolt();
         if (parm[2].type != VBOX_HGCM_SVC_PARM_32BIT)
             return setError (E_FAIL, tr ("Internal application error"));
@@ -1717 +1718 @@
         {
             Utf8Str dir = stateFilePath;
-            RTPathStripFilename (dir.mutableRaw());
-            if (!RTDirExists (dir))
+            dir.stripFilename();
+            if (!RTDirExists(dir))
             {
                 int vrc = RTDirCreateFullPath (dir, 0777);
@@ -3865 +3866 @@
 
     parm[0].type = VBOX_HGCM_SVC_PARM_PTR;
-    /* To save doing a const cast, we use the mutableRaw() member. */
-    parm[0].u.pointer.addr = Utf8Name.mutableRaw();
+    parm[0].u.pointer.addr = (void*)Utf8Name.c_str();
     /* The + 1 is the null terminator */
     parm[0].u.pointer.size = (uint32_t)Utf8Name.length() + 1;
@@ -3882 +3882 @@
         if (vrc != VERR_NOT_FOUND)
         {
-            size_t iFlags = strlen(pszBuffer) + 1;
-            Utf8Str(pszBuffer).cloneTo (aValue);
+            Utf8Str strBuffer(pszBuffer);
+            strBuffer.cloneTo(aValue);
+
             *aTimestamp = parm[2].u.uint64;
-            Utf8Str(pszBuffer + iFlags).cloneTo (aFlags);
+
+            size_t iFlags = strBuffer.length() + 1;
+            Utf8Str(pszBuffer + iFlags).cloneTo(aFlags);
         }
         else
@@ -3930 +3933 @@
 
     parm[0].type = VBOX_HGCM_SVC_PARM_PTR;
-    /* To save doing a const cast, we use the mutableRaw() member. */
-    parm[0].u.pointer.addr = Utf8Name.mutableRaw();
+    parm[0].u.pointer.addr = (void*)Utf8Name.c_str();
     /* The + 1 is the null terminator */
     parm[0].u.pointer.size = (uint32_t)Utf8Name.length() + 1;
@@ -3938 +3940 @@
     {
         parm[1].type = VBOX_HGCM_SVC_PARM_PTR;
-        /* To save doing a const cast, we use the mutableRaw() member. */
-        parm[1].u.pointer.addr = Utf8Value.mutableRaw();
+        parm[1].u.pointer.addr = (void*)Utf8Value.c_str();
         /* The + 1 is the null terminator */
         parm[1].u.pointer.size = (uint32_t)Utf8Value.length() + 1;
@@ -3947 +3948 @@
     {
         parm[2].type = VBOX_HGCM_SVC_PARM_PTR;
-        /* To save doing a const cast, we use the mutableRaw() member. */
-        parm[2].u.pointer.addr = Utf8Flags.mutableRaw();
+        parm[2].u.pointer.addr = (void*)Utf8Flags.c_str();
         /* The + 1 is the null terminator */
         parm[2].u.pointer.size = (uint32_t)Utf8Flags.length() + 1;

trunk/src/VBox/Main/ConsoleImpl2.cpp

@@ -1814 +1814 @@
         {
             /* Pull over the properties from the server. */
-            SafeArray <BSTR> namesOut;
-            SafeArray <BSTR> valuesOut;
-            SafeArray <ULONG64> timestampsOut;
-            SafeArray <BSTR> flagsOut;
+            SafeArray<BSTR> namesOut;
+            SafeArray<BSTR> valuesOut;
+            SafeArray<ULONG64> timestampsOut;
+            SafeArray<BSTR> flagsOut;
             hrc = pConsole->mControl->PullGuestProperties(ComSafeArrayAsOutParam(namesOut),
                                                 ComSafeArrayAsOutParam(valuesOut),
@@ -1829 +1829 @@
                 rc = VERR_INVALID_PARAMETER;
 
-            std::vector <Utf8Str> utf8Names, utf8Values, utf8Flags;
-            std::vector <char *> names, values, flags;
-            std::vector <ULONG64> timestamps;
+            std::vector<Utf8Str> utf8Names, utf8Values, utf8Flags;
+            std::vector<char *> names, values, flags;
+            std::vector<ULONG64> timestamps;
             for (unsigned i = 0; i < cProps && RT_SUCCESS(rc); ++i)
                 if (   !VALID_PTR(namesOut[i])

trunk/src/VBox/Main/MachineImpl.cpp

@@ -3450 +3450 @@
     AssertReturn (!mData->mConfigFileFull.isNull(), VERR_GENERAL_FAILURE);
 
-    Utf8Str settingsDir = mData->mConfigFileFull;
-
-    RTPathStripFilename (settingsDir.mutableRaw());
-    char folder [RTPATH_MAX];
-    int vrc = RTPathAbsEx (settingsDir, aPath, folder, sizeof (folder));
-    if (RT_SUCCESS (vrc))
+    Utf8Str strSettingsDir = mData->mConfigFileFull;
+
+    strSettingsDir.stripFilename();
+    char folder[RTPATH_MAX];
+    int vrc = RTPathAbsEx(strSettingsDir, aPath, folder, sizeof(folder));
+    if (RT_SUCCESS(vrc))
         aResult = folder;
 
@@ -3483 +3483 @@
     Utf8Str settingsDir = mData->mConfigFileFull;
 
-    RTPathStripFilename (settingsDir.mutableRaw());
-    if (RTPathStartsWith (aPath, settingsDir))
+    settingsDir.stripFilename();
+    if (RTPathStartsWith(aPath, settingsDir))
     {
         /* when assigning, we create a separate Utf8Str instance because both
@@ -3491 +3491 @@
          * first, and since its the same as aPath, an attempt to copy garbage
          * will be made. */
-        aResult = Utf8Str (aPath + settingsDir.length() + 1);
+        aResult = Utf8Str(aPath + settingsDir.length() + 1);
     }
 }
@@ -5949 +5949 @@
             /* first, rename the directory if it matches the machine name */
             configDir = configFile;
-            RTPathStripFilename (configDir.mutableRaw());
+            configDir.stripFilename();
             newConfigDir = configDir;
-            if (RTPathFilename (configDir) == name)
+            if (RTPathFilename(configDir) == name)
             {
-                RTPathStripFilename (newConfigDir.mutableRaw());
+                newConfigDir.stripFilename();
                 newConfigDir = Utf8StrFmt ("%s%c%s",
                     newConfigDir.raw(), RTPATH_DELIMITER, newName.raw());
@@ -6078 +6078 @@
 
         /* ensure the settings directory exists */
-        Utf8Str path = mData->mConfigFileFull;
-        RTPathStripFilename (path.mutableRaw());
-        if (!RTDirExists (path))
-        {
-            vrc = RTDirCreateFullPath (path, 0777);
-            if (RT_FAILURE (vrc))
+        Utf8Str path(mData->mConfigFileFull);
+        path.stripFilename();
+        if (!RTDirExists(path))
+        {
+            vrc = RTDirCreateFullPath(path, 0777);
+            if (RT_FAILURE(vrc))
             {
                 return setError (E_FAIL,
@@ -7655 +7655 @@
  *  @note Not thread safe (must be called from this object's lock).
  */
-bool Machine::isInOwnDir (Utf8Str *aSettingsDir /* = NULL */)
+bool Machine::isInOwnDir(Utf8Str *aSettingsDir /* = NULL */)
 {
     Utf8Str settingsDir = mData->mConfigFileFull;
-    RTPathStripFilename (settingsDir.mutableRaw());
-    char *dirName = RTPathFilename (settingsDir);
+    settingsDir.stripFilename();
+    char *dirName = RTPathFilename(settingsDir);
 
     AssertReturn (dirName, false);

trunk/src/VBox/Main/Makefile.kmk

@@ -519 +519 @@
         include
 VBoxSettings_SOURCES    = \
-        xml/xml.cpp \
         xml/Settings.cpp
 VBoxSettings_LDFLAGS.darwin = -install_name $(VBOX_DYLD_EXECUTABLE_PATH)/$(notdir $(LIB_SETTINGS)) -Wl,-x # no debug info please.

trunk/src/VBox/Main/SharedFolderImpl.cpp

@@ -28 +28 @@
 
 #include <iprt/param.h>
+#include <iprt/cpputils.h>
 #include <iprt/path.h>
-#include <iprt/cpputils.h>
 
 // constructor / destructor
@@ -199 +199 @@
         ;
 #else
-    if (hostPathLen == 1 && RTPATH_IS_SEP (hostPath[0]))
+    if (hostPathLen == 1 && RTPATH_IS_SEP(hostPath[0]))
         ;
 #endif
     else
-        RTPathStripTrailingSlash (hostPath.mutableRaw());
+        hostPath.stripTrailingSlash();
 
     /* Check whether the path is full (absolute) */

trunk/src/VBox/Main/VirtualBoxErrorInfoImpl.cpp

@@ -156 +156 @@
     AssertComRC (rc);
     Utf8Str message;
-    rc = aInfo->GetMessage (message.asOutParam());
+    rc = aInfo->GetMessage(message.asOutParam());
+    message.jolt();
     AssertComRC (rc);
     mText = message;

trunk/src/VBox/Main/VirtualBoxImpl.cpp

@@ -3870 +3870 @@
 HRESULT VirtualBox::ensureFilePathExists (const char *aFileName)
 {
-    Utf8Str dir = aFileName;
-    RTPathStripFilename (dir.mutableRaw());
-    if (!RTDirExists (dir))
-    {
-        int vrc = RTDirCreateFullPath (dir, 0777);
+    Utf8Str strDir(aFileName);
+    strDir.stripFilename();
+    if (!RTDirExists(strDir))
+    {
+        int vrc = RTDirCreateFullPath(strDir, 0777);
         if (RT_FAILURE (vrc))
         {
             return setError (E_FAIL,
                 tr ("Could not create the directory '%s' (%Rrc)"),
-                dir.raw(), vrc);
+                strDir.c_str(), vrc);
         }
     }

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

@@ -118 +118 @@
 
                     Utf8Str message;
-                    rc = ex->GetMessage (message.asOutParam());
+                    rc = ex->GetMessage(message.asOutParam());
+                    message.jolt();
                     gotSomething |= NS_SUCCEEDED (rc);
                     if (NS_SUCCEEDED (rc))

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

@@ -179 +179 @@
     AssertComRC (rc);
     Utf8Str message;
-    rc = aInfo->GetMessage (message.asOutParam());
+    rc = aInfo->GetMessage(message.asOutParam());
+    message.jolt();
     AssertComRC (rc);
     mText = message;

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

@@ -26 +26 @@
 
 #include <iprt/err.h>
+#include <iprt/path.h>
 
 namespace com
@@ -85 +86 @@
 
                 size_t cbCopy = psz - pFirst;
-                ret.alloc(cbCopy + 1);
-                memcpy(ret.str, pFirst, cbCopy);
-                ret.str[cbCopy] = '\0';
+                ret.reserve(cbCopy + 1);
+                memcpy(ret.m_psz, pFirst, cbCopy);
+                ret.m_psz[cbCopy] = '\0';
             }
         }
@@ -95 +96 @@
 }
 
+bool Utf8Str::endsWith(const Utf8Str &that, CaseSensitivity cs /*= CaseSensitive*/) const
+{
+    size_t l1 = length();
+    if (l1 == 0)
+        return false;
+
+    size_t l2 = that.length();
+    if (l1 < l2)
+        return false;
+
+    size_t l = l1 - l2;
+    if (cs == CaseSensitive)
+        return ::RTStrCmp(&m_psz[l], that.m_psz) == 0;
+    else
+        return ::RTStrICmp(&m_psz[l], that.m_psz) == 0;
+}
+
+bool Utf8Str::startsWith(const Utf8Str &that, CaseSensitivity cs /*= CaseSensitive*/) const
+{
+    size_t l1 = length();
+    size_t l2 = that.length();
+    if (l1 == 0 || l2 == 0)
+        return false;
+
+    if (l1 < l2)
+        return false;
+
+    if (cs == CaseSensitive)
+        return ::RTStrNCmp(m_psz, that.m_psz, l2) == 0;
+    else
+        return ::RTStrNICmp(m_psz, that.m_psz, l2) == 0;
+}
+
+bool Utf8Str::contains(const Utf8Str &that, CaseSensitivity cs /*= CaseSensitive*/) const
+{
+    if (cs == CaseSensitive)
+        return ::RTStrStr(m_psz, that.m_psz) != NULL;
+    else
+        return ::RTStrIStr(m_psz, that.m_psz) != NULL;
+}
+
+Utf8Str& Utf8Str::toLower()
+{
+    if (!isEmpty())
+        ::RTStrToLower(m_psz);
+    return *this;
+}
+
+Utf8Str& Utf8Str::toUpper()
+{
+    if (!isEmpty())
+        ::RTStrToUpper(m_psz);
+    return *this;
+}
+
+void Utf8Str::stripTrailingSlash()
+{
+    RTPathStripTrailingSlash(m_psz);
+    jolt();
+}
+
+void Utf8Str::stripFilename()
+{
+    RTPathStripFilename(m_psz);
+    jolt();
+}
+
+void Utf8Str::stripExt()
+{
+    RTPathStripExt(m_psz);
+    jolt();
+}
+
 int Utf8Str::toInt(uint64_t &i) const
 {
-    if (!str)
+    if (!m_psz)
         return VERR_NO_DIGITS;
-    return RTStrToUInt64Ex(str, NULL, 0, &i);
+    return RTStrToUInt64Ex(m_psz, NULL, 0, &i);
 }
 
 int Utf8Str::toInt(uint32_t &i) const
 {
-    if (!str)
+    if (!m_psz)
         return VERR_NO_DIGITS;
-    return RTStrToUInt32Ex(str, NULL, 0, &i);
+    return RTStrToUInt32Ex(m_psz, NULL, 0, &i);
 }
 

trunk/src/VBox/Main/include/ApplianceImpl.h

@@ -92 +92 @@
     const ComObjPtr <VirtualBox, ComWeakRef> mVirtualBox;
 
-    struct Data;            // obscure, defined in AppliannceImpl.cpp
+    struct Data;            // opaque, defined in ApplianceImpl.cpp
     Data *m;
 

trunk/src/VBox/Main/webservice/vboxweb.cpp

@@ -603 +603 @@
  * @return
  */
-std::string ConvertComString(const com::Guid &bstr)
-{
+std::string ConvertComString(const com::Guid &uuid)
+{
+    com::Bstr bstr(uuid);
     com::Utf8Str ustr(bstr);
     const char *pcsz;

trunk/src/VBox/Runtime/Makefile.kmk

@@ -51 +51 @@
  LIBRARIES += RuntimeR3
  DLLS += VBoxRT
-
- # Temporary(?) hack.
- VBOX_WITH_LIBXML2_IN_VBOXRT=
 
 else # !VBOX_ONLY_ADDITIONS && !VBOX_ONLY_DOCS
@@ -165 +162 @@
 #
 RuntimeR3_TEMPLATE      = VBOXR3STATIC
+RuntimeR3_SDKS          = VBOX_LIBXML2
 RuntimeR3_SDKS.win      = WINPSDK W2K3DDK
 RuntimeR3_DEFS          = IN_RT_R3 IN_SUP_R3 LDR_WITH_NATIVE LDR_WITH_ELF32 LDR_WITH_PE RT_WITH_VBOX RT_NO_GIP
@@ -306 +304 @@
         r3/test.cpp \
         r3/testi.cpp \
-        r3/tcp.cpp
+        r3/tcp.cpp \
+        r3/xml.cpp
 
 #if1of ($(KBUILD_TARGET_ARCH),amd64 x86)
@@ -787 +786 @@
 #
 VBoxRT_TEMPLATE                = VBOXR3
-ifdef VBOX_WITH_LIBXML2_IN_VBOXRT
 VBoxRT_SDKS                    = VBOX_OPENSSL VBOX_LIBXML2 VBOX_LIBCURL
-endif
 VBoxRT_SDKS.win                = WINPSDK W2K3DDK VBOX_NTDLL
 ifeq ($(KBUILD_TARGET)$(VBOX_WITH_HARDENING),darwin)
@@ -799 +796 @@
         VBox/VBoxRTDeps.cpp \
         $(RuntimeR3_SOURCES)
-if defined(VBOX_WITH_LIBXML2_IN_VBOXRT)
 VBoxRT_SOURCES                += \
         common/misc/s3.cpp
-endif
 VBoxRT_SOURCES.$(KBUILD_TARGET) = $(RuntimeR3_SOURCES.$(KBUILD_TARGET))
 VBoxRT_SOURCES.$(KBUILD_TARGET).$(KBUILD_TARGET_ARCH) = $(RuntimeR3_SOURCES.$(KBUILD_TARGET).$(KBUILD_TARGET_ARCH))
@@ -818 +813 @@
         $(PATH_LIB)/VBox-kStuff$(VBOX_SUFF_LIB)
 endif
-ifdef VBOX_WITH_LIBXML2_IN_VBOXRT
- ifndef SDK_VBOX_LIBXML2_LIBS
-  VBoxRT_LIBS                 += \
+ifndef  SDK_VBOX_LIBXML2_LIBS
+ VBoxRT_LIBS                 += \
         $(PATH_LIB)/VBox-libxml2$(VBOX_SUFF_LIB)
- endif
- ifndef SDK_VBOX_OPENSSL_LIBS
-  VBoxRT_LIBS                 += \
+endif
+ifndef  SDK_VBOX_OPENSSL_LIBS
+ VBoxRT_LIBS                 += \
         $(PATH_LIB)/VBox-libcrypto$(VBOX_SUFF_LIB)
- endif
 endif
 VBoxRT_LIBS.darwin             = \
@@ -851 +844 @@
         $(PATH_LIB)/RuntimeR3L4$(VBOX_SUFF_LIB)
 
-ifdef VBOX_WITH_LIBXML2_IN_VBOXRT
-VBox/VBoxRTDeps.cpp_DEFS = VBOX_WITH_LIBXML2_IN_VBOXRT
-endif
-
 if1of ($(DLLS), VBoxRT)
 $$(VBoxRT_0_OUTDIR)/VBoxRT.def: \
                 $(PATH_SUB_CURRENT)/r3/win/VBoxRT-$$(if-expr $$(KBUILD_TARGET_ARCH) == amd64,win64,win32).def \
-                $(if-expr defined(VBOX_WITH_LIBXML2_IN_VBOXRT),$(PATH_SUB_CURRENT)/r3/win/$(if $(VBOX_OSE),VBoxRT-openssl-ose.def,VBoxRT-openssl.def),)
+                $(PATH_SUB_CURRENT)/r3/win/$(if $(VBOX_OSE),VBoxRT-openssl-ose.def,VBoxRT-openssl.def)
         $(RM) -f -- $@
         $(REDIRECT) -wto $@ -- $(CAT_EXT) $^

trunk/src/VBox/Runtime/VBox/VBoxRTDeps.cpp

@@ -36 +36 @@
 #include <iprt/assert.h>
 #include <iprt/asm.h>
-#ifdef VBOX_WITH_LIBXML2_IN_VBOXRT
+
 # include <libxml/xmlmodule.h>
 # include <libxml/globals.h>
@@ -44 +44 @@
 # include <openssl/x509.h>
 # include <openssl/rsa.h>
-#endif
 
 
@@ -55 +54 @@
     (PFNRT)SUPR3PageAllocEx,
     (PFNRT)SUPSemEventCreate,
-#ifdef VBOX_WITH_LIBXML2_IN_VBOXRT
     (PFNRT)xmlModuleOpen,
     (PFNRT)MD5_Init,
@@ -65 +63 @@
     (PFNRT)i2d_X509,
     (PFNRT)RSA_generate_key,
-#endif
     (PFNRT)RTAssertShouldPanic,
     (PFNRT)ASMAtomicReadU64,

trunk/src/VBox/Runtime/r3/xml.cpp

@@ -19 +19 @@
  */
 
-#include "Logging.h"
-
 #include <iprt/cdefs.h>
 #include <iprt/err.h>
 #include <iprt/file.h>
 #include <iprt/lock.h>
-#include <iprt/string.h>
+#include <iprt/xml_cpp.h>
 
 #include <libxml/tree.h>
@@ -36 +34 @@
 #include <libxml/xmlschemas.h>
 
-#include <list>
 #include <map>
 #include <boost/shared_ptr.hpp>
-
-#include "VBox/xml.h"
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -991 +986 @@
 {
     m->copyFrom(x.m);
-};
+}
 
 Document& Document::operator=(const Document &x)
@@ -998 +993 @@
     m->copyFrom(x.m);
     return *this;
-};
+}
 
 Document::~Document()

trunk/src/VBox/Runtime/testcase/tstUtf8.cpp

@@ -42 +42 @@
 #include <iprt/err.h>
 #include <iprt/test.h>
+#include <iprt/ministring_cpp.h>
 
 #include <stdlib.h> /** @todo use our random. */
@@ -926 +927 @@
 
 
+void testMinistring(RTTEST hTest)
+{
+    RTTestSub(hTest, "class ministring");
+
+#define CHECK(expr) \
+    do { \
+        if (!(expr)) \
+            RTTestFailed(hTest, "%d: FAILED %s", __LINE__, #expr); \
+    } while (0)
+
+#define CHECK_DUMP(expr, value) \
+    do { \
+        if (!(expr)) \
+            RTTestFailed(hTest, "%d: FAILED %s, got \"%s\"", __LINE__, #expr, value); \
+    } while (0)
+
+#define CHECK_DUMP_I(expr) \
+    do { \
+        if (!(expr)) \
+            RTTestFailed(hTest, "%d: FAILED %s, got \"%d\"", __LINE__, #expr, expr); \
+    } while (0)
+
+    ministring empty;
+    CHECK( (empty.length() == 0) );
+    CHECK( (empty.capacity() == 0) );
+
+    ministring sixbytes("12345");
+    CHECK( (sixbytes.length() == 5) );
+    CHECK( (sixbytes.capacity() == 6) );
+
+    sixbytes.append("678");
+    CHECK( (sixbytes.length() == 8) );
+    CHECK( (sixbytes.capacity() == 9) );
+
+    char *psz = sixbytes.mutableRaw();
+        // 12345678
+        //       ^
+        // 0123456
+    psz[6] = '\0';
+    sixbytes.jolt();
+    CHECK( (sixbytes.length() == 6) );
+    CHECK( (sixbytes.capacity() == 7) );
+
+    ministring morebytes("tobereplaced");
+    morebytes = "newstring ";
+    morebytes.append(sixbytes);
+
+    CHECK_DUMP( (morebytes == "newstring 123456"), morebytes.c_str() );
+
+    ministring third(morebytes);
+    third.reserve(100 * 1024);      // 100 KB
+    CHECK_DUMP( (third == "newstring 123456"), morebytes.c_str() );
+    CHECK( (third.capacity() == 100 * 1024) );
+    CHECK( (third.length() == morebytes.length()) );        // must not have changed
+
+    ministring copy1(morebytes);
+    ministring copy2 = morebytes;
+    CHECK( (copy1 == copy2) );
+
+    copy1 = NULL;
+    CHECK( (copy1.isNull()) );
+
+    copy1 = "";
+    CHECK( (copy1.isEmpty()) );
+
+    CHECK( (ministring("abc") < ministring("def")) );
+    CHECK( (ministring("abc") != ministring("def")) );
+    CHECK_DUMP_I( (ministring("def") > ministring("abc")) );
+
+    copy2.setNull();
+    for (int i = 0;
+         i < 100;
+         ++i)
+    {
+        copy2.reserve(50);      // should be ignored after 50 loops
+        copy2.append("1");
+    }
+    CHECK( (copy2.length() == 100) );
+
+#undef CHECK
+}
+
 int main()
 {
@@ -946 +1029 @@
     TstRTStrXCmp(hTest);
     testStrStr(hTest);
+
+    testMinistring(hTest);
+
     Benchmarks(hTest);