Changeset 21077 in vbox

Timestamp:

Jun 30, 2009 3:19:12 PM (15 years ago)

Author:

vboxsync

Message:

back out r49329, r49331, will start over

Location:

trunk

Files:

• Config.kmk (modified) (3 diffs)
• include/VBox/com/string.h (modified) (16 diffs)
• include/VBox/settings.h (modified) (1 diff)
• include/VBox/xml.h (modified) (1 diff)
• 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) (2 diffs)
• 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/Main/xml/xml.cpp (modified) (1 diff)
• src/VBox/Runtime/Makefile.kmk (modified) (7 diffs)
• src/VBox/Runtime/VBox/VBoxRTDeps.cpp (modified) (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
@@ -1797 +1799 @@
 #
 SDK_VBOX_LIBXML2          = .
-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
+#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_LIBXSLT          = .
@@ -1837 +1853 @@
 SDK_VBOX_OPENSSL_INCS ?= $(SDK_VBOX_OPENSSL_VBOX_DEFAULT_INCS)
 SDK_VBOX_OPENSSL_ORDERDEPS ?= $(crypto-headers_1_TARGET)
-SDK_VBOX_OPENSSL_LIBS ?= $(PATH_LIB)/VBox-libcrypto$(VBOX_SUFF_LIB)
+ifndef VBOX_WITH_LIBXML2_IN_VBOXRT
+ SDK_VBOX_OPENSSL_LIBS ?= $(PATH_LIB)/VBox-libcrypto$(VBOX_SUFF_LIB)
+endif
 # 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 : public ministring
+class Utf8Str
 {
 public:
 
-    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;
-    }
+    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; }
 
     /**
@@ -379 +564 @@
      *  caller.
      */
-    const Utf8Str& cloneTo(char **pstr) const
+    const Utf8Str &cloneTo (char **pstr) const
     {
         if (pstr)
-            *pstr = RTStrDup(m_psz);
+        {
+            *pstr = NULL;
+            raw_copy (*pstr, str);
+        }
         return *this;
     }
@@ -394 +582 @@
      *  string.
      */
-    Utf8Str& detachTo(char **pstr)
-    {
-        *pstr = m_psz;
-        m_psz = NULL;
-        m_cbAllocated = 0;
-        m_cbLength = 0;
+    Utf8Str &detachTo (char **pstr)
+    {
+        *pstr = str;
+        str = NULL;
         return *this;
     }
@@ -408 +594 @@
      *  caller.
      */
-    const Utf8Str& cloneTo(BSTR *pstr) const
+    const Utf8Str &cloneTo (BSTR *pstr) const
     {
         if (pstr)
         {
             *pstr = NULL;
-            Bstr::raw_copy(*pstr, m_psz);
+            Bstr::raw_copy (*pstr, str);
         }
         return *this;
@@ -437 +623 @@
 
     /**
-     * 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.
+     * Attempts to convert the member string into an 32-bit integer.
      *
      * @returns 32-bit unsigned number on success.
@@ -496 +630 @@
     int toInt32() const
     {
-        return RTStrToInt32(m_psz);
+        return RTStrToInt32(str);
     }
 
@@ -507 +641 @@
     int toUInt32() const
     {
-        return RTStrToUInt32(m_psz);
+        return RTStrToUInt32(str);
     }
 
@@ -518 +652 @@
     int64_t toInt64() const
     {
-        return RTStrToInt64(m_psz);
+        return RTStrToInt64(str);
     }
 
@@ -529 +663 @@
     uint64_t toUInt64() const
     {
-        return RTStrToUInt64(m_psz);
+        return RTStrToUInt64(str);
     }
 
@@ -550 +684 @@
      *  Takes the ownership of the returned data.
      */
-    char **asOutParam()
-    {
-        cleanup();
-        return &m_psz;
-    }
+    char **asOutParam() { setNull(); return &str; }
 
     /**
@@ -563 +693 @@
 protected:
 
-    /**
-     * 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;
-        }
-    }
+    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;
 
     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
@@ -618 +760 @@
 }
 
-inline const Bstr& Bstr::cloneTo(char **pstr) const
-{
-    if (pstr)
-    {
-        Utf8Str ustr(*this);
-        ustr.detachTo(pstr);
+inline const Bstr &Bstr::cloneTo (char **pstr) const
+{
+    if (pstr) {
+        *pstr = NULL;
+        Utf8Str::raw_copy (*pstr, bstr);
     }
     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/VBox/xml.h

@@ +1 @@
+/** @file
+ * VirtualBox XML helper APIs.
+ */
+
+/*
+ * Copyright (C) 2007-2008 Sun Microsystems, Inc.
+ *
+ * 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.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
+ * Clara, CA 95054 USA or visit http://www.sun.com if you need
+ * additional information or have any questions.
+ */
+
+#ifndef ___VBox_vboxxml_h
+#define ___VBox_vboxxml_h
+
+#ifndef IN_RING3
+# error "There are no XML APIs available in Ring-0 Context!"
+#else /* IN_RING3 */
+
+/** @def IN_VBOXXML_R3
+ * Used to indicate whether we're inside the same link module as the
+ * XML Settings File Manipulation API.
+ *
+ * @todo should go to a separate common include together with VBOXXML2_CLASS
+ * once there becomes more than one header in the VBoxXML2 library.
+ */
+#ifdef DOXYGEN_RUNNING
+# define IN_VBOXXML_R3
+#endif
+
+/** @def VBOXXML_CLASS
+ * Class export/import wrapper. */
+#ifdef IN_VBOXXML_R3
+# define VBOXXML_CLASS DECLEXPORT_CLASS
+#else
+# define VBOXXML_CLASS DECLIMPORT_CLASS
+#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;
+typedef xmlParserInput *xmlParserInputPtr;
+typedef struct _xmlParserCtxt xmlParserCtxt;
+typedef xmlParserCtxt *xmlParserCtxtPtr;
+typedef struct _xmlError xmlError;
+typedef xmlError *xmlErrorPtr;
+
+namespace xml
+{
+
+// Little string class for XML only
+//////////////////////////////////////////////////////////////////////////////
+
+class ministring
+{
+public:
+    ministring()
+        : m_psz(NULL)
+    {
+    }
+
+    ministring(const ministring &s)
+        : m_psz(NULL)
+    {
+        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());
+    }
+
+    void setWhat(const char *pcszMessage)
+    {
+        cleanup();
+        copyFrom(pcszMessage);
+    }
+
+    virtual const char* what() const throw()
+    {
+        return m_pcsz;
+    }
+
+private:
+    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;
+};
+
+class VBOXXML_CLASS LogicError : public Error
+{
+public:
+
+    LogicError(const char *aMsg = NULL)
+        : xml::Error(aMsg)
+    {}
+
+    LogicError(RT_SRC_POS_DECL);
+};
+
+class VBOXXML_CLASS RuntimeError : public Error
+{
+public:
+
+    RuntimeError(const char *aMsg = NULL)
+        : xml::Error(aMsg)
+    {}
+};
+
+class VBOXXML_CLASS XmlError : public RuntimeError
+{
+public:
+    XmlError(xmlErrorPtr aErr);
+
+    static char *Format(xmlErrorPtr aErr);
+};
+
+// Logical errors
+//////////////////////////////////////////////////////////////////////////////
+
+class VBOXXML_CLASS ENotImplemented : public LogicError
+{
+public:
+    ENotImplemented(const char *aMsg = NULL) : LogicError(aMsg) {}
+    ENotImplemented(RT_SRC_POS_DECL) : LogicError(RT_SRC_POS_ARGS) {}
+};
+
+class VBOXXML_CLASS EInvalidArg : public LogicError
+{
+public:
+    EInvalidArg(const char *aMsg = NULL) : LogicError(aMsg) {}
+    EInvalidArg(RT_SRC_POS_DECL) : LogicError(RT_SRC_POS_ARGS) {}
+};
+
+class VBOXXML_CLASS EDocumentNotEmpty : public LogicError
+{
+public:
+    EDocumentNotEmpty(const char *aMsg = NULL) : LogicError(aMsg) {}
+    EDocumentNotEmpty(RT_SRC_POS_DECL) : LogicError(RT_SRC_POS_ARGS) {}
+};
+
+class VBOXXML_CLASS ENodeIsNotElement : public LogicError
+{
+public:
+    ENodeIsNotElement(const char *aMsg = NULL) : LogicError(aMsg) {}
+    ENodeIsNotElement(RT_SRC_POS_DECL) : LogicError(RT_SRC_POS_ARGS) {}
+};
+
+// Runtime errors
+//////////////////////////////////////////////////////////////////////////////
+
+class VBOXXML_CLASS ENoMemory : public RuntimeError, public std::bad_alloc
+{
+public:
+    ENoMemory(const char *aMsg = NULL) : RuntimeError (aMsg) {}
+    virtual ~ENoMemory() throw() {}
+};
+
+class VBOXXML_CLASS EIPRTFailure : public RuntimeError
+{
+public:
+
+    EIPRTFailure (int aRC);
+
+    int rc() const { return mRC; }
+
+private:
+    int mRC;
+};
+
+
+/**
+ * The Stream class is a base class for I/O streams.
+ */
+class VBOXXML_CLASS Stream
+{
+public:
+
+    virtual ~Stream() {}
+
+    virtual const char *uri() const = 0;
+
+    /**
+     * Returns the current read/write position in the stream. The returned
+     * position is a zero-based byte offset from the beginning of the file.
+     *
+     * Throws ENotImplemented if this operation is not implemented for the
+     * given stream.
+     */
+    virtual uint64_t pos() const = 0;
+
+    /**
+     * Sets the current read/write position in the stream.
+     *
+     * @param aPos Zero-based byte offset from the beginning of the stream.
+     *
+     * Throws ENotImplemented if this operation is not implemented for the
+     * given stream.
+     */
+    virtual void setPos (uint64_t aPos) = 0;
+};
+
+/**
+ * The Input class represents an input stream.
+ *
+ * This input stream is used to read the settings tree from.
+ * This is an abstract class that must be subclassed in order to fill it with
+ * useful functionality.
+ */
+class VBOXXML_CLASS Input : virtual public Stream
+{
+public:
+
+    /**
+     * Reads from the stream to the supplied buffer.
+     *
+     * @param aBuf Buffer to store read data to.
+     * @param aLen Buffer length.
+     *
+     * @return Number of bytes read.
+     */
+    virtual int read (char *aBuf, int aLen) = 0;
+};
+
+/**
+ *
+ */
+class VBOXXML_CLASS Output : virtual public Stream
+{
+public:
+
+    /**
+     * Writes to the stream from the supplied buffer.
+     *
+     * @param aBuf Buffer to write data from.
+     * @param aLen Buffer length.
+     *
+     * @return Number of bytes written.
+     */
+    virtual int write (const char *aBuf, int aLen) = 0;
+
+    /**
+     * Truncates the stream from the current position and upto the end.
+     * The new file size will become exactly #pos() bytes.
+     *
+     * Throws ENotImplemented if this operation is not implemented for the
+     * given stream.
+     */
+    virtual void truncate() = 0;
+};
+
+
+//////////////////////////////////////////////////////////////////////////////
+
+/**
+ * The File class is a stream implementation that reads from and writes to
+ * regular files.
+ *
+ * The File class uses IPRT File API for file operations. Note that IPRT File
+ * API is not thread-safe. This means that if you pass the same RTFILE handle to
+ * different File instances that may be simultaneously used on different
+ * threads, you should care about serialization; otherwise you will get garbage
+ * when reading from or writing to such File instances.
+ */
+class VBOXXML_CLASS File : public Input, public Output
+{
+public:
+
+    /**
+     * Possible file access modes.
+     */
+    enum Mode { Mode_Read, Mode_WriteCreate, Mode_Overwrite, Mode_ReadWrite };
+
+    /**
+     * Opens a file with the given name in the given mode. If @a aMode is Read
+     * or ReadWrite, the file must exist. If @a aMode is Write, the file must
+     * not exist. Otherwise, an EIPRTFailure excetion will be thrown.
+     *
+     * @param aMode     File mode.
+     * @param aFileName File name.
+     */
+    File (Mode aMode, const char *aFileName);
+
+    /**
+     * Uses the given file handle to perform file operations. This file
+     * handle must be already open in necessary mode (read, or write, or mixed).
+     *
+     * The read/write position of the given handle will be reset to the
+     * beginning of the file on success.
+     *
+     * Note that the given file handle will not be automatically closed upon
+     * this object destruction.
+     *
+     * @note It you pass the same RTFILE handle to more than one File instance,
+     *       please make sure you have provided serialization in case if these
+     *       instasnces are to be simultaneously used by different threads.
+     *       Otherwise you may get garbage when reading or writing.
+     *
+     * @param aHandle   Open file handle.
+     * @param aFileName File name (for reference).
+     */
+    File (RTFILE aHandle, const char *aFileName = NULL);
+
+    /**
+     * Destroys the File object. If the object was created from a file name
+     * the corresponding file will be automatically closed. If the object was
+     * created from a file handle, it will remain open.
+     */
+    virtual ~File();
+
+    const char *uri() const;
+
+    uint64_t pos() const;
+    void setPos (uint64_t aPos);
+
+    /**
+     * See Input::read(). If this method is called in wrong file mode,
+     * LogicError will be thrown.
+     */
+    int read (char *aBuf, int aLen);
+
+    /**
+     * See Output::write(). If this method is called in wrong file mode,
+     * LogicError will be thrown.
+     */
+    int write (const char *aBuf, int aLen);
+
+    /**
+     * See Output::truncate(). If this method is called in wrong file mode,
+     * LogicError will be thrown.
+     */
+    void truncate();
+
+private:
+
+    /* Obscure class data */
+    struct Data;
+    std::auto_ptr <Data> m;
+
+    /* auto_ptr data doesn't have proper copy semantics */
+    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP (File)
+};
+
+/**
+ * The MemoryBuf class represents a stream implementation that reads from the
+ * memory buffer.
+ */
+class VBOXXML_CLASS MemoryBuf : public Input
+{
+public:
+
+    MemoryBuf (const char *aBuf, size_t aLen, const char *aURI = NULL);
+
+    virtual ~MemoryBuf();
+
+    const char *uri() const;
+
+    int read (char *aBuf, int aLen);
+    uint64_t pos() const;
+    void setPos (uint64_t aPos);
+
+private:
+    /* Obscure class data */
+    struct Data;
+    std::auto_ptr <Data> m;
+
+    /* auto_ptr data doesn't have proper copy semantics */
+    DECLARE_CLS_COPY_CTOR_ASSIGN_NOOP (MemoryBuf)
+};
+
+
+/*
+ * GlobalLock
+ *
+ *
+ */
+
+typedef xmlParserInput* FNEXTERNALENTITYLOADER(const char *aURI,
+                                               const char *aID,
+                                               xmlParserCtxt *aCtxt);
+typedef FNEXTERNALENTITYLOADER *PFNEXTERNALENTITYLOADER;
+
+class VBOXXML_CLASS GlobalLock
+{
+public:
+    GlobalLock();
+    ~GlobalLock();
+
+    void setExternalEntityLoader(PFNEXTERNALENTITYLOADER pFunc);
+
+    static xmlParserInput* callDefaultLoader(const char *aURI,
+                                             const char *aID,
+                                             xmlParserCtxt *aCtxt);
+
+private:
+    /* Obscure class data. */
+    struct Data;
+    struct Data *m;
+};
+
+/**
+ * Node:
+ *  an XML node, which represents either an element or text content
+ *  or an attribute.
+ *
+ *  For elements, getName() returns the element name, and getValue()
+ *  returns the text contents, if any.
+ *
+ *  For attributes, getName() returns the attribute name, and getValue()
+ *  returns the attribute value, if any.
+ *
+ *  Since the default constructor is private, one can create new nodes
+ *  only through factory methods provided by the XML classes. These are:
+ *
+ *  --  xml::Document::createRootElement()
+ *  --  xml::Node::createChild()
+ *  --  xml::Node::addContent()
+ *  --  xml::Node::setAttribute()
+ */
+
+class ElementNode;
+typedef std::list<const ElementNode*> ElementNodesList;
+
+class AttributeNode;
+
+class ContentNode;
+
+class VBOXXML_CLASS Node
+{
+public:
+    ~Node();
+
+    const char* getName() const;
+    const char* getValue() const;
+    bool copyValue(int32_t &i) const;
+    bool copyValue(uint32_t &i) const;
+    bool copyValue(int64_t &i) const;
+    bool copyValue(uint64_t &i) const;
+
+    int getLineNumber() const;
+
+    int isElement()
+    {
+        return mType == IsElement;
+    }
+
+protected:
+    typedef enum {IsElement, IsAttribute, IsContent} EnumType;
+    EnumType mType;
+
+    // hide the default constructor so people use only our factory methods
+    Node(EnumType type);
+    Node(const Node &x);      // no copying
+
+    void buildChildren();
+
+    /* Obscure class data */
+    struct Data;
+    Data *m;
+};
+
+class VBOXXML_CLASS ElementNode : public Node
+{
+public:
+    int getChildElements(ElementNodesList &children,
+                         const char *pcszMatch = NULL) const;
+
+    const ElementNode* findChildElement(const char *pcszMatch) const;
+    const ElementNode* findChildElementFromId(const char *pcszId) const;
+
+    const AttributeNode* findAttribute(const char *pcszMatch) const;
+    bool getAttributeValue(const char *pcszMatch, const char *&ppcsz) const;
+    bool getAttributeValue(const char *pcszMatch, int64_t &i) const;
+    bool getAttributeValue(const char *pcszMatch, uint64_t &i) const;
+
+    ElementNode* createChild(const char *pcszElementName);
+    ContentNode* addContent(const char *pcszContent);
+    AttributeNode* setAttribute(const char *pcszName, const char *pcszValue);
+
+protected:
+    // hide the default constructor so people use only our factory methods
+    ElementNode();
+    ElementNode(const ElementNode &x);      // no copying
+
+    friend class Node;
+    friend class Document;
+    friend class XmlFileParser;
+};
+
+class VBOXXML_CLASS ContentNode : public Node
+{
+public:
+
+protected:
+    // hide the default constructor so people use only our factory methods
+    ContentNode();
+    ContentNode(const ContentNode &x);      // no copying
+
+    friend class Node;
+    friend class ElementNode;
+};
+
+class VBOXXML_CLASS AttributeNode : public Node
+{
+public:
+
+protected:
+    // hide the default constructor so people use only our factory methods
+    AttributeNode();
+    AttributeNode(const AttributeNode &x);      // no copying
+
+    friend class Node;
+    friend class ElementNode;
+};
+
+/*
+ * NodesLoop
+ *
+ */
+
+class VBOXXML_CLASS NodesLoop
+{
+public:
+    NodesLoop(const ElementNode &node, const char *pcszMatch = NULL);
+    ~NodesLoop();
+    const ElementNode* forAllNodes() const;
+
+private:
+    /* Obscure class data */
+    struct Data;
+    Data *m;
+};
+
+/*
+ * Document
+ *
+ */
+
+class VBOXXML_CLASS Document
+{
+public:
+    Document();
+    ~Document();
+
+    Document(const Document &x);
+    Document& operator=(const Document &x);
+
+    const ElementNode* getRootElement() const;
+
+    ElementNode* createRootElement(const char *pcszRootElementName);
+
+private:
+    friend class XmlFileParser;
+    friend class XmlFileWriter;
+
+    void refreshInternals();
+
+    /* Obscure class data */
+    struct Data;
+    Data *m;
+};
+
+/*
+ * XmlParserBase
+ *
+ */
+
+class VBOXXML_CLASS XmlParserBase
+{
+protected:
+    XmlParserBase();
+    ~XmlParserBase();
+
+    xmlParserCtxtPtr m_ctxt;
+};
+
+/*
+ * XmlFileParser
+ *
+ */
+
+class VBOXXML_CLASS XmlFileParser : public XmlParserBase
+{
+public:
+    XmlFileParser();
+    ~XmlFileParser();
+
+    void read(const char *pcszFilename, Document &doc);
+
+private:
+    /* Obscure class data */
+    struct Data;
+    struct Data *m;
+
+    static int ReadCallback(void *aCtxt, char *aBuf, int aLen);
+    static int CloseCallback (void *aCtxt);
+};
+
+/*
+ * XmlFileWriter
+ *
+ */
+
+class VBOXXML_CLASS XmlFileWriter
+{
+public:
+    XmlFileWriter(Document &doc);
+    ~XmlFileWriter();
+
+    void write(const char *pcszFilename);
+
+    static int WriteCallback(void *aCtxt, const char *aBuf, int aLen);
+    static int CloseCallback (void *aCtxt);
+
+private:
+    /* Obscure class data */
+    struct Data;
+    Data *m;
+};
+
+#if defined(_MSC_VER)
+#pragma warning (default:4251)
+#endif
+
+#endif /* IN_RING3 */
+
+/** @} */
+
+} // end namespace xml
+
+#endif /* ___VBox_vboxxml_h */

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>
@@ -40 +39 @@
 
 #include "Logging.h"
+
+#include "VBox/xml.h"
 
 using namespace std;
@@ -233 +234 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
+
+static Utf8Str stripFilename(const Utf8Str &strFile)
+{
+    Utf8Str str2(strFile);
+    RTPathStripFilename(str2.mutableRaw());
+    return str2;
+}
 
 static const struct
@@ -2238 +2246 @@
                     /* 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(pAppliance->m->strPath);
-                    strSrcDir.stripFilename();
+                    Utf8Str strSrcDir = stripFilename(pAppliance->m->strPath);
 
                     /* Iterate over all given disk images */
@@ -3515 +3522 @@
             const Utf8Str &strTargetFileNameOnly = pDiskEntry->strOvf;
             // target path needs to be composed from where the output OVF is
-            Utf8Str strTargetFilePath(m->strPath);
-            strTargetFilePath.stripFilename();
+            Utf8Str strTargetFilePath = stripFilename(m->strPath);
             strTargetFilePath.append("/");
             strTargetFilePath.append(strTargetFileNameOnly);
@@ -3715 +3721 @@
                 const Utf8Str &strTargetFileNameOnly = (*itH)->strOvf;
                 /* Target path needs to be composed from where the output OVF is */
-                Utf8Str strTargetFilePath(m->strPath);
-                strTargetFilePath.stripFilename();
+                Utf8Str strTargetFilePath = stripFilename(m->strPath);
                 strTargetFilePath.append("/");
                 strTargetFilePath.append(strTargetFileNameOnly);
@@ -4731 +4736 @@
 
             Utf8Str strTargetVmdkName(bstrName);
-            strTargetVmdkName.stripExt();
+            RTPathStripExt(strTargetVmdkName.mutableRaw());
             strTargetVmdkName.append(".vmdk");
 

trunk/src/VBox/Main/ConsoleImpl.cpp

@@ -1073 +1073 @@
     for (unsigned i = 0; i < 10 && (VERR_BUFFER_OVERFLOW == vrc); ++i)
     {
-        Utf8Buf.reserve(cchBuf + 1024);
+        Utf8Buf.alloc(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"));
@@ -1718 +1717 @@
         {
             Utf8Str dir = stateFilePath;
-            dir.stripFilename();
-            if (!RTDirExists(dir))
+            RTPathStripFilename (dir.mutableRaw());
+            if (!RTDirExists (dir))
             {
                 int vrc = RTDirCreateFullPath (dir, 0777);
@@ -3866 +3865 @@
 
     parm[0].type = VBOX_HGCM_SVC_PARM_PTR;
-    parm[0].u.pointer.addr = (void*)Utf8Name.c_str();
+    /* To save doing a const cast, we use the mutableRaw() member. */
+    parm[0].u.pointer.addr = Utf8Name.mutableRaw();
     /* The + 1 is the null terminator */
     parm[0].u.pointer.size = (uint32_t)Utf8Name.length() + 1;
@@ -3882 +3882 @@
         if (vrc != VERR_NOT_FOUND)
         {
-            Utf8Str strBuffer(pszBuffer);
-            strBuffer.cloneTo(aValue);
-
+            size_t iFlags = strlen(pszBuffer) + 1;
+            Utf8Str(pszBuffer).cloneTo (aValue);
             *aTimestamp = parm[2].u.uint64;
-
-            size_t iFlags = strBuffer.length() + 1;
-            Utf8Str(pszBuffer + iFlags).cloneTo(aFlags);
+            Utf8Str(pszBuffer + iFlags).cloneTo (aFlags);
         }
         else
@@ -3933 +3930 @@
 
     parm[0].type = VBOX_HGCM_SVC_PARM_PTR;
-    parm[0].u.pointer.addr = (void*)Utf8Name.c_str();
+    /* To save doing a const cast, we use the mutableRaw() member. */
+    parm[0].u.pointer.addr = Utf8Name.mutableRaw();
     /* The + 1 is the null terminator */
     parm[0].u.pointer.size = (uint32_t)Utf8Name.length() + 1;
@@ -3940 +3938 @@
     {
         parm[1].type = VBOX_HGCM_SVC_PARM_PTR;
-        parm[1].u.pointer.addr = (void*)Utf8Value.c_str();
+        /* To save doing a const cast, we use the mutableRaw() member. */
+        parm[1].u.pointer.addr = Utf8Value.mutableRaw();
         /* The + 1 is the null terminator */
         parm[1].u.pointer.size = (uint32_t)Utf8Value.length() + 1;
@@ -3948 +3947 @@
     {
         parm[2].type = VBOX_HGCM_SVC_PARM_PTR;
-        parm[2].u.pointer.addr = (void*)Utf8Flags.c_str();
+        /* To save doing a const cast, we use the mutableRaw() member. */
+        parm[2].u.pointer.addr = Utf8Flags.mutableRaw();
         /* 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 strSettingsDir = mData->mConfigFileFull;
-
-    strSettingsDir.stripFilename();
-    char folder[RTPATH_MAX];
-    int vrc = RTPathAbsEx(strSettingsDir, aPath, folder, sizeof(folder));
-    if (RT_SUCCESS(vrc))
+    Utf8Str settingsDir = mData->mConfigFileFull;
+
+    RTPathStripFilename (settingsDir.mutableRaw());
+    char folder [RTPATH_MAX];
+    int vrc = RTPathAbsEx (settingsDir, aPath, folder, sizeof (folder));
+    if (RT_SUCCESS (vrc))
         aResult = folder;
 
@@ -3483 +3483 @@
     Utf8Str settingsDir = mData->mConfigFileFull;
 
-    settingsDir.stripFilename();
-    if (RTPathStartsWith(aPath, settingsDir))
+    RTPathStripFilename (settingsDir.mutableRaw());
+    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;
-            configDir.stripFilename();
+            RTPathStripFilename (configDir.mutableRaw());
             newConfigDir = configDir;
-            if (RTPathFilename(configDir) == name)
+            if (RTPathFilename (configDir) == name)
             {
-                newConfigDir.stripFilename();
+                RTPathStripFilename (newConfigDir.mutableRaw());
                 newConfigDir = Utf8StrFmt ("%s%c%s",
                     newConfigDir.raw(), RTPATH_DELIMITER, newName.raw());
@@ -6078 +6078 @@
 
         /* ensure the settings directory exists */
-        Utf8Str path(mData->mConfigFileFull);
-        path.stripFilename();
-        if (!RTDirExists(path))
-        {
-            vrc = RTDirCreateFullPath(path, 0777);
-            if (RT_FAILURE(vrc))
+        Utf8Str path = mData->mConfigFileFull;
+        RTPathStripFilename (path.mutableRaw());
+        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;
-    settingsDir.stripFilename();
-    char *dirName = RTPathFilename(settingsDir);
+    RTPathStripFilename (settingsDir.mutableRaw());
+    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/path.h>
 #include <iprt/cpputils.h>
-#include <iprt/path.h>
 
 // constructor / destructor
@@ -199 +199 @@
         ;
 #else
-    if (hostPathLen == 1 && RTPATH_IS_SEP(hostPath[0]))
+    if (hostPathLen == 1 && RTPATH_IS_SEP (hostPath[0]))
         ;
 #endif
     else
-        hostPath.stripTrailingSlash();
+        RTPathStripTrailingSlash (hostPath.mutableRaw());
 
     /* Check whether the path is full (absolute) */

trunk/src/VBox/Main/VirtualBoxErrorInfoImpl.cpp

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

trunk/src/VBox/Main/VirtualBoxImpl.cpp

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

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

@@ -118 +118 @@
 
                     Utf8Str message;
-                    rc = ex->GetMessage(message.asOutParam());
-                    message.jolt();
+                    rc = ex->GetMessage (message.asOutParam());
                     gotSomething |= NS_SUCCEEDED (rc);
                     if (NS_SUCCEEDED (rc))
@@ -183 +182 @@
     LONG lrc;
 
-    rc = info->COMGETTER(ResultCode) (&lrc); mResultCode = lrc;
+    rc = info->COMGETTER(ResultCode) (&lrc); mResultCode = lrc;    
     gotSomething |= SUCCEEDED (rc);
     gotAll &= SUCCEEDED (rc);

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

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

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

@@ -26 +26 @@
 
 #include <iprt/err.h>
-#include <iprt/path.h>
 
 namespace com
@@ -86 +85 @@
 
                 size_t cbCopy = psz - pFirst;
-                ret.reserve(cbCopy + 1);
-                memcpy(ret.m_psz, pFirst, cbCopy);
-                ret.m_psz[cbCopy] = '\0';
+                ret.alloc(cbCopy + 1);
+                memcpy(ret.str, pFirst, cbCopy);
+                ret.str[cbCopy] = '\0';
             }
         }
@@ -96 +95 @@
 }
 
-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 (!m_psz)
+    if (!str)
         return VERR_NO_DIGITS;
-    return RTStrToUInt64Ex(m_psz, NULL, 0, &i);
+    return RTStrToUInt64Ex(str, NULL, 0, &i);
 }
 
 int Utf8Str::toInt(uint32_t &i) const
 {
-    if (!m_psz)
+    if (!str)
         return VERR_NO_DIGITS;
-    return RTStrToUInt32Ex(m_psz, NULL, 0, &i);
+    return RTStrToUInt32Ex(str, NULL, 0, &i);
 }
 

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

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

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

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

trunk/src/VBox/Main/xml/xml.cpp

@@ +1 @@
+/** @file
+ * VirtualBox XML Manipulation API.
+ */
+
+/*
+ * Copyright (C) 2007-2009 Sun Microsystems, Inc.
+ *
+ * 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.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
+ * Clara, CA 95054 USA or visit http://www.sun.com if you need
+ * additional information or have any questions.
+ */
+
+#include "Logging.h"
+
+#include <iprt/cdefs.h>
+#include <iprt/err.h>
+#include <iprt/file.h>
+#include <iprt/lock.h>
+#include <iprt/string.h>
+
+#include <libxml/tree.h>
+#include <libxml/parser.h>
+#include <libxml/globals.h>
+#include <libxml/xmlIO.h>
+#include <libxml/xmlsave.h>
+#include <libxml/uri.h>
+
+#include <libxml/xmlschemas.h>
+
+#include <list>
+#include <map>
+#include <boost/shared_ptr.hpp>
+
+#include "VBox/xml.h"
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// globals
+//
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Global module initialization structure. This is to wrap non-reentrant bits
+ * of libxml, among other things.
+ *
+ * The constructor and destructor of this structure are used to perform global
+ * module initiaizaton and cleanup. Thee must be only one global variable of
+ * this structure.
+ */
+static
+class Global
+{
+public:
+
+    Global()
+    {
+        /* Check the parser version. The docs say it will kill the app if
+         * there is a serious version mismatch, but I couldn't find it in the
+         * source code (it only prints the error/warning message to the console) so
+         * let's leave it as is for informational purposes. */
+        LIBXML_TEST_VERSION
+
+        /* Init libxml */
+        xmlInitParser();
+
+        /* Save the default entity resolver before someone has replaced it */
+        sxml.defaultEntityLoader = xmlGetExternalEntityLoader();
+    }
+
+    ~Global()
+    {
+        /* Shutdown libxml */
+        xmlCleanupParser();
+    }
+
+    struct
+    {
+        xmlExternalEntityLoader defaultEntityLoader;
+
+        /** Used to provide some thread safety missing in libxml2 (see e.g.
+         *  XmlTreeBackend::read()) */
+        RTLockMtx lock;
+    }
+    sxml;  /* XXX naming this xml will break with gcc-3.3 */
+}
+gGlobal;
+
+
+
+namespace xml
+{
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Exceptions
+//
+////////////////////////////////////////////////////////////////////////////////
+
+LogicError::LogicError(RT_SRC_POS_DECL)
+    : Error(NULL)
+{
+    char *msg = NULL;
+    RTStrAPrintf(&msg, "In '%s', '%s' at #%d",
+                 pszFunction, pszFile, iLine);
+    setWhat(msg);
+    RTStrFree(msg);
+}
+
+XmlError::XmlError(xmlErrorPtr aErr)
+{
+    if (!aErr)
+        throw EInvalidArg(RT_SRC_POS);
+
+    char *msg = Format(aErr);
+    setWhat(msg);
+    RTStrFree(msg);
+}
+
+/**
+ * Composes a single message for the given error. The caller must free the
+ * returned string using RTStrFree() when no more necessary.
+ */
+// static
+char *XmlError::Format(xmlErrorPtr aErr)
+{
+    const char *msg = aErr->message ? aErr->message : "<none>";
+    size_t msgLen = strlen(msg);
+    /* strip spaces, trailing EOLs and dot-like char */
+    while (msgLen && strchr(" \n.?!", msg [msgLen - 1]))
+        --msgLen;
+
+    char *finalMsg = NULL;
+    RTStrAPrintf(&finalMsg, "%.*s.\nLocation: '%s', line %d (%d), column %d",
+                 msgLen, msg, aErr->file, aErr->line, aErr->int1, aErr->int2);
+
+    return finalMsg;
+}
+
+EIPRTFailure::EIPRTFailure(int aRC)
+    : RuntimeError(NULL),
+      mRC(aRC)
+{
+    char *newMsg = NULL;
+    RTStrAPrintf(&newMsg, "Runtime error: %d (%s)", aRC, RTErrGetShort(aRC));
+    setWhat(newMsg);
+    RTStrFree(newMsg);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// File Class
+//
+//////////////////////////////////////////////////////////////////////////////
+
+struct File::Data
+{
+    Data()
+        : fileName (NULL), handle (NIL_RTFILE), opened (false) {}
+
+    char *fileName;
+    RTFILE handle;
+    bool opened : 1;
+};
+
+File::File(Mode aMode, const char *aFileName)
+    : m (new Data())
+{
+    m->fileName = RTStrDup (aFileName);
+    if (m->fileName == NULL)
+        throw ENoMemory();
+
+    unsigned flags = 0;
+    switch (aMode)
+    {
+        case Mode_Read:
+            flags = RTFILE_O_READ;
+            break;
+        case Mode_WriteCreate:      // fail if file exists
+            flags = RTFILE_O_WRITE | RTFILE_O_CREATE;
+            break;
+        case Mode_Overwrite:        // overwrite if file exists
+            flags = RTFILE_O_WRITE | RTFILE_O_CREATE_REPLACE;
+            break;
+        case Mode_ReadWrite:
+            flags = RTFILE_O_READ | RTFILE_O_WRITE;
+    }
+
+    int vrc = RTFileOpen (&m->handle, aFileName, flags);
+    if (RT_FAILURE (vrc))
+        throw EIPRTFailure (vrc);
+
+    m->opened = true;
+}
+
+File::File (RTFILE aHandle, const char *aFileName /* = NULL */)
+    : m (new Data())
+{
+    if (aHandle == NIL_RTFILE)
+        throw EInvalidArg (RT_SRC_POS);
+
+    m->handle = aHandle;
+
+    if (aFileName)
+    {
+        m->fileName = RTStrDup (aFileName);
+        if (m->fileName == NULL)
+            throw ENoMemory();
+    }
+
+    setPos (0);
+}
+
+File::~File()
+{
+    if (m->opened)
+        RTFileClose (m->handle);
+
+    RTStrFree (m->fileName);
+}
+
+const char *File::uri() const
+{
+    return m->fileName;
+}
+
+uint64_t File::pos() const
+{
+    uint64_t p = 0;
+    int vrc = RTFileSeek (m->handle, 0, RTFILE_SEEK_CURRENT, &p);
+    if (RT_SUCCESS (vrc))
+        return p;
+
+    throw EIPRTFailure (vrc);
+}
+
+void File::setPos (uint64_t aPos)
+{
+    uint64_t p = 0;
+    unsigned method = RTFILE_SEEK_BEGIN;
+    int vrc = VINF_SUCCESS;
+
+    /* check if we overflow int64_t and move to INT64_MAX first */
+    if (((int64_t) aPos) < 0)
+    {
+        vrc = RTFileSeek (m->handle, INT64_MAX, method, &p);
+        aPos -= (uint64_t) INT64_MAX;
+        method = RTFILE_SEEK_CURRENT;
+    }
+    /* seek the rest */
+    if (RT_SUCCESS (vrc))
+        vrc = RTFileSeek (m->handle, (int64_t) aPos, method, &p);
+    if (RT_SUCCESS (vrc))
+        return;
+
+    throw EIPRTFailure (vrc);
+}
+
+int File::read (char *aBuf, int aLen)
+{
+    size_t len = aLen;
+    int vrc = RTFileRead (m->handle, aBuf, len, &len);
+    if (RT_SUCCESS (vrc))
+        return (int)len;
+
+    throw EIPRTFailure (vrc);
+}
+
+int File::write (const char *aBuf, int aLen)
+{
+    size_t len = aLen;
+    int vrc = RTFileWrite (m->handle, aBuf, len, &len);
+    if (RT_SUCCESS (vrc))
+        return (int)len;
+
+    throw EIPRTFailure (vrc);
+
+    return -1 /* failure */;
+}
+
+void File::truncate()
+{
+    int vrc = RTFileSetSize (m->handle, pos());
+    if (RT_SUCCESS (vrc))
+        return;
+
+    throw EIPRTFailure (vrc);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// MemoryBuf Class
+//
+//////////////////////////////////////////////////////////////////////////////
+
+struct MemoryBuf::Data
+{
+    Data()
+        : buf (NULL), len (0), uri (NULL), pos (0) {}
+
+    const char *buf;
+    size_t len;
+    char *uri;
+
+    size_t pos;
+};
+
+MemoryBuf::MemoryBuf (const char *aBuf, size_t aLen, const char *aURI /* = NULL */)
+    : m (new Data())
+{
+    if (aBuf == NULL)
+        throw EInvalidArg (RT_SRC_POS);
+
+    m->buf = aBuf;
+    m->len = aLen;
+    m->uri = RTStrDup (aURI);
+}
+
+MemoryBuf::~MemoryBuf()
+{
+    RTStrFree (m->uri);
+}
+
+const char *MemoryBuf::uri() const
+{
+    return m->uri;
+}
+
+uint64_t MemoryBuf::pos() const
+{
+    return m->pos;
+}
+
+void MemoryBuf::setPos (uint64_t aPos)
+{
+    size_t pos = (size_t) aPos;
+    if ((uint64_t) pos != aPos)
+        throw EInvalidArg();
+
+    if (pos > m->len)
+        throw EInvalidArg();
+
+    m->pos = pos;
+}
+
+int MemoryBuf::read (char *aBuf, int aLen)
+{
+    if (m->pos >= m->len)
+        return 0 /* nothing to read */;
+
+    size_t len = m->pos + aLen < m->len ? aLen : m->len - m->pos;
+    memcpy (aBuf, m->buf + m->pos, len);
+    m->pos += len;
+
+    return (int)len;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// GlobalLock class
+//
+////////////////////////////////////////////////////////////////////////////////
+
+struct GlobalLock::Data
+{
+    PFNEXTERNALENTITYLOADER pOldLoader;
+    RTLock lock;
+
+    Data()
+        : pOldLoader(NULL),
+          lock(gGlobal.sxml.lock)
+    {
+    }
+};
+
+GlobalLock::GlobalLock()
+    : m(new Data())
+{
+}
+
+GlobalLock::~GlobalLock()
+{
+    if (m->pOldLoader)
+        xmlSetExternalEntityLoader(m->pOldLoader);
+    delete m;
+    m = NULL;
+}
+
+void GlobalLock::setExternalEntityLoader(PFNEXTERNALENTITYLOADER pLoader)
+{
+    m->pOldLoader = xmlGetExternalEntityLoader();
+    xmlSetExternalEntityLoader(pLoader);
+}
+
+// static
+xmlParserInput* GlobalLock::callDefaultLoader(const char *aURI,
+                                              const char *aID,
+                                              xmlParserCtxt *aCtxt)
+{
+    return gGlobal.sxml.defaultEntityLoader(aURI, aID, aCtxt);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Node class
+//
+////////////////////////////////////////////////////////////////////////////////
+
+struct Node::Data
+{
+    xmlNode     *plibNode;          // != NULL if this is an element or content node
+    xmlAttr     *plibAttr;          // != NULL if this is an attribute node
+
+    Node        *pParent;           // NULL only for the root element
+    const char  *pcszName;          // element or attribute name, points either into plibNode or plibAttr;
+                                    // NULL if this is a content node
+
+    struct compare_const_char
+    {
+        bool operator()(const char* s1, const char* s2) const
+        {
+            return strcmp(s1, s2) < 0;
+        }
+    };
+
+    // attributes, if this is an element; can be empty
+    typedef std::map<const char*, boost::shared_ptr<AttributeNode>, compare_const_char > AttributesMap;
+    AttributesMap attribs;
+
+    // child elements, if this is an element; can be empty
+    typedef std::list< boost::shared_ptr<Node> > InternalNodesList;
+    InternalNodesList children;
+};
+
+Node::Node(EnumType type)
+    : mType(type),
+      m(new Data)
+{
+    m->plibNode = NULL;
+    m->plibAttr = NULL;
+    m->pParent = NULL;
+}
+
+Node::~Node()
+{
+    delete m;
+}
+
+void Node::buildChildren()       // private
+{
+    // go thru this element's attributes
+    xmlAttr *plibAttr = m->plibNode->properties;
+    while (plibAttr)
+    {
+        const char *pcszAttribName = (const char*)plibAttr->name;
+        boost::shared_ptr<AttributeNode> pNew(new AttributeNode);
+        pNew->m->plibAttr = plibAttr;
+        pNew->m->pcszName = (const char*)plibAttr->name;
+        pNew->m->pParent = this;
+        // store
+        m->attribs[pcszAttribName] = pNew;
+
+        plibAttr = plibAttr->next;
+    }
+
+    // go thru this element's child elements
+    xmlNodePtr plibNode = m->plibNode->children;
+    while (plibNode)
+    {
+        boost::shared_ptr<Node> pNew;
+
+        if (plibNode->name)
+            pNew = boost::shared_ptr<Node>(new ElementNode);
+        else
+            pNew = boost::shared_ptr<Node>(new ContentNode);
+
+        pNew->m->plibNode = plibNode;
+        pNew->m->pcszName = (const char*)plibNode->name;
+        pNew->m->pParent = this;
+        // store
+        m->children.push_back(pNew);
+
+        // recurse for this child element to get its own children
+        pNew->buildChildren();
+
+        plibNode = plibNode->next;
+    }
+}
+
+const char* Node::getName() const
+{
+    return m->pcszName;
+}
+
+/**
+ * Returns the value of a node. If this node is an attribute, returns
+ * the attribute value; if this node is an element, then this returns
+ * the element text content.
+ * @return
+ */
+const char* Node::getValue() const
+{
+    if (    (m->plibAttr)
+         && (m->plibAttr->children)
+       )
+        // libxml hides attribute values in another node created as a
+        // single child of the attribute node, and it's in the content field
+        return (const char*)m->plibAttr->children->content;
+
+    if (    (m->plibNode)
+         && (m->plibNode->children)
+       )
+        return (const char*)m->plibNode->children->content;
+
+    return NULL;
+}
+
+/**
+ * Copies the value of a node into the given integer variable.
+ * Returns TRUE only if a value was found and was actually an
+ * integer of the given type.
+ * @return
+ */
+bool Node::copyValue(int32_t &i) const
+{
+    const char *pcsz;
+    if (    ((pcsz = getValue()))
+         && (VINF_SUCCESS == RTStrToInt32Ex(pcsz, NULL, 10, &i))
+       )
+        return true;
+
+    return false;
+}
+
+/**
+ * Copies the value of a node into the given integer variable.
+ * Returns TRUE only if a value was found and was actually an
+ * integer of the given type.
+ * @return
+ */
+bool Node::copyValue(uint32_t &i) const
+{
+    const char *pcsz;
+    if (    ((pcsz = getValue()))
+         && (VINF_SUCCESS == RTStrToUInt32Ex(pcsz, NULL, 10, &i))
+       )
+        return true;
+
+    return false;
+}
+
+/**
+ * Copies the value of a node into the given integer variable.
+ * Returns TRUE only if a value was found and was actually an
+ * integer of the given type.
+ * @return
+ */
+bool Node::copyValue(int64_t &i) const
+{
+    const char *pcsz;
+    if (    ((pcsz = getValue()))
+         && (VINF_SUCCESS == RTStrToInt64Ex(pcsz, NULL, 10, &i))
+       )
+        return true;
+
+    return false;
+}
+
+/**
+ * Copies the value of a node into the given integer variable.
+ * Returns TRUE only if a value was found and was actually an
+ * integer of the given type.
+ * @return
+ */
+bool Node::copyValue(uint64_t &i) const
+{
+    const char *pcsz;
+    if (    ((pcsz = getValue()))
+         && (VINF_SUCCESS == RTStrToUInt64Ex(pcsz, NULL, 10, &i))
+       )
+        return true;
+
+    return false;
+}
+
+/**
+ * Returns the line number of the current node in the source XML file.
+ * Useful for error messages.
+ * @return
+ */
+int Node::getLineNumber() const
+{
+    if (m->plibAttr)
+        return m->pParent->m->plibNode->line;
+
+    return m->plibNode->line;
+}
+
+ElementNode::ElementNode()
+    : Node(IsElement)
+{
+}
+
+/**
+ * Builds a list of direct child elements of the current element that
+ * match the given string; if pcszMatch is NULL, all direct child
+ * elements are returned.
+ * @param children out: list of nodes to which children will be appended.
+ * @param pcszMatch in: match string, or NULL to return all children.
+ * @return Number of items appended to the list (0 if none).
+ */
+int ElementNode::getChildElements(ElementNodesList &children,
+                                  const char *pcszMatch /*= NULL*/)
+    const
+{
+    int i = 0;
+    Data::InternalNodesList::const_iterator
+        it,
+        last = m->children.end();
+    for (it = m->children.begin();
+         it != last;
+         ++it)
+    {
+        // export this child node if ...
+        if (    (!pcszMatch)    // the caller wants all nodes or
+             || (!strcmp(pcszMatch, (**it).getName())) // the element name matches
+           )
+        {
+            Node *pNode = (*it).get();
+            if (pNode->isElement())
+                children.push_back(static_cast<ElementNode*>(pNode));
+            ++i;
+        }
+    }
+    return i;
+}
+
+/**
+ * Returns the first child element whose name matches pcszMatch.
+ * @param pcszMatch
+ * @return
+ */
+const ElementNode* ElementNode::findChildElement(const char *pcszMatch)
+    const
+{
+    Data::InternalNodesList::const_iterator
+        it,
+        last = m->children.end();
+    for (it = m->children.begin();
+         it != last;
+         ++it)
+    {
+        if ((**it).isElement())
+        {
+            ElementNode *pelm = static_cast<ElementNode*>((*it).get());
+            if (!strcmp(pcszMatch, pelm->getName())) // the element name matches
+                return pelm;
+        }
+    }
+
+    return NULL;
+}
+
+/**
+ * Returns the first child element whose "id" attribute matches pcszId.
+ * @param pcszId identifier to look for.
+ * @return child element or NULL if not found.
+ */
+const ElementNode* ElementNode::findChildElementFromId(const char *pcszId) const
+{
+    Data::InternalNodesList::const_iterator
+        it,
+        last = m->children.end();
+    for (it = m->children.begin();
+         it != last;
+         ++it)
+    {
+        if ((**it).isElement())
+        {
+            ElementNode *pelm = static_cast<ElementNode*>((*it).get());
+            const AttributeNode *pAttr;
+            if (    ((pAttr = pelm->findAttribute("id")))
+                 && (!strcmp(pAttr->getValue(), pcszId))
+               )
+                return pelm;
+        }
+    }
+
+    return NULL;
+}
+
+/**
+ *
+ * @param pcszMatch
+ * @return
+ */
+const AttributeNode* ElementNode::findAttribute(const char *pcszMatch) const
+{
+    Data::AttributesMap::const_iterator it;
+
+    it = m->attribs.find(pcszMatch);
+    if (it != m->attribs.end())
+        return it->second.get();
+
+    return NULL;
+}
+
+/**
+ * Convenience method which attempts to find the attribute with the given
+ * name and returns its value as a string.
+ *
+ * @param pcszMatch name of attribute to find.
+ * @param str out: attribute value
+ * @return TRUE if attribute was found and str was thus updated.
+ */
+bool ElementNode::getAttributeValue(const char *pcszMatch, const char *&ppcsz) const
+{
+    const Node* pAttr;
+    if ((pAttr = findAttribute(pcszMatch)))
+    {
+        ppcsz = pAttr->getValue();
+        return true;
+    }
+
+    return false;
+}
+
+/**
+ * Convenience method which attempts to find the attribute with the given
+ * name and returns its value as a signed long integer. This calls
+ * RTStrToInt64Ex internally and will only output the integer if that
+ * function returns no error.
+ *
+ * @param pcszMatch name of attribute to find.
+ * @param i out: attribute value
+ * @return TRUE if attribute was found and str was thus updated.
+ */
+bool ElementNode::getAttributeValue(const char *pcszMatch, int64_t &i) const
+{
+    const char *pcsz;
+    if (    (getAttributeValue(pcszMatch, pcsz))
+         && (VINF_SUCCESS == RTStrToInt64Ex(pcsz, NULL, 10, &i))
+       )
+        return true;
+
+    return false;
+}
+
+/**
+ * Convenience method which attempts to find the attribute with the given
+ * name and returns its value as an unsigned long integer.This calls
+ * RTStrToUInt64Ex internally and will only output the integer if that
+ * function returns no error.
+ *
+ * @param pcszMatch name of attribute to find.
+ * @param i out: attribute value
+ * @return TRUE if attribute was found and str was thus updated.
+ */
+bool ElementNode::getAttributeValue(const char *pcszMatch, uint64_t &i) const
+{
+    const char *pcsz;
+    if (    (getAttributeValue(pcszMatch, pcsz))
+         && (VINF_SUCCESS == RTStrToUInt64Ex(pcsz, NULL, 10, &i))
+       )
+        return true;
+
+    return false;
+}
+
+/**
+ * Creates a new child element node and appends it to the list
+ * of children in "this".
+ *
+ * @param pcszElementName
+ * @return
+ */
+ElementNode* ElementNode::createChild(const char *pcszElementName)
+{
+    // we must be an element, not an attribute
+    if (!m->plibNode)
+        throw ENodeIsNotElement(RT_SRC_POS);
+
+    // libxml side: create new node
+    xmlNode *plibNode;
+    if (!(plibNode = xmlNewNode(NULL,        // namespace
+                                (const xmlChar*)pcszElementName)))
+        throw ENoMemory();
+    xmlAddChild(m->plibNode, plibNode);
+
+    // now wrap this in C++
+    ElementNode *p = new ElementNode;
+    boost::shared_ptr<ElementNode> pNew(p);
+    pNew->m->plibNode = plibNode;
+    pNew->m->pcszName = (const char*)plibNode->name;
+
+    m->children.push_back(pNew);
+
+    return p;
+}
+
+
+/**
+ * Creates a content node and appends it to the list of children
+ * in "this".
+ *
+ * @param pcszElementName
+ * @return
+ */
+ContentNode* ElementNode::addContent(const char *pcszContent)
+{
+    // libxml side: create new node
+    xmlNode *plibNode;
+    if (!(plibNode = xmlNewText((const xmlChar*)pcszContent)))
+        throw ENoMemory();
+    xmlAddChild(m->plibNode, plibNode);
+
+    // now wrap this in C++
+    ContentNode *p = new ContentNode;
+    boost::shared_ptr<ContentNode> pNew(p);
+    pNew->m->plibNode = plibNode;
+    pNew->m->pcszName = NULL;
+
+    m->children.push_back(pNew);
+
+    return p;
+}
+
+/**
+ * Sets the given attribute.
+ *
+ * If an attribute with the given name exists, it is overwritten,
+ * otherwise a new attribute is created. Returns the attribute node
+ * that was either created or changed.
+ *
+ * @param pcszName
+ * @param pcszValue
+ * @return
+ */
+AttributeNode* ElementNode::setAttribute(const char *pcszName, const char *pcszValue)
+{
+    Data::AttributesMap::const_iterator it;
+
+    it = m->attribs.find(pcszName);
+    if (it == m->attribs.end())
+    {
+        // libxml side: xmlNewProp creates an attribute
+        xmlAttr *plibAttr = xmlNewProp(m->plibNode, (xmlChar*)pcszName, (xmlChar*)pcszValue);
+        const char *pcszAttribName = (const char*)plibAttr->name;
+
+        // C++ side: create an attribute node around it
+        boost::shared_ptr<AttributeNode> pNew(new AttributeNode);
+        pNew->m->plibAttr = plibAttr;
+        pNew->m->pcszName = (const char*)plibAttr->name;
+        pNew->m->pParent = this;
+        // store
+        m->attribs[pcszAttribName] = pNew;
+    }
+    else
+    {
+        // @todo
+        throw LogicError("Attribute exists");
+    }
+
+    return NULL;
+
+}
+
+
+AttributeNode::AttributeNode()
+    : Node(IsAttribute)
+{
+}
+
+ContentNode::ContentNode()
+    : Node(IsContent)
+{
+}
+
+/*
+ * NodesLoop
+ *
+ */
+
+struct NodesLoop::Data
+{
+    ElementNodesList listElements;
+    ElementNodesList::const_iterator it;
+};
+
+NodesLoop::NodesLoop(const ElementNode &node, const char *pcszMatch /* = NULL */)
+{
+    m = new Data;
+    node.getChildElements(m->listElements, pcszMatch);
+    m->it = m->listElements.begin();
+}
+
+NodesLoop::~NodesLoop()
+{
+    delete m;
+}
+
+
+/**
+ * Handy convenience helper for looping over all child elements. Create an
+ * instance of NodesLoop on the stack and call this method until it returns
+ * NULL, like this:
+ * <code>
+ *      xml::Node node;         // should point to an element
+ *      xml::NodesLoop loop(node, "child");  // find all "child" elements under node
+ *      const xml::Node *pChild = NULL;
+ *      while (pChild = loop.forAllNodes())
+ *          ...;
+ * </code>
+ * @param node
+ * @param pcszMatch
+ * @return
+ */
+const ElementNode* NodesLoop::forAllNodes() const
+{
+    const ElementNode *pNode = NULL;
+
+    if (m->it != m->listElements.end())
+    {
+        pNode = *(m->it);
+        ++(m->it);
+    }
+
+    return pNode;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Document class
+//
+////////////////////////////////////////////////////////////////////////////////
+
+struct Document::Data
+{
+    xmlDocPtr   plibDocument;
+    ElementNode *pRootElement;
+
+    Data()
+    {
+        plibDocument = NULL;
+        pRootElement = NULL;
+    }
+
+    ~Data()
+    {
+        reset();
+    }
+
+    void reset()
+    {
+        if (plibDocument)
+        {
+            xmlFreeDoc(plibDocument);
+            plibDocument = NULL;
+        }
+        if (pRootElement)
+        {
+            delete pRootElement;
+            pRootElement = NULL;
+        }
+    }
+
+    void copyFrom(const Document::Data *p)
+    {
+        if (p->plibDocument)
+        {
+            plibDocument = xmlCopyDoc(p->plibDocument,
+                                      1);      // recursive == copy all
+        }
+    }
+};
+
+Document::Document()
+    : m(new Data)
+{
+}
+
+Document::Document(const Document &x)
+    : m(new Data)
+{
+    m->copyFrom(x.m);
+};
+
+Document& Document::operator=(const Document &x)
+{
+    m->reset();
+    m->copyFrom(x.m);
+    return *this;
+};
+
+Document::~Document()
+{
+    delete m;
+}
+
+/**
+ * private method to refresh all internal structures after the internal pDocument
+ * has changed. Called from XmlFileParser::read(). m->reset() must have been
+ * called before to make sure all members except the internal pDocument are clean.
+ */
+void Document::refreshInternals() // private
+{
+    m->pRootElement = new ElementNode();
+    m->pRootElement->m->plibNode = xmlDocGetRootElement(m->plibDocument);
+    m->pRootElement->m->pcszName = (const char*)m->pRootElement->m->plibNode->name;
+
+    m->pRootElement->buildChildren();
+}
+
+/**
+ * Returns the root element of the document, or NULL if the document is empty.
+ * @return
+ */
+const ElementNode* Document::getRootElement() const
+{
+    return m->pRootElement;
+}
+
+/**
+ * Creates a new element node and sets it as the root element. This will
+ * only work if the document is empty; otherwise EDocumentNotEmpty is thrown.
+ */
+ElementNode* Document::createRootElement(const char *pcszRootElementName)
+{
+    if (m->pRootElement || m->plibDocument)
+        throw EDocumentNotEmpty(RT_SRC_POS);
+
+    // libxml side: create document, create root node
+    m->plibDocument = xmlNewDoc((const xmlChar*)"1.0");
+    xmlNode *plibRootNode;
+    if (!(plibRootNode = xmlNewNode(NULL,        // namespace
+                                    (const xmlChar*)pcszRootElementName)))
+        throw ENoMemory();
+    xmlDocSetRootElement(m->plibDocument, plibRootNode);
+
+    // now wrap this in C++
+    m->pRootElement = new ElementNode();
+    m->pRootElement->m->plibNode = plibRootNode;
+    m->pRootElement->m->pcszName = (const char*)plibRootNode->name;
+
+    return m->pRootElement;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// XmlParserBase class
+//
+////////////////////////////////////////////////////////////////////////////////
+
+XmlParserBase::XmlParserBase()
+{
+    m_ctxt = xmlNewParserCtxt();
+    if (m_ctxt == NULL)
+        throw ENoMemory();
+}
+
+XmlParserBase::~XmlParserBase()
+{
+    xmlFreeParserCtxt (m_ctxt);
+    m_ctxt = NULL;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// XmlFileParser class
+//
+////////////////////////////////////////////////////////////////////////////////
+
+struct XmlFileParser::Data
+{
+    xmlParserCtxtPtr ctxt;
+    ministring strXmlFilename;
+
+    Data()
+    {
+        if (!(ctxt = xmlNewParserCtxt()))
+            throw xml::ENoMemory();
+    }
+
+    ~Data()
+    {
+        xmlFreeParserCtxt(ctxt);
+        ctxt = NULL;
+    }
+};
+
+XmlFileParser::XmlFileParser()
+    : XmlParserBase(),
+      m(new Data())
+{
+}
+
+XmlFileParser::~XmlFileParser()
+{
+    delete m;
+    m = NULL;
+}
+
+struct IOContext
+{
+    File file;
+    ministring error;
+
+    IOContext(const char *pcszFilename, File::Mode mode)
+        : file(mode, pcszFilename)
+    {
+    }
+
+    void setError(const xml::Error &x)
+    {
+        error = x.what();
+    }
+
+    void setError(const std::exception &x)
+    {
+        error = x.what();
+    }
+};
+
+struct ReadContext : IOContext
+{
+    ReadContext(const char *pcszFilename)
+        : IOContext(pcszFilename, File::Mode_Read)
+    {
+    }
+};
+
+struct WriteContext : IOContext
+{
+    WriteContext(const char *pcszFilename)
+        : IOContext(pcszFilename, File::Mode_Overwrite)
+    {
+    }
+};
+
+/**
+ * Reads the given file and fills the given Document object with its contents.
+ * Throws XmlError on parsing errors.
+ *
+ * The document that is passed in will be reset before being filled if not empty.
+ *
+ * @param pcszFilename in: name fo file to parse.
+ * @param doc out: document to be reset and filled with data according to file contents.
+ */
+void XmlFileParser::read(const char *pcszFilename,
+                         Document &doc)
+{
+    GlobalLock lock;
+//     global.setExternalEntityLoader(ExternalEntityLoader);
+
+    m->strXmlFilename = pcszFilename;
+
+    ReadContext context(pcszFilename);
+    doc.m->reset();
+    if (!(doc.m->plibDocument = xmlCtxtReadIO(m->ctxt,
+                                              ReadCallback,
+                                              CloseCallback,
+                                              &context,
+                                              pcszFilename,
+                                              NULL,       // encoding = auto
+                                              XML_PARSE_NOBLANKS)))
+        throw XmlError(xmlCtxtGetLastError(m->ctxt));
+
+    doc.refreshInternals();
+}
+
+// static
+int XmlFileParser::ReadCallback(void *aCtxt, char *aBuf, int aLen)
+{
+    ReadContext *pContext = static_cast<ReadContext*>(aCtxt);
+
+    /* To prevent throwing exceptions while inside libxml2 code, we catch
+     * them and forward to our level using a couple of variables. */
+
+    try
+    {
+        return pContext->file.read(aBuf, aLen);
+    }
+    catch (const xml::EIPRTFailure &err) { pContext->setError(err); }
+    catch (const xml::Error &err) { pContext->setError(err); }
+    catch (const std::exception &err) { pContext->setError(err); }
+    catch (...) { pContext->setError(xml::LogicError(RT_SRC_POS)); }
+
+    return -1 /* failure */;
+}
+
+int XmlFileParser::CloseCallback(void *aCtxt)
+{
+    /// @todo to be written
+
+    return -1;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// XmlFileWriter class
+//
+////////////////////////////////////////////////////////////////////////////////
+
+struct XmlFileWriter::Data
+{
+    Document *pDoc;
+};
+
+XmlFileWriter::XmlFileWriter(Document &doc)
+{
+    m = new Data();
+    m->pDoc = &doc;
+}
+
+XmlFileWriter::~XmlFileWriter()
+{
+    delete m;
+}
+
+void XmlFileWriter::write(const char *pcszFilename)
+{
+    WriteContext context(pcszFilename);
+
+    GlobalLock lock;
+
+    /* serialize to the stream */
+    xmlIndentTreeOutput = 1;
+    xmlTreeIndentString = "  ";
+    xmlSaveNoEmptyTags = 0;
+
+    xmlSaveCtxtPtr saveCtxt;
+    if (!(saveCtxt = xmlSaveToIO(WriteCallback,
+                                 CloseCallback,
+                                 &context,
+                                 NULL,
+                                 XML_SAVE_FORMAT)))
+        throw xml::LogicError(RT_SRC_POS);
+
+    long rc = xmlSaveDoc(saveCtxt, m->pDoc->m->plibDocument);
+    if (rc == -1)
+    {
+        /* look if there was a forwared exception from the lower level */
+//         if (m->trappedErr.get() != NULL)
+//             m->trappedErr->rethrow();
+
+        /* there must be an exception from the Output implementation,
+         * otherwise the save operation must always succeed. */
+        throw xml::LogicError(RT_SRC_POS);
+    }
+
+    xmlSaveClose(saveCtxt);
+}
+
+int XmlFileWriter::WriteCallback(void *aCtxt, const char *aBuf, int aLen)
+{
+    WriteContext *pContext = static_cast<WriteContext*>(aCtxt);
+
+    /* To prevent throwing exceptions while inside libxml2 code, we catch
+     * them and forward to our level using a couple of variables. */
+    try
+    {
+        return pContext->file.write(aBuf, aLen);
+    }
+    catch (const xml::EIPRTFailure &err) { pContext->setError(err); }
+    catch (const xml::Error &err) { pContext->setError(err); }
+    catch (const std::exception &err) { pContext->setError(err); }
+    catch (...) { pContext->setError(xml::LogicError(RT_SRC_POS)); }
+
+    return -1 /* failure */;
+}
+
+int XmlFileWriter::CloseCallback(void *aCtxt)
+{
+    /// @todo to be written
+
+    return -1;
+}
+
+
+} // end namespace xml
+
+

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
@@ -162 +165 @@
 #
 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
@@ -304 +306 @@
         r3/test.cpp \
         r3/testi.cpp \
-        r3/tcp.cpp \
-        r3/xml.cpp
+        r3/tcp.cpp
 
 #if1of ($(KBUILD_TARGET_ARCH),amd64 x86)
@@ -786 +787 @@
 #
 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)
@@ -796 +799 @@
         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))
@@ -813 +818 @@
         $(PATH_LIB)/VBox-kStuff$(VBOX_SUFF_LIB)
 endif
+ifdef VBOX_WITH_LIBXML2_IN_VBOXRT
+ ifndef SDK_VBOX_LIBXML2_LIBS
   VBoxRT_LIBS                 += \
         $(PATH_LIB)/VBox-libxml2$(VBOX_SUFF_LIB)
+ endif
+ ifndef SDK_VBOX_OPENSSL_LIBS
   VBoxRT_LIBS                 += \
         $(PATH_LIB)/VBox-libcrypto$(VBOX_SUFF_LIB)
+ endif
+endif
 VBoxRT_LIBS.darwin             = \
         iconv
@@ -840 +851 @@
         $(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 \
-                $(PATH_SUB_CURRENT)/r3/win/$(if $(VBOX_OSE),VBoxRT-openssl-ose.def,VBoxRT-openssl.def)
+                $(if-expr defined(VBOX_WITH_LIBXML2_IN_VBOXRT),$(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
 
 
@@ -54 +55 @@
     (PFNRT)SUPR3PageAllocEx,
     (PFNRT)SUPSemEventCreate,
+#ifdef VBOX_WITH_LIBXML2_IN_VBOXRT
     (PFNRT)xmlModuleOpen,
     (PFNRT)MD5_Init,
@@ -63 +65 @@
     (PFNRT)i2d_X509,
     (PFNRT)RSA_generate_key,
+#endif
     (PFNRT)RTAssertShouldPanic,
     (PFNRT)ASMAtomicReadU64,

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. */
@@ -927 +926 @@
 
 
-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()
 {
@@ -1029 +946 @@
     TstRTStrXCmp(hTest);
     testStrStr(hTest);
-
-    testMinistring(hTest);
-
     Benchmarks(hTest);