Adding upstream version 7.0.14-dfsg.upstream/7.0.14-dfsg

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

8 files changed, 5599 insertions, 0 deletions

diff --git a/src/VBox/Main/cbinding/Makefile.kmk b/src/VBox/Main/cbinding/Makefile.kmk
new file mode 100644
index 00000000..7f45b28c
--- /dev/null
+++ b/src/VBox/Main/cbinding/Makefile.kmk
@@ -0,0 +1,158 @@
+# $Id: Makefile.kmk $
+## @file
+# Sub-Makefile for the VBox C Binding.
+#
+
+#
+# Copyright (C) 2009-2023 Oracle and/or its affiliates.
+#
+# This file is part of VirtualBox base platform packages, as
+# available from https://www.virtualbox.org.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation, in version 3 of the
+# License.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see <https://www.gnu.org/licenses>.
+#
+# SPDX-License-Identifier: GPL-3.0-only
+#
+
+SUB_DEPTH = ../../../..
+include $(KBUILD_PATH)/subheader.kmk
+
+
+#
+# The samples
+#
+INSTALLS += CAPISamples
+CAPISamples_MODE = a+r,u+rw
+CAPISamples_INST = \
+	$(INST_SDK)bindings/c/samples/
+CAPISamples_SOURCES = \
+	tstCAPIGlue.c \
+	makefile.tstCAPIGlue=>Makefile
+
+#
+# The ???.
+#
+INSTALLS += CAPIGlue
+CAPIGlue_MODE = a+r,u+rw
+CAPIGlue_INST = \
+	$(INST_SDK)bindings/c/glue/
+CAPIGlue_SOURCES = \
+	VBoxCAPIGlue.c \
+	$(CAPIHeaders_0_OUTDIR)/VBoxCAPIGlue.h
+CAPIGlue_CLEAN = \
+	$(CAPIHeaders_0_OUTDIR)/VBoxCAPIGlue.h
+
+$$(CAPIHeaders_0_OUTDIR)/VBoxCAPIGlue.h: \
+		$(PATH_SUB_CURRENT)/VBoxCAPIGlue.h.in \
+		$(MAKEFILE_CURRENT) \
+		| $$(dir $$@)
+	$(call MSG_GENERATE,,$@)
+	$(QUIET)$(SED) \
+		-e 's/@VBOX_API_VERSION@/$(VBOX_API_VERSION)/' \
+		<  $< >  $@
+
+#
+# The ???.
+#
+INSTALLS += CAPIHeaders
+CAPIHeaders_MODE = a+r,u+rw
+CAPIHeaders_INST = $(INST_SDK)bindings/c/include/
+CAPIHeaders_SOURCES = \
+	$(CAPIHeaders_0_OUTDIR)/VBoxCAPI.h=>VBoxCAPI_v$(VBOX_API_VERSION).h
+CAPIHeaders_CLEAN = \
+	$(CAPIHeaders_0_OUTDIR)/VBoxCAPI.h
+
+$$(CAPIHeaders_0_OUTDIR)/VBoxCAPI.h: \
+		$(PATH_SUB_CURRENT)/capiidl.xsl \
+		$(PATH_SUB_CURRENT)/../idl/typemap-shared.inc.xsl \
+		$(VBOX_XIDL_FILE) \
+		| $$(dir $$@)
+	$(call MSG_TOOL,xsltproc,CAPIHeaders,$<,$@)
+	$(QUIET)$(VBOX_XSLTPROC) -o $@ $^
+
+ifndef VBOX_ONLY_SDK
+
+ #
+ # The C API binding utility DLL
+ #
+ DLLS += VBoxCAPI
+ VBoxCAPI_TEMPLATE = VBoxMainClientDll
+ ifdef VBOX_WITH_XPCOM
+  # Keep old name on XPCOM so that legacy code is happy.
+  VBoxCAPI_INST = $(INST_BIN)VBoxXPCOMC$(VBOX_SUFF_DLL)
+ endif
+ VBoxCAPI_DEFS = IN_VBOXCAPI
+ VBoxCAPI_SOURCES = \
+ 	VBoxCAPI.cpp
+ VBoxCAPI_SOURCES.win = \
+ 	VBoxCAPI.rc
+ VBoxCAPI_INCS = \
+ 	$(CAPIHeaders_0_OUTDIR)
+ VBoxCAPI_INTERMEDIATES = \
+ 	$(CAPIHeaders_0_OUTDIR)/VBoxCAPI.h
+
+ #
+ # The C glue library.
+ #
+ LIBRARIES += VBoxCAPIGlue
+ VBoxCAPIGlue_TEMPLATE = VBoxMainExe
+ VBoxCAPIGlue_DEFS = IN_VBOXCAPI
+ VBoxCAPIGlue_SOURCES = \
+ 	VBoxCAPIGlue.c
+ ifdef VBOX_WITH_XPCOM
+  VBoxCAPIGlue_SOURCES += \
+  	$(VBOX_PATH_SDK)/bindings/xpcom/lib/VirtualBox_i.c
+ else
+  VBoxCAPIGlue_SOURCES += \
+  	$(VBOX_PATH_SDK)/bindings/mscom/lib/VirtualBox_i.c
+ endif
+ VBoxCAPIGlue_INCS = \
+ 	$(VBOX_PATH_SDK)/bindings/c/include \
+ 	$(VBOX_PATH_SDK)/bindings/c/glue
+ VBoxCAPIGlue_INTERMEDIATES = \
+ 	$(VBOX_PATH_SDK)/bindings/c/glue/VBoxCAPIGlue.h \
+ 	$(VBOX_PATH_SDK)/bindings/c/include/VBoxCAPI_v$(VBOX_API_VERSION).h
+
+ if defined(VBOX_WITH_TESTCASES) && "$(KBUILD_TARGET)" != "darwin"
+  #
+  # The testcase (also in samples).
+  # C testcase using the dynamic glue.
+  #
+  PROGRAMS += tstCAPIGlue
+  tstCAPIGlue_TEMPLATE = VBoxR3TstExe
+  tstCAPIGlue_INCS = \
+  	$(VBOX_PATH_SDK)/bindings/c/include \
+  	$(VBOX_PATH_SDK)/bindings/c/glue
+  ifdef VBOX_WITH_XPCOM
+   tstCAPIGlue_INCS += \
+   	$(VBOX_PATH_SDK)/bindings/xpcom/include
+  else
+   tstCAPIGlue_INCS += \
+   	$(VBOX_PATH_SDK)/bindings/mscom/include
+  endif
+  tstCAPIGlue_INTERMEDIATES = \
+  	$(VBOX_PATH_SDK)/bindings/c/glue/VBoxCAPIGlue.h \
+  	$(VBOX_PATH_SDK)/bindings/c/include/VBoxCAPI_v$(VBOX_API_VERSION).h \
+  	$(if-expr !defined(VBOX_WITH_XPCOM),$(VBOX_PATH_SDK)/bindings/mscom/include/VirtualBox.h,)
+  tstCAPIGlue_SOURCES = \
+  	tstCAPIGlue.c
+  tstCAPIGlue_LIBS = \
+  	$(VBoxCAPIGlue_1_TARGET)
+ endif
+
+endif # !VBOX_ONLY_SDK
+
+# generate rules.
+include $(FILE_KBUILD_SUB_FOOTER)
+
diff --git a/src/VBox/Main/cbinding/VBoxCAPI.cpp b/src/VBox/Main/cbinding/VBoxCAPI.cpp
new file mode 100644
index 00000000..52d951e1
--- /dev/null
+++ b/src/VBox/Main/cbinding/VBoxCAPI.cpp
@@ -0,0 +1,1023 @@
+/* $Id: VBoxCAPI.cpp $ */
+/** @file VBoxCAPI.cpp
+ * Utility functions to use with the C API binding.
+ */
+
+/*
+ * Copyright (C) 2009-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#define LOG_GROUP LOG_GROUP_MAIN
+
+#include "VBoxCAPI.h"
+
+#ifdef VBOX_WITH_XPCOM
+# include <nsMemory.h>
+# include <nsIServiceManager.h>
+# include <nsEventQueueUtils.h>
+# include <nsIExceptionService.h>
+# include <stdlib.h>
+#endif /* VBOX_WITH_XPCOM */
+
+#include <iprt/env.h>
+#include <iprt/err.h>
+#include <iprt/initterm.h>
+#include <iprt/mem.h>
+#include <iprt/string.h>
+#include <iprt/utf16.h>
+#include <iprt/uuid.h>
+#include <VBox/log.h>
+#include <VBox/version.h>
+
+#include "VBox/com/com.h"
+#include "VBox/com/NativeEventQueue.h"
+
+
+#ifndef RT_OS_DARWIN /* Probably not used for xpcom, so clang gets upset: error: using directive refers to implicitly-defined namespace 'std' [-Werror]*/
+using namespace std;
+#endif
+
+/* The following 2 object references should be eliminated once the legacy
+ * way to initialize the COM/XPCOM C bindings is removed. */
+static ISession            *g_Session           = NULL;
+static IVirtualBox         *g_VirtualBox        = NULL;
+
+#ifdef VBOX_WITH_XPCOM
+/* This object reference should be eliminated once the legacy way of handling
+ * the event queue (XPCOM specific) is removed. */
+static nsIEventQueue       *g_EventQueue        = NULL;
+#endif /* VBOX_WITH_XPCOM */
+
+static void VBoxComUninitialize(void);
+static void VBoxClientUninitialize(void);
+
+static int
+VBoxUtf16ToUtf8(CBSTR pwszString, char **ppszString)
+{
+    if (!pwszString)
+    {
+        *ppszString = NULL;
+        return VINF_SUCCESS;
+    }
+    return RTUtf16ToUtf8(pwszString, ppszString);
+}
+
+static int
+VBoxUtf8ToUtf16(const char *pszString, BSTR *ppwszString)
+{
+    *ppwszString = NULL;
+    if (!pszString)
+        return VINF_SUCCESS;
+#ifdef VBOX_WITH_XPCOM
+    return RTStrToUtf16(pszString, ppwszString);
+#else /* !VBOX_WITH_XPCOM */
+    PRTUTF16 pwsz;
+    int vrc = RTStrToUtf16(pszString, &pwsz);
+    if (RT_SUCCESS(vrc))
+    {
+        *ppwszString = ::SysAllocString(pwsz);
+        if (!*ppwszString)
+            vrc = VERR_NO_STR_MEMORY;
+        RTUtf16Free(pwsz);
+    }
+    return vrc;
+#endif /* !VBOX_WITH_XPCOM */
+}
+
+static void
+VBoxUtf8Clear(char *pszString)
+{
+    RT_BZERO(pszString, strlen(pszString));
+}
+
+static void
+VBoxUtf16Clear(BSTR pwszString)
+{
+    RT_BZERO(pwszString, RTUtf16Len(pwszString) * sizeof(RTUTF16));
+}
+
+static void
+VBoxUtf16Free(BSTR pwszString)
+{
+#ifdef VBOX_WITH_XPCOM
+    RTUtf16Free(pwszString);
+#else
+    ::SysFreeString(pwszString);
+#endif
+}
+
+static void
+VBoxUtf8Free(char *pszString)
+{
+    RTStrFree(pszString);
+}
+
+static void
+VBoxComUnallocString(BSTR pwsz)
+{
+    if (pwsz)
+    {
+#ifdef VBOX_WITH_XPCOM
+        nsMemory::Free(pwsz);
+#else
+        ::SysFreeString(pwsz);
+#endif
+    }
+}
+
+static void
+VBoxComUnallocMem(void *pv)
+{
+    VBoxComUnallocString((BSTR)pv);
+}
+
+static ULONG
+VBoxVTElemSize(VARTYPE vt)
+{
+    switch (vt)
+    {
+        case VT_BOOL:
+        case VT_I1:
+        case VT_UI1:
+            return 1;
+        case VT_I2:
+        case VT_UI2:
+            return 2;
+        case VT_I4:
+        case VT_UI4:
+        case VT_HRESULT:
+            return 4;
+        case VT_I8:
+        case VT_UI8:
+            return 8;
+        case VT_BSTR:
+        case VT_DISPATCH:
+        case VT_UNKNOWN:
+            return sizeof(void *);
+        default:
+            return 0;
+    }
+}
+
+static SAFEARRAY *
+VBoxSafeArrayCreateVector(VARTYPE vt, LONG lLbound, ULONG cElements)
+{
+#ifdef VBOX_WITH_XPCOM
+    NOREF(lLbound);
+    ULONG cbElement = VBoxVTElemSize(vt);
+    if (!cbElement)
+        return NULL;
+    SAFEARRAY *psa = (SAFEARRAY *)RTMemAllocZ(sizeof(SAFEARRAY));
+    if (!psa)
+        return psa;
+    if (cElements)
+    {
+        void *pv = nsMemory::Alloc(cElements * cbElement);
+        if (!pv)
+        {
+            RTMemFree(psa);
+            return NULL;
+        }
+        psa->pv = pv;
+        psa->c = cElements;
+    }
+    return psa;
+#else /* !VBOX_WITH_XPCOM */
+    return SafeArrayCreateVector(vt, lLbound, cElements);
+#endif /* !VBOX_WITH_XPCOM */
+}
+
+static SAFEARRAY *
+VBoxSafeArrayOutParamAlloc(void)
+{
+#ifdef VBOX_WITH_XPCOM
+    return (SAFEARRAY *)RTMemAllocZ(sizeof(SAFEARRAY));
+#else /* !VBOX_WITH_XPCOM */
+    return NULL;
+#endif /* !VBOX_WITH_XPCOM */
+}
+
+static HRESULT
+VBoxSafeArrayDestroy(SAFEARRAY *psa)
+{
+#ifdef VBOX_WITH_XPCOM
+    if (psa)
+    {
+        if (psa->pv)
+            nsMemory::Free(psa->pv);
+        RTMemFree(psa);
+    }
+    return S_OK;
+#else /* !VBOX_WITH_XPCOM */
+    VARTYPE vt = VT_UNKNOWN;
+    HRESULT hrc = SafeArrayGetVartype(psa, &vt);
+    if (FAILED(hrc))
+        return hrc;
+    if (vt == VT_BSTR)
+    {
+        /* Special treatment: strings are to be freed explicitly, see sample
+         * C binding code, so zap it here. No way to reach compatible code
+         * behavior between COM and XPCOM without this kind of trickery. */
+        void *pData;
+        hrc = SafeArrayAccessData(psa, &pData);
+        if (FAILED(hrc))
+            return hrc;
+        ULONG cbElement = VBoxVTElemSize(vt);
+        if (!cbElement)
+            return E_INVALIDARG;
+        Assert(cbElement = psa->cbElements);
+        ULONG cElements = psa->rgsabound[0].cElements;
+        memset(pData, '\0', cbElement * cElements);
+        SafeArrayUnaccessData(psa);
+    }
+    return SafeArrayDestroy(psa);
+#endif /* !VBOX_WITH_XPCOM */
+}
+
+static HRESULT
+VBoxSafeArrayCopyInParamHelper(SAFEARRAY *psa, const void *pv, ULONG cb)
+{
+    if (!pv || !psa)
+        return E_POINTER;
+    if (!cb)
+        return S_OK;
+
+    void *pData;
+#ifdef VBOX_WITH_XPCOM
+    pData = psa->pv;
+#else /* !VBOX_WITH_XPCOM */
+    HRESULT hrc = SafeArrayAccessData(psa, &pData);
+    if (FAILED(hrc))
+        return hrc;
+#endif /* !VBOX_WITH_XPCOM */
+    memcpy(pData, pv, cb);
+#ifndef VBOX_WITH_XPCOM
+    SafeArrayUnaccessData(psa);
+#endif
+    return S_OK;
+}
+
+static HRESULT
+VBoxSafeArrayCopyOutParamHelper(void **ppv, ULONG *pcb, VARTYPE vt, SAFEARRAY *psa)
+{
+    if (!ppv)
+        return E_POINTER;
+    ULONG cbElement = VBoxVTElemSize(vt);
+    if (!cbElement)
+    {
+        *ppv = NULL;
+        if (pcb)
+            *pcb = 0;
+        return E_INVALIDARG;
+    }
+#ifndef VBOX_WITH_XPCOM
+    if (psa->cDims != 1)
+    {
+        *ppv = NULL;
+        if (pcb)
+            *pcb = 0;
+        return E_INVALIDARG;
+    }
+    Assert(cbElement = psa->cbElements);
+#endif /* !VBOX_WITH_XPCOM */
+    void *pData;
+    ULONG cElements;
+#ifdef VBOX_WITH_XPCOM
+    pData = psa->pv;
+    cElements = psa->c;
+#else /* !VBOX_WITH_XPCOM */
+    HRESULT hrc = SafeArrayAccessData(psa, &pData);
+    if (FAILED(hrc))
+    {
+        *ppv = NULL;
+        if (pcb)
+            *pcb = 0;
+        return hrc;
+    }
+    cElements = psa->rgsabound[0].cElements;
+#endif /* !VBOX_WITH_XPCOM */
+    size_t cbTotal = cbElement * cElements;
+    void *pv = NULL;
+    if (cbTotal)
+    {
+        pv = malloc(cbTotal);
+        if (!pv)
+        {
+            *ppv = NULL;
+            if (pcb)
+                *pcb = 0;
+            return E_OUTOFMEMORY;
+        }
+        else
+            memcpy(pv, pData, cbTotal);
+    }
+    *ppv = pv;
+    if (pcb)
+        *pcb = (ULONG)cbTotal;
+#ifndef VBOX_WITH_XPCOM
+    SafeArrayUnaccessData(psa);
+#endif
+    return S_OK;
+}
+
+static HRESULT
+VBoxSafeArrayCopyOutIfaceParamHelper(IUnknown ***ppaObj, ULONG *pcObj, SAFEARRAY *psa)
+{
+    ULONG mypcb;
+    HRESULT hrc = VBoxSafeArrayCopyOutParamHelper((void **)ppaObj, &mypcb, VT_UNKNOWN, psa);
+    if (FAILED(hrc))
+    {
+        if (pcObj)
+            *pcObj = 0;
+        return hrc;
+    }
+    ULONG cElements = mypcb / sizeof(void *);
+    if (pcObj)
+        *pcObj = cElements;
+#ifndef VBOX_WITH_XPCOM
+    /* Do this only for COM, as there the SAFEARRAY destruction will release
+     * the contained references automatically. XPCOM doesn't do that, which
+     * means that copying implicitly transfers ownership. */
+    IUnknown **paObj = *ppaObj;
+    for (ULONG i = 0; i < cElements; i++)
+    {
+        IUnknown *pObj = paObj[i];
+        if (pObj)
+            pObj->AddRef();
+    }
+#endif /* VBOX_WITH_XPCOM */
+    return S_OK;
+}
+
+static HRESULT
+VBoxArrayOutFree(void *pv)
+{
+    free(pv);
+    return S_OK;
+}
+
+static void
+VBoxComInitialize(const char *pszVirtualBoxIID, IVirtualBox **ppVirtualBox,
+                  const char *pszSessionIID, ISession **ppSession)
+{
+    int vrc;
+    IID virtualBoxIID;
+    IID sessionIID;
+
+    *ppSession    = NULL;
+    *ppVirtualBox = NULL;
+
+    /* convert the string representation of the UUIDs (if provided) to IID */
+    if (pszVirtualBoxIID && *pszVirtualBoxIID)
+    {
+        vrc = ::RTUuidFromStr((RTUUID *)&virtualBoxIID, pszVirtualBoxIID);
+        if (RT_FAILURE(vrc))
+            return;
+    }
+    else
+        virtualBoxIID = IID_IVirtualBox;
+    if (pszSessionIID && *pszSessionIID)
+    {
+        vrc = ::RTUuidFromStr((RTUUID *)&sessionIID, pszSessionIID);
+        if (RT_FAILURE(vrc))
+            return;
+    }
+    else
+        sessionIID = IID_ISession;
+
+    HRESULT hrc = com::Initialize(VBOX_COM_INIT_F_DEFAULT | VBOX_COM_INIT_F_NO_COM_PATCHING);
+    if (FAILED(hrc))
+    {
+        Log(("Cbinding: COM/XPCOM could not be initialized! hrc=%Rhrc\n", hrc));
+        VBoxComUninitialize();
+        return;
+    }
+
+#ifdef VBOX_WITH_XPCOM
+    hrc = NS_GetMainEventQ(&g_EventQueue);
+    if (FAILED(hrc))
+    {
+        Log(("Cbinding: Could not get XPCOM event queue! hrc=%Rhrc\n", hrc));
+        VBoxComUninitialize();
+        return;
+    }
+#endif /* VBOX_WITH_XPCOM */
+
+#ifdef VBOX_WITH_XPCOM
+    nsIComponentManager *pManager;
+    hrc = NS_GetComponentManager(&pManager);
+    if (FAILED(hrc))
+    {
+        Log(("Cbinding: Could not get component manager! hrc=%Rhrc\n", hrc));
+        VBoxComUninitialize();
+        return;
+    }
+
+    hrc = pManager->CreateInstanceByContractID(NS_VIRTUALBOX_CONTRACTID,
+                                               nsnull,
+                                               virtualBoxIID,
+                                               (void **)&g_VirtualBox);
+#else /* !VBOX_WITH_XPCOM */
+    IVirtualBoxClient *pVirtualBoxClient;
+    hrc = CoCreateInstance(CLSID_VirtualBoxClient, NULL, CLSCTX_INPROC_SERVER, IID_IVirtualBoxClient, (void **)&pVirtualBoxClient);
+    if (SUCCEEDED(hrc))
+    {
+        IVirtualBox *pVirtualBox;
+        hrc = pVirtualBoxClient->get_VirtualBox(&pVirtualBox);
+        if (SUCCEEDED(hrc))
+        {
+            hrc = pVirtualBox->QueryInterface(virtualBoxIID, (void **)&g_VirtualBox);
+            pVirtualBox->Release();
+        }
+        pVirtualBoxClient->Release();
+    }
+#endif /* !VBOX_WITH_XPCOM */
+    if (FAILED(hrc))
+    {
+        Log(("Cbinding: Could not instantiate VirtualBox object! hrc=%Rhrc\n",hrc));
+#ifdef VBOX_WITH_XPCOM
+        pManager->Release();
+        pManager = NULL;
+#endif /* VBOX_WITH_XPCOM */
+        VBoxComUninitialize();
+        return;
+    }
+
+    Log(("Cbinding: IVirtualBox object created.\n"));
+
+#ifdef VBOX_WITH_XPCOM
+    hrc = pManager->CreateInstanceByContractID(NS_SESSION_CONTRACTID, nsnull, sessionIID, (void **)&g_Session);
+#else /* !VBOX_WITH_XPCOM */
+    hrc = CoCreateInstance(CLSID_Session, NULL, CLSCTX_INPROC_SERVER, sessionIID, (void **)&g_Session);
+#endif /* !VBOX_WITH_XPCOM */
+    if (FAILED(hrc))
+    {
+        Log(("Cbinding: Could not instantiate Session object! hrc=%Rhrc\n",hrc));
+#ifdef VBOX_WITH_XPCOM
+        pManager->Release();
+        pManager = NULL;
+#endif /* VBOX_WITH_XPCOM */
+        VBoxComUninitialize();
+        return;
+    }
+
+    Log(("Cbinding: ISession object created.\n"));
+
+#ifdef VBOX_WITH_XPCOM
+    pManager->Release();
+    pManager = NULL;
+#endif /* VBOX_WITH_XPCOM */
+
+    *ppSession = g_Session;
+    *ppVirtualBox = g_VirtualBox;
+}
+
+static void
+VBoxComInitializeV1(IVirtualBox **ppVirtualBox, ISession **ppSession)
+{
+    VBoxComInitialize(NULL, ppVirtualBox, NULL, ppSession);
+}
+
+static void
+VBoxComUninitialize(void)
+{
+    if (g_Session)
+    {
+        g_Session->Release();
+        g_Session = NULL;
+    }
+    if (g_VirtualBox)
+    {
+        g_VirtualBox->Release();
+        g_VirtualBox = NULL;
+    }
+#ifdef VBOX_WITH_XPCOM
+    if (g_EventQueue)
+    {
+        g_EventQueue->Release();
+        g_EventQueue = NULL;
+    }
+#endif /* VBOX_WITH_XPCOM */
+    com::Shutdown();
+    Log(("Cbinding: Cleaned up the created objects.\n"));
+}
+
+#ifdef VBOX_WITH_XPCOM
+static void
+VBoxGetEventQueue(nsIEventQueue **ppEventQueue)
+{
+    *ppEventQueue = g_EventQueue;
+}
+#endif /* VBOX_WITH_XPCOM */
+
+static int
+VBoxProcessEventQueue(LONG64 iTimeoutMS)
+{
+    RTMSINTERVAL iTimeout;
+    if (iTimeoutMS < 0 || iTimeoutMS > UINT32_MAX)
+        iTimeout = RT_INDEFINITE_WAIT;
+    else
+        iTimeout = (RTMSINTERVAL)iTimeoutMS;
+    int vrc = com::NativeEventQueue::getMainEventQueue()->processEventQueue(iTimeout);
+    switch (vrc)
+    {
+        case VINF_SUCCESS:
+            return 0;
+        case VINF_INTERRUPTED:
+            return 1;
+        case VERR_INTERRUPTED:
+            return 2;
+        case VERR_TIMEOUT:
+            return 3;
+        case VERR_INVALID_CONTEXT:
+            return 4;
+        default:
+            return 5;
+    }
+}
+
+static int
+VBoxInterruptEventQueueProcessing(void)
+{
+    com::NativeEventQueue::getMainEventQueue()->interruptEventQueueProcessing();
+    return 0;
+}
+
+static HRESULT
+VBoxGetException(IErrorInfo **ppException)
+{
+    HRESULT hrc;
+
+    *ppException = NULL;
+
+#ifdef VBOX_WITH_XPCOM
+    nsIServiceManager *mgr = NULL;
+    hrc = NS_GetServiceManager(&mgr);
+    if (FAILED(hrc) || !mgr)
+        return hrc;
+
+    IID esid = NS_IEXCEPTIONSERVICE_IID;
+    nsIExceptionService *es = NULL;
+    hrc = mgr->GetServiceByContractID(NS_EXCEPTIONSERVICE_CONTRACTID, esid, (void **)&es);
+    if (FAILED(hrc) || !es)
+    {
+        mgr->Release();
+        return hrc;
+    }
+
+    nsIExceptionManager *em;
+    hrc = es->GetCurrentExceptionManager(&em);
+    if (FAILED(hrc) || !em)
+    {
+        es->Release();
+        mgr->Release();
+        return hrc;
+    }
+
+    nsIException *ex;
+    hrc = em->GetCurrentException(&ex);
+    if (FAILED(hrc))
+    {
+        em->Release();
+        es->Release();
+        mgr->Release();
+        return hrc;
+    }
+
+    *ppException = ex;
+    em->Release();
+    es->Release();
+    mgr->Release();
+#else /* !VBOX_WITH_XPCOM */
+    IErrorInfo *ex;
+    hrc = ::GetErrorInfo(0, &ex);
+    if (FAILED(hrc))
+        return hrc;
+
+    *ppException = ex;
+#endif /* !VBOX_WITH_XPCOM */
+
+    return hrc;
+}
+
+static HRESULT
+VBoxClearException(void)
+{
+    HRESULT hrc;
+
+#ifdef VBOX_WITH_XPCOM
+    nsIServiceManager *mgr = NULL;
+    hrc = NS_GetServiceManager(&mgr);
+    if (FAILED(hrc) || !mgr)
+        return hrc;
+
+    IID esid = NS_IEXCEPTIONSERVICE_IID;
+    nsIExceptionService *es = NULL;
+    hrc = mgr->GetServiceByContractID(NS_EXCEPTIONSERVICE_CONTRACTID, esid, (void **)&es);
+    if (FAILED(hrc) || !es)
+    {
+        mgr->Release();
+        return hrc;
+    }
+
+    nsIExceptionManager *em;
+    hrc = es->GetCurrentExceptionManager(&em);
+    if (FAILED(hrc) || !em)
+    {
+        es->Release();
+        mgr->Release();
+        return hrc;
+    }
+
+    hrc = em->SetCurrentException(NULL);
+    em->Release();
+    es->Release();
+    mgr->Release();
+#else /* !VBOX_WITH_XPCOM */
+    hrc = ::SetErrorInfo(0, NULL);
+#endif /* !VBOX_WITH_XPCOM */
+
+    return hrc;
+}
+
+static HRESULT
+VBoxClientInitialize(const char *pszVirtualBoxClientIID, IVirtualBoxClient **ppVirtualBoxClient)
+{
+    IID virtualBoxClientIID;
+
+    *ppVirtualBoxClient = NULL;
+
+    /* convert the string representation of UUID to IID type */
+    if (pszVirtualBoxClientIID && *pszVirtualBoxClientIID)
+    {
+        int vrc = ::RTUuidFromStr((RTUUID *)&virtualBoxClientIID, pszVirtualBoxClientIID);
+        if (RT_FAILURE(vrc))
+            return E_INVALIDARG;
+    }
+    else
+        virtualBoxClientIID = IID_IVirtualBoxClient;
+
+    HRESULT hrc = com::Initialize(VBOX_COM_INIT_F_DEFAULT | VBOX_COM_INIT_F_NO_COM_PATCHING);
+    if (FAILED(hrc))
+    {
+        Log(("Cbinding: COM/XPCOM could not be initialized! hrc=%Rhrc\n", hrc));
+        VBoxClientUninitialize();
+        return hrc;
+    }
+
+#ifdef VBOX_WITH_XPCOM
+    hrc = NS_GetMainEventQ(&g_EventQueue);
+    if (NS_FAILED(hrc))
+    {
+        Log(("Cbinding: Could not get XPCOM event queue! hrc=%Rhrc\n", hrc));
+        VBoxClientUninitialize();
+        return hrc;
+    }
+#endif /* VBOX_WITH_XPCOM */
+
+#ifdef VBOX_WITH_XPCOM
+    nsIComponentManager *pManager;
+    hrc = NS_GetComponentManager(&pManager);
+    if (FAILED(hrc))
+    {
+        Log(("Cbinding: Could not get component manager! hrc=%Rhrc\n", hrc));
+        VBoxClientUninitialize();
+        return hrc;
+    }
+
+    hrc = pManager->CreateInstanceByContractID(NS_VIRTUALBOXCLIENT_CONTRACTID,
+                                               nsnull,
+                                               virtualBoxClientIID,
+                                               (void **)ppVirtualBoxClient);
+#else /* !VBOX_WITH_XPCOM */
+    hrc = CoCreateInstance(CLSID_VirtualBoxClient, NULL, CLSCTX_INPROC_SERVER, virtualBoxClientIID, (void **)ppVirtualBoxClient);
+#endif /* !VBOX_WITH_XPCOM */
+    if (FAILED(hrc))
+    {
+        Log(("Cbinding: Could not instantiate VirtualBoxClient object! hrc=%Rhrc\n",hrc));
+#ifdef VBOX_WITH_XPCOM
+        pManager->Release();
+        pManager = NULL;
+#endif /* VBOX_WITH_XPCOM */
+        VBoxClientUninitialize();
+        return hrc;
+    }
+
+#ifdef VBOX_WITH_XPCOM
+    pManager->Release();
+    pManager = NULL;
+#endif /* VBOX_WITH_XPCOM */
+
+    Log(("Cbinding: IVirtualBoxClient object created.\n"));
+
+    return S_OK;
+}
+
+static HRESULT
+VBoxClientThreadInitialize(void)
+{
+    return com::Initialize(VBOX_COM_INIT_F_DEFAULT | VBOX_COM_INIT_F_NO_COM_PATCHING);
+}
+
+static HRESULT
+VBoxClientThreadUninitialize(void)
+{
+    return com::Shutdown();
+}
+
+static void
+VBoxClientUninitialize(void)
+{
+#ifdef VBOX_WITH_XPCOM
+    if (g_EventQueue)
+    {
+        NS_RELEASE(g_EventQueue);
+        g_EventQueue = NULL;
+    }
+#endif /* VBOX_WITH_XPCOM */
+    com::Shutdown();
+    Log(("Cbinding: Cleaned up the created objects.\n"));
+}
+
+static unsigned int
+VBoxVersion(void)
+{
+    return VBOX_VERSION_MAJOR * 1000 * 1000 + VBOX_VERSION_MINOR * 1000 + VBOX_VERSION_BUILD;
+}
+
+static unsigned int
+VBoxAPIVersion(void)
+{
+    return VBOX_VERSION_MAJOR * 1000 + VBOX_VERSION_MINOR + (VBOX_VERSION_BUILD > 50 ? 1 : 0);
+}
+
+VBOXCAPI_DECL(PCVBOXCAPI)
+VBoxGetCAPIFunctions(unsigned uVersion)
+{
+    /* This is the first piece of code which knows that IPRT exists, so
+     * initialize it properly. The limited initialization in VBoxC is not
+     * sufficient, and causes trouble with com::Initialize() misbehaving. */
+    RTR3InitDll(0);
+
+    /*
+     * The current interface version.
+     */
+    static const VBOXCAPI s_Functions =
+    {
+        sizeof(VBOXCAPI),
+        VBOX_CAPI_VERSION,
+
+        VBoxVersion,
+        VBoxAPIVersion,
+
+        VBoxClientInitialize,
+        VBoxClientThreadInitialize,
+        VBoxClientThreadUninitialize,
+        VBoxClientUninitialize,
+
+        VBoxComInitialize,
+        VBoxComUninitialize,
+
+        VBoxComUnallocString,
+
+        VBoxUtf16ToUtf8,
+        VBoxUtf8ToUtf16,
+        VBoxUtf8Free,
+        VBoxUtf16Free,
+
+        VBoxSafeArrayCreateVector,
+        VBoxSafeArrayOutParamAlloc,
+        VBoxSafeArrayCopyInParamHelper,
+        VBoxSafeArrayCopyOutParamHelper,
+        VBoxSafeArrayCopyOutIfaceParamHelper,
+        VBoxSafeArrayDestroy,
+        VBoxArrayOutFree,
+
+#ifdef VBOX_WITH_XPCOM
+        VBoxGetEventQueue,
+#endif /* VBOX_WITH_XPCOM */
+        VBoxGetException,
+        VBoxClearException,
+        VBoxProcessEventQueue,
+        VBoxInterruptEventQueueProcessing,
+
+        VBoxUtf8Clear,
+        VBoxUtf16Clear,
+
+        VBOX_CAPI_VERSION
+    };
+
+    if ((uVersion & 0xffff0000U) == (VBOX_CAPI_VERSION & 0xffff0000U))
+        return &s_Functions;
+
+    /*
+     * Legacy interface version 3.0.
+     */
+    static const struct VBOXCAPIV3
+    {
+        /** The size of the structure. */
+        unsigned cb;
+        /** The structure version. */
+        unsigned uVersion;
+
+        unsigned int (*pfnGetVersion)(void);
+
+        unsigned int (*pfnGetAPIVersion)(void);
+
+        HRESULT (*pfnClientInitialize)(const char *pszVirtualBoxClientIID,
+                                       IVirtualBoxClient **ppVirtualBoxClient);
+        void (*pfnClientUninitialize)(void);
+
+        void (*pfnComInitialize)(const char *pszVirtualBoxIID,
+                                 IVirtualBox **ppVirtualBox,
+                                 const char *pszSessionIID,
+                                 ISession **ppSession);
+
+        void (*pfnComUninitialize)(void);
+
+        void (*pfnComUnallocMem)(void *pv);
+
+        int (*pfnUtf16ToUtf8)(CBSTR pwszString, char **ppszString);
+        int (*pfnUtf8ToUtf16)(const char *pszString, BSTR *ppwszString);
+        void (*pfnUtf8Free)(char *pszString);
+        void (*pfnUtf16Free)(BSTR pwszString);
+
+#ifdef VBOX_WITH_XPCOM
+        void (*pfnGetEventQueue)(nsIEventQueue **ppEventQueue);
+#endif /* VBOX_WITH_XPCOM */
+        HRESULT (*pfnGetException)(IErrorInfo **ppException);
+        HRESULT (*pfnClearException)(void);
+
+        /** Tail version, same as uVersion. */
+        unsigned uEndVersion;
+    } s_Functions_v3_0 =
+    {
+        sizeof(s_Functions_v3_0),
+        0x00030000U,
+
+        VBoxVersion,
+        VBoxAPIVersion,
+
+        VBoxClientInitialize,
+        VBoxClientUninitialize,
+
+        VBoxComInitialize,
+        VBoxComUninitialize,
+
+        VBoxComUnallocMem,
+
+        VBoxUtf16ToUtf8,
+        VBoxUtf8ToUtf16,
+        VBoxUtf8Free,
+        VBoxUtf16Free,
+
+#ifdef VBOX_WITH_XPCOM
+        VBoxGetEventQueue,
+#endif /* VBOX_WITH_XPCOM */
+        VBoxGetException,
+        VBoxClearException,
+
+        0x00030000U
+    };
+
+    if ((uVersion & 0xffff0000U) == 0x00030000U)
+        return (PCVBOXCAPI)&s_Functions_v3_0;
+
+    /*
+     * Legacy interface version 2.0.
+     */
+    static const struct VBOXCAPIV2
+    {
+        /** The size of the structure. */
+        unsigned cb;
+        /** The structure version. */
+        unsigned uVersion;
+
+        unsigned int (*pfnGetVersion)(void);
+
+        void (*pfnComInitialize)(const char *pszVirtualBoxIID,
+                                 IVirtualBox **ppVirtualBox,
+                                 const char *pszSessionIID,
+                                 ISession **ppSession);
+
+        void (*pfnComUninitialize)(void);
+
+        void (*pfnComUnallocMem)(void *pv);
+        void (*pfnUtf16Free)(BSTR pwszString);
+        void (*pfnUtf8Free)(char *pszString);
+
+        int (*pfnUtf16ToUtf8)(CBSTR pwszString, char **ppszString);
+        int (*pfnUtf8ToUtf16)(const char *pszString, BSTR *ppwszString);
+
+#ifdef VBOX_WITH_XPCOM
+        void (*pfnGetEventQueue)(nsIEventQueue **ppEventQueue);
+#endif /* VBOX_WITH_XPCOM */
+
+        /** Tail version, same as uVersion. */
+        unsigned uEndVersion;
+    } s_Functions_v2_0 =
+    {
+        sizeof(s_Functions_v2_0),
+        0x00020000U,
+
+        VBoxVersion,
+
+        VBoxComInitialize,
+        VBoxComUninitialize,
+
+        VBoxComUnallocMem,
+        VBoxUtf16Free,
+        VBoxUtf8Free,
+
+        VBoxUtf16ToUtf8,
+        VBoxUtf8ToUtf16,
+
+#ifdef VBOX_WITH_XPCOM
+        VBoxGetEventQueue,
+#endif /* VBOX_WITH_XPCOM */
+
+        0x00020000U
+    };
+
+    if ((uVersion & 0xffff0000U) == 0x00020000U)
+        return (PCVBOXCAPI)&s_Functions_v2_0;
+
+    /*
+     * Legacy interface version 1.0.
+     */
+    static const struct VBOXCAPIV1
+    {
+        /** The size of the structure. */
+        unsigned cb;
+        /** The structure version. */
+        unsigned uVersion;
+
+        unsigned int (*pfnGetVersion)(void);
+
+        void (*pfnComInitialize)(IVirtualBox **virtualBox, ISession **session);
+        void (*pfnComUninitialize)(void);
+
+        void (*pfnComUnallocMem)(void *pv);
+        void (*pfnUtf16Free)(BSTR pwszString);
+        void (*pfnUtf8Free)(char *pszString);
+
+        int (*pfnUtf16ToUtf8)(CBSTR pwszString, char **ppszString);
+        int (*pfnUtf8ToUtf16)(const char *pszString, BSTR *ppwszString);
+
+        /** Tail version, same as uVersion. */
+        unsigned uEndVersion;
+    } s_Functions_v1_0 =
+    {
+        sizeof(s_Functions_v1_0),
+        0x00010000U,
+
+        VBoxVersion,
+
+        VBoxComInitializeV1,
+        VBoxComUninitialize,
+
+        VBoxComUnallocMem,
+        VBoxUtf16Free,
+        VBoxUtf8Free,
+
+        VBoxUtf16ToUtf8,
+        VBoxUtf8ToUtf16,
+
+        0x00010000U
+    };
+
+    if ((uVersion & 0xffff0000U) == 0x00010000U)
+        return (PCVBOXCAPI)&s_Functions_v1_0;
+
+    /*
+     * Unsupported interface version.
+     */
+    return NULL;
+}
+
+#ifdef VBOX_WITH_XPCOM
+VBOXCAPI_DECL(PCVBOXCAPI)
+VBoxGetXPCOMCFunctions(unsigned uVersion)
+{
+    return VBoxGetCAPIFunctions(uVersion);
+}
+#endif /* VBOX_WITH_XPCOM */
+/* vim: set ts=4 sw=4 et: */
diff --git a/src/VBox/Main/cbinding/VBoxCAPI.rc b/src/VBox/Main/cbinding/VBoxCAPI.rc
new file mode 100644
index 00000000..59fe2115
--- /dev/null
+++ b/src/VBox/Main/cbinding/VBoxCAPI.rc
@@ -0,0 +1,61 @@
+/* $Id: VBoxCAPI.rc $ */
+/** @file
+ * VBoxCAPI - Resource file containing version info.
+ */
+
+/*
+ * Copyright (C) 2015-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+#include <windows.h>
+#include <VBox/version.h>
+
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+
+VS_VERSION_INFO VERSIONINFO
+  FILEVERSION      VBOX_RC_FILE_VERSION
+  PRODUCTVERSION   VBOX_RC_FILE_VERSION
+  FILEFLAGSMASK    VS_FFI_FILEFLAGSMASK
+  FILEFLAGS        VBOX_RC_FILE_FLAGS
+  FILEOS           VBOX_RC_FILE_OS
+  FILETYPE         VBOX_RC_TYPE_DLL
+  FILESUBTYPE      VFT2_UNKNOWN
+BEGIN
+  BLOCK "StringFileInfo"
+  BEGIN
+    BLOCK "040904b0" // Lang=US English, CharSet=Unicode
+    BEGIN
+      VALUE "FileDescription",  "VirtualBox C Bindings\0"
+      VALUE "InternalName",     "VBoxCAPI\0"
+      VALUE "OriginalFilename", "VBoxCAPI.dll\0"
+      VALUE "CompanyName",      VBOX_RC_COMPANY_NAME
+      VALUE "FileVersion",      VBOX_RC_FILE_VERSION_STR
+      VALUE "LegalCopyright",   VBOX_RC_LEGAL_COPYRIGHT
+      VALUE "ProductName",      VBOX_RC_PRODUCT_NAME_STR
+      VALUE "ProductVersion",   VBOX_RC_PRODUCT_VERSION_STR
+      VBOX_RC_MORE_STRINGS
+    END
+  END
+  BLOCK "VarFileInfo"
+  BEGIN
+    VALUE "Translation", 0x409, 1200
+  END
+END
diff --git a/src/VBox/Main/cbinding/VBoxCAPIGlue.c b/src/VBox/Main/cbinding/VBoxCAPIGlue.c
new file mode 100644
index 00000000..476bfddf
--- /dev/null
+++ b/src/VBox/Main/cbinding/VBoxCAPIGlue.c
@@ -0,0 +1,345 @@
+/* $Id: VBoxCAPIGlue.c $ */
+/** @file
+ * Glue code for dynamically linking to VBoxCAPI.
+ */
+
+/*
+ * Copyright (C) 2008-2023 Oracle and/or its affiliates.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+/* NOTE: do NOT use any include files here which are only available in the
+ * VirtualBox tree, e.g. iprt. They are not available in the SDK, which is
+ * where this file will provided as source code and has to be compilable. */
+#include "VBoxCAPIGlue.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#ifdef WIN32
+# define _INTPTR 2 /* on Windows stdint.h compares this in #if, causing warnings if not defined */
+#endif /* WIN32 */
+#include <stdint.h>
+#ifndef WIN32
+# include <dlfcn.h>
+# include <pthread.h>
+#else /* WIN32 */
+# include <Windows.h>
+#endif /* WIN32 */
+
+
+/*********************************************************************************************************************************
+*   Defined Constants And Macros                                                                                                 *
+*********************************************************************************************************************************/
+#if defined(__linux__) || defined(__linux_gnu__) || defined(__sun__) || defined(__FreeBSD__)
+# define DYNLIB_NAME        "VBoxXPCOMC.so"
+#elif defined(__APPLE__)
+# define DYNLIB_NAME        "VBoxXPCOMC.dylib"
+#elif defined(__OS2__)
+# define DYNLIB_NAME        "VBoxXPCOMC.dll"
+#elif defined(WIN32)
+# define DYNLIB_NAME        "VBoxCAPI.dll"
+#else
+# error "Port me"
+#endif
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+/** The so/dynsym/dll handle for VBoxCAPI. */
+#ifndef WIN32
+void *g_hVBoxCAPI = NULL;
+#else /* WIN32 */
+HMODULE g_hVBoxCAPI = NULL;
+#endif /* WIN32 */
+/** The last load error. */
+char g_szVBoxErrMsg[256] = "";
+/** Pointer to the VBOXCAPI function table. */
+PCVBOXCAPI g_pVBoxFuncs = NULL;
+/** Pointer to VBoxGetCAPIFunctions for the loaded VBoxCAPI so/dylib/dll. */
+PFNVBOXGETCAPIFUNCTIONS g_pfnGetFunctions = NULL;
+
+typedef void FNDUMMY(void);
+typedef FNDUMMY *PFNDUMMY;
+/** Just a dummy global structure containing a bunch of
+ * function pointers to code which is wanted in the link. */
+PFNDUMMY g_apfnVBoxCAPIGlue[] =
+{
+#ifndef WIN32
+    /* The following link dependency is for helping gdb as it gets hideously
+     * confused if the application doesn't drag in pthreads, but uses it. */
+    (PFNDUMMY)pthread_create,
+#endif /* !WIN32 */
+    NULL
+};
+
+
+/**
+ * Wrapper for setting g_szVBoxErrMsg. Can be an empty stub.
+ *
+ * @param   fAlways         When 0 the g_szVBoxErrMsg is only set if empty.
+ * @param   pszFormat       The format string.
+ * @param   ...             The arguments.
+ */
+static void setErrMsg(int fAlways, const char *pszFormat, ...)
+{
+    if (    fAlways
+        ||  !g_szVBoxErrMsg[0])
+    {
+        va_list va;
+        va_start(va, pszFormat);
+        vsnprintf(g_szVBoxErrMsg, sizeof(g_szVBoxErrMsg), pszFormat, va);
+        va_end(va);
+    }
+}
+
+
+/**
+ * Try load C API .so/dylib/dll from the specified location and resolve all
+ * the symbols we need. Tries both the new style and legacy name.
+ *
+ * @returns 0 on success, -1 on failure.
+ * @param   pszHome         The directory where to try load VBoxCAPI/VBoxXPCOMC
+ *                          from. Can be NULL.
+ * @param   fSetAppHome     Whether to set the VBOX_APP_HOME env.var. or not
+ *                          (boolean).
+ */
+static int tryLoadLibrary(const char *pszHome, int fSetAppHome)
+{
+    size_t      cchHome = pszHome ? strlen(pszHome) : 0;
+    size_t      cbBufNeeded;
+    char        szName[4096];
+
+    /*
+     * Construct the full name.
+     */
+    cbBufNeeded = cchHome + sizeof("/" DYNLIB_NAME);
+    if (cbBufNeeded > sizeof(szName))
+    {
+        setErrMsg(1, "path buffer too small: %u bytes needed",
+                  (unsigned)cbBufNeeded);
+        return -1;
+    }
+    if (cchHome)
+    {
+        memcpy(szName, pszHome, cchHome);
+        szName[cchHome] = '/';
+        cchHome++;
+    }
+    memcpy(&szName[cchHome], DYNLIB_NAME, sizeof(DYNLIB_NAME));
+
+    /*
+     * Try load it by that name, setting the VBOX_APP_HOME first (for now).
+     * Then resolve and call the function table getter.
+     */
+    if (fSetAppHome)
+    {
+#ifndef WIN32
+        if (pszHome)
+            setenv("VBOX_APP_HOME", pszHome, 1 /* always override */);
+        else
+            unsetenv("VBOX_APP_HOME");
+#endif /* !WIN32 */
+    }
+
+#ifndef WIN32
+    g_hVBoxCAPI = dlopen(szName, RTLD_NOW | RTLD_LOCAL);
+#else /* WIN32 */
+    g_hVBoxCAPI = LoadLibraryExA(szName, NULL /* hFile */, 0 /* dwFlags */);
+#endif /* WIN32 */
+    if (g_hVBoxCAPI)
+    {
+        PFNVBOXGETCAPIFUNCTIONS pfnGetFunctions;
+#ifndef WIN32
+        pfnGetFunctions = (PFNVBOXGETCAPIFUNCTIONS)(uintptr_t)
+            dlsym(g_hVBoxCAPI, VBOX_GET_CAPI_FUNCTIONS_SYMBOL_NAME);
+# ifdef VBOX_GET_XPCOM_FUNCTIONS_SYMBOL_NAME
+        if (!pfnGetFunctions)
+            pfnGetFunctions = (PFNVBOXGETCAPIFUNCTIONS)(uintptr_t)
+                dlsym(g_hVBoxCAPI, VBOX_GET_XPCOM_FUNCTIONS_SYMBOL_NAME);
+# endif /* VBOX_GET_XPCOM_FUNCTIONS_SYMBOL_NAME */
+#else /* WIN32 */
+        pfnGetFunctions = (PFNVBOXGETCAPIFUNCTIONS)
+            GetProcAddress(g_hVBoxCAPI, VBOX_GET_CAPI_FUNCTIONS_SYMBOL_NAME);
+#endif /* WIN32 */
+        if (pfnGetFunctions)
+        {
+            g_pVBoxFuncs = pfnGetFunctions(VBOX_CAPI_VERSION);
+            if (g_pVBoxFuncs)
+            {
+                if (   (   VBOX_CAPI_MAJOR(g_pVBoxFuncs->uVersion)
+                        == VBOX_CAPI_MAJOR(VBOX_CAPI_VERSION))
+                    && (   VBOX_CAPI_MINOR(g_pVBoxFuncs->uVersion)
+                        >= VBOX_CAPI_MINOR(VBOX_CAPI_VERSION)))
+                {
+                    g_pfnGetFunctions = pfnGetFunctions;
+                    return 0;
+                }
+                setErrMsg(1, "%.80s: pfnGetFunctions(%#x) returned incompatible version %#x",
+                          szName, VBOX_CAPI_VERSION, g_pVBoxFuncs->uVersion);
+                g_pVBoxFuncs = NULL;
+            }
+            else
+            {
+                /* bail out */
+                setErrMsg(1, "%.80s: pfnGetFunctions(%#x) failed",
+                          szName, VBOX_CAPI_VERSION);
+            }
+        }
+        else
+        {
+#ifndef WIN32
+            setErrMsg(1, "dlsym(%.80s/%.32s): %.128s",
+                      szName, VBOX_GET_CAPI_FUNCTIONS_SYMBOL_NAME, dlerror());
+#else /* WIN32 */
+            setErrMsg(1, "GetProcAddress(%.80s/%.32s): %d",
+                      szName, VBOX_GET_CAPI_FUNCTIONS_SYMBOL_NAME, GetLastError());
+#endif /* WIN32 */
+        }
+
+#ifndef WIN32
+        dlclose(g_hVBoxCAPI);
+#else /* WIN32 */
+        FreeLibrary(g_hVBoxCAPI);
+#endif /* WIN32 */
+        g_hVBoxCAPI = NULL;
+    }
+    else
+    {
+#ifndef WIN32
+        setErrMsg(0, "dlopen(%.80s): %.160s", szName, dlerror());
+#else /* WIN32 */
+        setErrMsg(0, "LoadLibraryEx(%.80s): %d", szName, GetLastError());
+#endif /* WIN32 */
+    }
+
+    return -1;
+}
+
+
+/**
+ * Tries to locate and load VBoxCAPI.so/dylib/dll, resolving all the related
+ * function pointers.
+ *
+ * @returns 0 on success, -1 on failure.
+ *
+ * @remark  This should be considered moved into a separate glue library since
+ *          its its going to be pretty much the same for any user of VBoxCAPI
+ *          and it will just cause trouble to have duplicate versions of this
+ *          source code all around the place.
+ */
+int VBoxCGlueInit(void)
+{
+    const char *pszHome;
+
+    memset(g_szVBoxErrMsg, 0, sizeof(g_szVBoxErrMsg));
+
+    /*
+     * If the user specifies the location, try only that.
+     */
+    pszHome = getenv("VBOX_APP_HOME");
+    if (pszHome)
+        return tryLoadLibrary(pszHome, 0);
+
+    /*
+     * Try the known standard locations.
+     */
+#if defined(__gnu__linux__) || defined(__linux__)
+    if (tryLoadLibrary("/opt/VirtualBox", 1) == 0)
+        return 0;
+    if (tryLoadLibrary("/usr/lib/virtualbox", 1) == 0)
+        return 0;
+#elif defined(__sun__)
+    if (tryLoadLibrary("/opt/VirtualBox/amd64", 1) == 0)
+        return 0;
+    if (tryLoadLibrary("/opt/VirtualBox/i386", 1) == 0)
+        return 0;
+#elif defined(__APPLE__)
+    if (tryLoadLibrary("/Applications/VirtualBox.app/Contents/MacOS", 1) == 0)
+        return 0;
+#elif defined(__FreeBSD__)
+    if (tryLoadLibrary("/usr/local/lib/virtualbox", 1) == 0)
+        return 0;
+#elif defined(__OS2__)
+    if (tryLoadLibrary("C:/Apps/VirtualBox", 1) == 0)
+        return 0;
+#elif defined(WIN32)
+    pszHome = getenv("ProgramFiles");
+    if (pszHome)
+    {
+        char szPath[4096];
+        size_t cb = sizeof(szPath);
+        char *tmp = szPath;
+        strncpy(tmp, pszHome, cb);
+        tmp[cb - 1] = '\0';
+        cb -= strlen(tmp);
+        tmp += strlen(tmp);
+        strncpy(tmp, "/Oracle/VirtualBox", cb);
+        tmp[cb - 1] = '\0';
+        if (tryLoadLibrary(szPath, 1) == 0)
+            return 0;
+    }
+    if (tryLoadLibrary("C:/Program Files/Oracle/VirtualBox", 1) == 0)
+        return 0;
+#else
+# error "port me"
+#endif
+
+    /*
+     * Finally try the dynamic linker search path.
+     */
+    if (tryLoadLibrary(NULL, 1) == 0)
+        return 0;
+
+    /* No luck, return failure. */
+    return -1;
+}
+
+
+/**
+ * Terminate the C glue library.
+ */
+void VBoxCGlueTerm(void)
+{
+    if (g_hVBoxCAPI)
+    {
+#if 0 /* VBoxRT.so doesn't like being reloaded. See @bugref{3725}. */
+#ifndef WIN32
+        dlclose(g_hVBoxCAPI);
+#else
+        FreeLibrary(g_hVBoxCAPI);
+#endif
+#endif
+        g_hVBoxCAPI = NULL;
+    }
+    g_pVBoxFuncs = NULL;
+    g_pfnGetFunctions = NULL;
+    memset(g_szVBoxErrMsg, 0, sizeof(g_szVBoxErrMsg));
+}
+
diff --git a/src/VBox/Main/cbinding/VBoxCAPIGlue.h.in b/src/VBox/Main/cbinding/VBoxCAPIGlue.h.in
new file mode 100644
index 00000000..60ec8b6f
--- /dev/null
+++ b/src/VBox/Main/cbinding/VBoxCAPIGlue.h.in
@@ -0,0 +1,68 @@
+/* $Id: VBoxCAPIGlue.h.in $ */
+/** @file VBoxCAPIGlue.h
+ * Glue for dynamically linking with VBoxCAPI.
+ */
+
+/*
+ * Copyright (C) 2008-2023 Oracle and/or its affiliates.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef ___VBoxCAPIGlue_h
+#define ___VBoxCAPIGlue_h
+#ifndef RT_WITHOUT_PRAGMA_ONCE
+# pragma once
+#endif
+
+#undef VBOX_WITH_GLUE
+#define VBOX_WITH_GLUE
+#include "VBoxCAPI_v@VBOX_API_VERSION@.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** The so/dynsym/dll handle for VBoxCAPI. */
+#ifndef WIN32
+extern void *g_hVBoxCAPI;
+#else
+extern HMODULE g_hVBoxCAPI;
+#endif
+/** The last load error. */
+extern char g_szVBoxErrMsg[256];
+/** Pointer to the VBOXCAPI function table. */
+extern PCVBOXCAPI g_pVBoxFuncs;
+/** Pointer to VBoxGetCAPIFunctions for the loaded VBoxCAPI so/dylib/dll. */
+extern PFNVBOXGETCAPIFUNCTIONS g_pfnGetFunctions;
+
+
+int VBoxCGlueInit(void);
+void VBoxCGlueTerm(void);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !___VBoxCAPIGlue_h */
+
diff --git a/src/VBox/Main/cbinding/capiidl.xsl b/src/VBox/Main/cbinding/capiidl.xsl
new file mode 100644
index 00000000..b9dabcfd
--- /dev/null
+++ b/src/VBox/Main/cbinding/capiidl.xsl
@@ -0,0 +1,2736 @@
+<?xml version="1.0"?>
+<!-- $Id: capiidl.xsl $ -->
+
+<!--
+ *  A template to generate a C header file for all relevant XPCOM interfaces
+ *  provided or needed for calling the VirtualBox API. The header file also
+ *  works on Windows, by using the C bindings header created by the MS COM IDL
+ *  compiler (which simultaneously supports C and C++, unlike XPCOM).
+-->
+<!--
+    Copyright (C) 2008-2023 Oracle and/or its affiliates.
+
+    This file is part of VirtualBox base platform packages, as
+    available from https://www.virtualbox.org.
+
+    This program is free software; you can redistribute it and/or
+    modify it under the terms of the GNU General Public License
+    as published by the Free Software Foundation, in version 3 of the
+    License.
+
+    This program is distributed in the hope that it will be useful, but
+    WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, see <https://www.gnu.org/licenses>.
+
+    SPDX-License-Identifier: GPL-3.0-only
+-->
+
+<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+<xsl:output method="text"/>
+
+<xsl:strip-space elements="*"/>
+
+
+<xsl:include href="../idl/typemap-shared.inc.xsl"/>
+
+<!--
+//  Keys for more efficiently looking up of types.
+/////////////////////////////////////////////////////////////////////////////
+-->
+
+<xsl:key name="G_keyInterfacesByName" match="//interface[@name]" use="@name"/>
+
+
+<!--
+//  templates
+/////////////////////////////////////////////////////////////////////////////
+-->
+
+
+<!--
+ *  not explicitly matched elements and attributes
+-->
+<xsl:template match="*"/>
+
+
+<!--
+ *  header
+-->
+<xsl:template match="/idl">
+  <xsl:text>/*
+ *  DO NOT EDIT! This is a generated file.
+ *
+ *  Header file which provides C declarations for VirtualBox Main API
+ *  (COM interfaces), generated from XIDL (XML interface definition).
+ *  On Windows (which uses COM instead of XPCOM) the native C support
+ *  is used, and most of this file is not used.
+ *
+ *  Source    : src/VBox/Main/idl/VirtualBox.xidl
+ *  Generator : src/VBox/Main/cbinding/capiidl.xsl
+ *
+ *  This file contains portions from the following Mozilla XPCOM files:
+ *      xpcom/include/xpcom/nsID.h
+ *      xpcom/include/nsIException.h
+ *      xpcom/include/nsprpub/prtypes.h
+ *      xpcom/include/xpcom/nsISupportsBase.h
+ *
+ * These files were originally triple-licensed (MPL/GPL2/LGPL2.1). Oracle
+ * elects to distribute this derived work under the LGPL2.1 only.
+ */
+
+/*
+ * Copyright (C) 2008-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of a free software library; you can redistribute
+ * it and/or modify it under the terms of the GNU Lesser General
+ * Public License version 2.1 as published by the Free Software
+ * Foundation and shipped in the "COPYING.LIB" file with this library.
+ * The library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY of any kind.
+ *
+ * Oracle LGPL Disclaimer: For the avoidance of doubt, except that if
+ * any license choice other than GPL or LGPL is available it will
+ * apply instead, Oracle elects to use only the Lesser General Public
+ * License version 2.1 (LGPLv2) at this time for any software where
+ * a choice of LGPL license versions is made available with the
+ * language indicating that LGPLv2 or any later version may be used,
+ * or where a choice of which version of the LGPL is applied is
+ * otherwise unspecified.
+ *
+ * SPDX-License-Identifier: LGPL-2.1-only
+ */
+
+#ifndef ___VirtualBox_CAPI_h
+#define ___VirtualBox_CAPI_h
+
+#ifdef _WIN32
+# ifdef _MSC_VER
+#  pragma warning(push)
+#  pragma warning(disable:4668 4255) /* -Wall and windows.h */
+#  if _MSC_VER >= 1800 /*RT_MSC_VER_VC120*/
+#   pragma warning(disable:4005) /* sdk/v7.1/include/sal_supp.h(57) : warning C4005: '__useHeader' : macro redefinition */
+#  endif
+#  ifdef __cplusplus
+#   if _MSC_VER >= 1900 /*RT_MSC_VER_VC140*/
+#    pragma warning(disable:5039) /* winbase.h(13179): warning C5039: 'TpSetCallbackCleanupGroup': pointer or reference to potentially throwing function passed to 'extern "C"' function under -EHc. Undefined behavior may occur if this function throws an exception. */
+#   endif
+#  endif
+# endif
+# undef COBJMACROS
+# define COBJMACROS
+# include "Windows.h"
+# pragma warning(pop)
+#endif /* _WIN32 */
+
+#ifdef WIN32
+# ifdef IN_VBOXCAPI
+#  define VBOXCAPI_DECL(type) extern __declspec(dllexport) type
+# else /* !IN_VBOXCAPI */
+#  define VBOXCAPI_DECL(type) __declspec(dllimport) type
+# endif /* !IN_VBOXCAPI */
+#endif /* WIN32 */
+
+#ifdef __cplusplus
+/* The C++ treatment in this file is not meant for SDK users, it only exists
+ * so that this file can be used to produce the VBoxCAPI shared library which
+ * has to use C++ as it does all the conversion magic. */
+# ifdef IN_VBOXCAPI
+#  include "VBox/com/VirtualBox.h"
+#  ifndef WIN32
+#   include "nsIEventQueue.h"
+#  endif /* !WIN32 */
+# else /* !IN_VBOXCAPI */
+#  error Do not include this header file from C++ code
+# endif /* !IN_VBOXCAPI */
+#endif /* __cplusplus */
+
+#ifdef __GNUC__
+# define VBOX_EXTERN_CONST(type, name) extern const type name __attribute__((nocommon))
+#else /* !__GNUC__ */
+# define VBOX_EXTERN_CONST(type, name) extern const type name
+#endif /* !__GNUC__ */
+
+/* Treat WIN32 completely separately, as on Windows VirtualBox uses COM, not
+ * XPCOM like on all other platforms. While the code below would also compile
+ * on Windows, we need to switch to the native C support provided by the header
+ * files produced by the COM IDL compiler. */
+#ifdef WIN32
+# include "ObjBase.h"
+# include "oaidl.h"
+# include "VirtualBox.h"
+
+#ifndef __cplusplus
+/* Skip this in the C++ case as there's already a definition for CBSTR. */
+typedef const BSTR CBSTR;
+#endif /* !__cplusplus */
+
+#define VBOX_WINAPI WINAPI
+
+#define ComSafeArrayAsInParam(f) (f)
+#define ComSafeArrayAsOutParam(f) (&amp;(f))
+#define ComSafeArrayAsOutTypeParam(f,t) (&amp;(f))
+#define ComSafeArrayAsOutIfaceParam(f,t) (&amp;(f))
+
+#else /* !WIN32 */
+
+#include &lt;stddef.h&gt;
+#include "wchar.h"
+
+#ifdef IN_VBOXCAPI
+# define VBOXCAPI_DECL(type) PR_EXPORT(type)
+#else /* !IN_VBOXCAPI */
+# define VBOXCAPI_DECL(type) PR_IMPORT(type)
+#endif /* !IN_VBOXCAPI */
+
+#ifndef __cplusplus
+
+#if defined(WIN32)
+
+#define PR_EXPORT(__type) extern __declspec(dllexport) __type
+#define PR_EXPORT_DATA(__type) extern __declspec(dllexport) __type
+#define PR_IMPORT(__type) __declspec(dllimport) __type
+#define PR_IMPORT_DATA(__type) __declspec(dllimport) __type
+
+#define PR_EXTERN(__type) extern __declspec(dllexport) __type
+#define PR_IMPLEMENT(__type) __declspec(dllexport) __type
+#define PR_EXTERN_DATA(__type) extern __declspec(dllexport) __type
+#define PR_IMPLEMENT_DATA(__type) __declspec(dllexport) __type
+
+#define PR_CALLBACK
+#define PR_CALLBACK_DECL
+#define PR_STATIC_CALLBACK(__x) static __x
+
+#elif defined(XP_BEOS)
+
+#define PR_EXPORT(__type) extern __declspec(dllexport) __type
+#define PR_EXPORT_DATA(__type) extern __declspec(dllexport) __type
+#define PR_IMPORT(__type) extern __declspec(dllexport) __type
+#define PR_IMPORT_DATA(__type) extern __declspec(dllexport) __type
+
+#define PR_EXTERN(__type) extern __declspec(dllexport) __type
+#define PR_IMPLEMENT(__type) __declspec(dllexport) __type
+#define PR_EXTERN_DATA(__type) extern __declspec(dllexport) __type
+#define PR_IMPLEMENT_DATA(__type) __declspec(dllexport) __type
+
+#define PR_CALLBACK
+#define PR_CALLBACK_DECL
+#define PR_STATIC_CALLBACK(__x) static __x
+
+#elif defined(WIN16)
+
+#define PR_CALLBACK_DECL        __cdecl
+
+#if defined(_WINDLL)
+#define PR_EXPORT(__type) extern __type _cdecl _export _loadds
+#define PR_IMPORT(__type) extern __type _cdecl _export _loadds
+#define PR_EXPORT_DATA(__type) extern __type _export
+#define PR_IMPORT_DATA(__type) extern __type _export
+
+#define PR_EXTERN(__type) extern __type _cdecl _export _loadds
+#define PR_IMPLEMENT(__type) __type _cdecl _export _loadds
+#define PR_EXTERN_DATA(__type) extern __type _export
+#define PR_IMPLEMENT_DATA(__type) __type _export
+
+#define PR_CALLBACK             __cdecl __loadds
+#define PR_STATIC_CALLBACK(__x) static __x PR_CALLBACK
+
+#else /* this must be .EXE */
+#define PR_EXPORT(__type) extern __type _cdecl _export
+#define PR_IMPORT(__type) extern __type _cdecl _export
+#define PR_EXPORT_DATA(__type) extern __type _export
+#define PR_IMPORT_DATA(__type) extern __type _export
+
+#define PR_EXTERN(__type) extern __type _cdecl _export
+#define PR_IMPLEMENT(__type) __type _cdecl _export
+#define PR_EXTERN_DATA(__type) extern __type _export
+#define PR_IMPLEMENT_DATA(__type) __type _export
+
+#define PR_CALLBACK             __cdecl __loadds
+#define PR_STATIC_CALLBACK(__x) __x PR_CALLBACK
+#endif /* _WINDLL */
+
+#elif defined(XP_MAC)
+
+#define PR_EXPORT(__type) extern __declspec(export) __type
+#define PR_EXPORT_DATA(__type) extern __declspec(export) __type
+#define PR_IMPORT(__type) extern __declspec(export) __type
+#define PR_IMPORT_DATA(__type) extern __declspec(export) __type
+
+#define PR_EXTERN(__type) extern __declspec(export) __type
+#define PR_IMPLEMENT(__type) __declspec(export) __type
+#define PR_EXTERN_DATA(__type) extern __declspec(export) __type
+#define PR_IMPLEMENT_DATA(__type) __declspec(export) __type
+
+#define PR_CALLBACK
+#define PR_CALLBACK_DECL
+#define PR_STATIC_CALLBACK(__x) static __x
+
+#elif defined(XP_OS2) &amp;&amp; defined(__declspec)
+
+#define PR_EXPORT(__type) extern __declspec(dllexport) __type
+#define PR_EXPORT_DATA(__type) extern __declspec(dllexport) __type
+#define PR_IMPORT(__type) __declspec(dllimport) __type
+#define PR_IMPORT_DATA(__type) __declspec(dllimport) __type
+
+#define PR_EXTERN(__type) extern __declspec(dllexport) __type
+#define PR_IMPLEMENT(__type) __declspec(dllexport) __type
+#define PR_EXTERN_DATA(__type) extern __declspec(dllexport) __type
+#define PR_IMPLEMENT_DATA(__type) __declspec(dllexport) __type
+
+#define PR_CALLBACK
+#define PR_CALLBACK_DECL
+#define PR_STATIC_CALLBACK(__x) static __x
+
+#elif defined(XP_OS2_VACPP)
+
+#define PR_EXPORT(__type) extern __type
+#define PR_EXPORT_DATA(__type) extern __type
+#define PR_IMPORT(__type) extern __type
+#define PR_IMPORT_DATA(__type) extern __type
+
+#define PR_EXTERN(__type) extern __type
+#define PR_IMPLEMENT(__type) __type
+#define PR_EXTERN_DATA(__type) extern __type
+#define PR_IMPLEMENT_DATA(__type) __type
+#define PR_CALLBACK _Optlink
+#define PR_CALLBACK_DECL
+#define PR_STATIC_CALLBACK(__x) static __x PR_CALLBACK
+
+#else /* Unix */
+
+# ifdef VBOX_HAVE_VISIBILITY_HIDDEN
+#  define PR_EXPORT(__type) __attribute__((visibility("default"))) extern __type
+#  define PR_EXPORT_DATA(__type) __attribute__((visibility("default"))) extern __type
+#  define PR_IMPORT(__type) extern __type
+#  define PR_IMPORT_DATA(__type) extern __type
+#  define PR_EXTERN(__type) __attribute__((visibility("default"))) extern __type
+#  define PR_IMPLEMENT(__type) __attribute__((visibility("default"))) __type
+#  define PR_EXTERN_DATA(__type) __attribute__((visibility("default"))) extern __type
+#  define PR_IMPLEMENT_DATA(__type) __attribute__((visibility("default"))) __type
+#  define PR_CALLBACK
+#  define PR_CALLBACK_DECL
+#  define PR_STATIC_CALLBACK(__x) static __x
+# else
+#  define PR_EXPORT(__type) extern __type
+#  define PR_EXPORT_DATA(__type) extern __type
+#  define PR_IMPORT(__type) extern __type
+#  define PR_IMPORT_DATA(__type) extern __type
+#  define PR_EXTERN(__type) extern __type
+#  define PR_IMPLEMENT(__type) __type
+#  define PR_EXTERN_DATA(__type) extern __type
+#  define PR_IMPLEMENT_DATA(__type) __type
+#  define PR_CALLBACK
+#  define PR_CALLBACK_DECL
+#  define PR_STATIC_CALLBACK(__x) static __x
+# endif
+#endif
+
+#if defined(_NSPR_BUILD_)
+#define NSPR_API(__type) PR_EXPORT(__type)
+#define NSPR_DATA_API(__type) PR_EXPORT_DATA(__type)
+#else
+#define NSPR_API(__type) PR_IMPORT(__type)
+#define NSPR_DATA_API(__type) PR_IMPORT_DATA(__type)
+#endif
+
+typedef unsigned char PRUint8;
+#if (defined(HPUX) &amp;&amp; defined(__cplusplus) \
+        &amp;&amp; !defined(__GNUC__) &amp;&amp; __cplusplus &lt; 199707L) \
+    || (defined(SCO) &amp;&amp; defined(__cplusplus) \
+        &amp;&amp; !defined(__GNUC__) &amp;&amp; __cplusplus == 1L)
+typedef char PRInt8;
+#else
+typedef signed char PRInt8;
+#endif
+
+#define PR_INT8_MAX 127
+#define PR_INT8_MIN (-128)
+#define PR_UINT8_MAX 255U
+
+typedef unsigned short PRUint16;
+typedef short PRInt16;
+
+#define PR_INT16_MAX 32767
+#define PR_INT16_MIN (-32768)
+#define PR_UINT16_MAX 65535U
+
+typedef unsigned int PRUint32;
+typedef int PRInt32;
+#define PR_INT32(x)  x
+#define PR_UINT32(x) x ## U
+
+#define PR_INT32_MAX PR_INT32(2147483647)
+#define PR_INT32_MIN (-PR_INT32_MAX - 1)
+#define PR_UINT32_MAX PR_UINT32(4294967295)
+
+typedef long PRInt64;
+typedef unsigned long PRUint64;
+typedef int PRIntn;
+typedef unsigned int PRUintn;
+
+typedef double          PRFloat64;
+typedef size_t PRSize;
+
+typedef ptrdiff_t PRPtrdiff;
+
+typedef unsigned long PRUptrdiff;
+
+typedef PRIntn PRBool;
+
+#define PR_TRUE 1
+#define PR_FALSE 0
+
+typedef PRUint8 PRPackedBool;
+
+/*
+** Status code used by some routines that have a single point of failure or
+** special status return.
+*/
+typedef enum { PR_FAILURE = -1, PR_SUCCESS = 0 } PRStatus;
+
+#ifndef __PRUNICHAR__
+#define __PRUNICHAR__
+#if defined(WIN32) || defined(XP_MAC)
+typedef wchar_t PRUnichar;
+#else
+typedef PRUint16 PRUnichar;
+#endif
+typedef PRUnichar *BSTR;
+typedef const PRUnichar *CBSTR;
+#endif
+
+typedef long PRWord;
+typedef unsigned long PRUword;
+
+#define nsnull 0
+typedef PRUint32 nsresult;
+
+#if defined(__GNUC__) &amp;&amp; (__GNUC__ > 2)
+#define NS_LIKELY(x)    (__builtin_expect((x), 1))
+#define NS_UNLIKELY(x)  (__builtin_expect((x), 0))
+#else
+#define NS_LIKELY(x)    (x)
+#define NS_UNLIKELY(x)  (x)
+#endif
+
+#define NS_FAILED(_nsresult) (NS_UNLIKELY((_nsresult) &amp; 0x80000000))
+#define NS_SUCCEEDED(_nsresult) (NS_LIKELY(!((_nsresult) &amp; 0x80000000)))
+
+#ifdef VBOX_WITH_XPCOM_NAMESPACE_CLEANUP
+# define PR_IntervalNow VBoxNsprPR_IntervalNow
+# define PR_TicksPerSecond VBoxNsprPR_TicksPerSecond
+# define PR_SecondsToInterval VBoxNsprPR_SecondsToInterval
+# define PR_MillisecondsToInterval VBoxNsprPR_MillisecondsToInterval
+# define PR_MicrosecondsToInterval VBoxNsprPR_MicrosecondsToInterval
+# define PR_IntervalToSeconds VBoxNsprPR_IntervalToSeconds
+# define PR_IntervalToMilliseconds VBoxNsprPR_IntervalToMilliseconds
+# define PR_IntervalToMicroseconds VBoxNsprPR_IntervalToMicroseconds
+# define PR_EnterMonitor VBoxNsprPR_EnterMonitor
+# define PR_ExitMonitor VBoxNsprPR_ExitMonitor
+# define PR_Notify VBoxNsprPR_Notify
+# define PR_NotifyAll VBoxNsprPR_NotifyAll
+# define PR_Wait VBoxNsprPR_Wait
+# define PR_NewMonitor VBoxNsprPR_NewMonitor
+# define PR_DestroyMonitor VBoxNsprPR_DestroyMonitor
+#endif /* VBOX_WITH_XPCOM_NAMESPACE_CLEANUP */
+
+typedef PRUint32 PRIntervalTime;
+
+#define PR_INTERVAL_MIN 1000UL
+#define PR_INTERVAL_MAX 100000UL
+#define PR_INTERVAL_NO_WAIT 0UL
+#define PR_INTERVAL_NO_TIMEOUT 0xffffffffUL
+
+NSPR_API(PRIntervalTime) PR_IntervalNow(void);
+NSPR_API(PRUint32) PR_TicksPerSecond(void);
+NSPR_API(PRIntervalTime) PR_SecondsToInterval(PRUint32 seconds);
+NSPR_API(PRIntervalTime) PR_MillisecondsToInterval(PRUint32 milli);
+NSPR_API(PRIntervalTime) PR_MicrosecondsToInterval(PRUint32 micro);
+NSPR_API(PRUint32) PR_IntervalToSeconds(PRIntervalTime ticks);
+NSPR_API(PRUint32) PR_IntervalToMilliseconds(PRIntervalTime ticks);
+NSPR_API(PRUint32) PR_IntervalToMicroseconds(PRIntervalTime ticks);
+
+typedef struct PRMonitor PRMonitor;
+
+NSPR_API(PRMonitor*) PR_NewMonitor(void);
+NSPR_API(void) PR_DestroyMonitor(PRMonitor *mon);
+NSPR_API(void) PR_EnterMonitor(PRMonitor *mon);
+NSPR_API(PRStatus) PR_ExitMonitor(PRMonitor *mon);
+NSPR_API(PRStatus) PR_Wait(PRMonitor *mon, PRIntervalTime ticks);
+NSPR_API(PRStatus) PR_Notify(PRMonitor *mon);
+NSPR_API(PRStatus) PR_NotifyAll(PRMonitor *mon);
+
+#ifdef VBOX_WITH_XPCOM_NAMESPACE_CLEANUP
+# define PR_CreateThread VBoxNsprPR_CreateThread
+# define PR_JoinThread VBoxNsprPR_JoinThread
+# define PR_Sleep VBoxNsprPR_Sleep
+# define PR_GetCurrentThread VBoxNsprPR_GetCurrentThread
+# define PR_GetThreadState VBoxNsprPR_GetThreadState
+# define PR_SetThreadPrivate VBoxNsprPR_SetThreadPrivate
+# define PR_GetThreadPrivate VBoxNsprPR_GetThreadPrivate
+# define PR_NewThreadPrivateIndex VBoxNsprPR_NewThreadPrivateIndex
+# define PR_GetThreadPriority VBoxNsprPR_GetThreadPriority
+# define PR_SetThreadPriority VBoxNsprPR_SetThreadPriority
+# define PR_Interrupt VBoxNsprPR_Interrupt
+# define PR_ClearInterrupt VBoxNsprPR_ClearInterrupt
+# define PR_BlockInterrupt VBoxNsprPR_BlockInterrupt
+# define PR_UnblockInterrupt VBoxNsprPR_UnblockInterrupt
+# define PR_GetThreadScope VBoxNsprPR_GetThreadScope
+# define PR_GetThreadType VBoxNsprPR_GetThreadType
+#endif /* VBOX_WITH_XPCOM_NAMESPACE_CLEANUP */
+
+typedef struct PRThread PRThread;
+typedef struct PRThreadStack PRThreadStack;
+
+typedef enum PRThreadType {
+    PR_USER_THREAD,
+    PR_SYSTEM_THREAD
+} PRThreadType;
+
+typedef enum PRThreadScope {
+    PR_LOCAL_THREAD,
+    PR_GLOBAL_THREAD,
+    PR_GLOBAL_BOUND_THREAD
+} PRThreadScope;
+
+typedef enum PRThreadState {
+    PR_JOINABLE_THREAD,
+    PR_UNJOINABLE_THREAD
+} PRThreadState;
+
+typedef enum PRThreadPriority
+{
+    PR_PRIORITY_FIRST = 0,      /* just a placeholder */
+    PR_PRIORITY_LOW = 0,        /* the lowest possible priority */
+    PR_PRIORITY_NORMAL = 1,     /* most common expected priority */
+    PR_PRIORITY_HIGH = 2,       /* slightly more aggressive scheduling */
+    PR_PRIORITY_URGENT = 3,     /* it does little good to have more than one */
+    PR_PRIORITY_LAST = 3        /* this is just a placeholder */
+} PRThreadPriority;
+
+NSPR_API(PRThread*) PR_CreateThread(PRThreadType type,
+                     void (PR_CALLBACK *start)(void *arg),
+                     void *arg,
+                     PRThreadPriority priority,
+                     PRThreadScope scope,
+                     PRThreadState state,
+                     PRUint32 stackSize);
+NSPR_API(PRStatus) PR_JoinThread(PRThread *thread);
+NSPR_API(PRThread*) PR_GetCurrentThread(void);
+#ifndef NO_NSPR_10_SUPPORT
+#define PR_CurrentThread() PR_GetCurrentThread() /* for nspr1.0 compat. */
+#endif /* NO_NSPR_10_SUPPORT */
+NSPR_API(PRThreadPriority) PR_GetThreadPriority(const PRThread *thread);
+NSPR_API(void) PR_SetThreadPriority(PRThread *thread, PRThreadPriority priority);
+
+typedef void (PR_CALLBACK *PRThreadPrivateDTOR)(void *priv);
+
+NSPR_API(PRStatus) PR_NewThreadPrivateIndex(
+    PRUintn *newIndex, PRThreadPrivateDTOR destructor);
+NSPR_API(PRStatus) PR_SetThreadPrivate(PRUintn tpdIndex, void *priv);
+NSPR_API(void*) PR_GetThreadPrivate(PRUintn tpdIndex);
+NSPR_API(PRStatus) PR_Interrupt(PRThread *thread);
+NSPR_API(void) PR_ClearInterrupt(void);
+NSPR_API(void) PR_BlockInterrupt(void);
+NSPR_API(void) PR_UnblockInterrupt(void);
+NSPR_API(PRStatus) PR_Sleep(PRIntervalTime ticks);
+NSPR_API(PRThreadScope) PR_GetThreadScope(const PRThread *thread);
+NSPR_API(PRThreadType) PR_GetThreadType(const PRThread *thread);
+NSPR_API(PRThreadState) PR_GetThreadState(const PRThread *thread);
+
+#ifdef VBOX_WITH_XPCOM_NAMESPACE_CLEANUP
+# define PR_DestroyLock VBoxNsprPR_DestroyLock
+# define PR_Lock VBoxNsprPR_Lock
+# define PR_NewLock VBoxNsprPR_NewLock
+# define PR_Unlock VBoxNsprPR_Unlock
+#endif /* VBOX_WITH_XPCOM_NAMESPACE_CLEANUP */
+
+typedef struct PRLock PRLock;
+
+NSPR_API(PRLock*) PR_NewLock(void);
+NSPR_API(void) PR_DestroyLock(PRLock *lock);
+NSPR_API(void) PR_Lock(PRLock *lock);
+NSPR_API(PRStatus) PR_Unlock(PRLock *lock);
+
+#ifdef VBOX_WITH_XPCOM_NAMESPACE_CLEANUP
+# define PR_NewCondVar VBoxNsprPR_NewCondVar
+# define PR_DestroyCondVar VBoxNsprPR_DestroyCondVar
+# define PR_WaitCondVar VBoxNsprPR_WaitCondVar
+# define PR_NotifyCondVar VBoxNsprPR_NotifyCondVar
+# define PR_NotifyAllCondVar VBoxNsprPR_NotifyAllCondVar
+#endif /* VBOX_WITH_XPCOM_NAMESPACE_CLEANUP */
+
+typedef struct PRCondVar PRCondVar;
+
+NSPR_API(PRCondVar*) PR_NewCondVar(PRLock *lock);
+NSPR_API(void) PR_DestroyCondVar(PRCondVar *cvar);
+NSPR_API(PRStatus) PR_WaitCondVar(PRCondVar *cvar, PRIntervalTime timeout);
+NSPR_API(PRStatus) PR_NotifyCondVar(PRCondVar *cvar);
+NSPR_API(PRStatus) PR_NotifyAllCondVar(PRCondVar *cvar);
+
+typedef struct PRCListStr PRCList;
+
+struct PRCListStr {
+    PRCList *next;
+    PRCList *prev;
+};
+
+#ifdef VBOX_WITH_XPCOM_NAMESPACE_CLEANUP
+# define PL_DestroyEvent VBoxNsplPL_DestroyEvent
+# define PL_HandleEvent VBoxNsplPL_HandleEvent
+# define PL_InitEvent VBoxNsplPL_InitEvent
+# define PL_CreateEventQueue VBoxNsplPL_CreateEventQueue
+# define PL_CreateMonitoredEventQueue VBoxNsplPL_CreateMonitoredEventQueue
+# define PL_CreateNativeEventQueue VBoxNsplPL_CreateNativeEventQueue
+# define PL_DequeueEvent VBoxNsplPL_DequeueEvent
+# define PL_DestroyEventQueue VBoxNsplPL_DestroyEventQueue
+# define PL_EventAvailable VBoxNsplPL_EventAvailable
+# define PL_EventLoop VBoxNsplPL_EventLoop
+# define PL_GetEvent VBoxNsplPL_GetEvent
+# define PL_GetEventOwner VBoxNsplPL_GetEventOwner
+# define PL_GetEventQueueMonitor VBoxNsplPL_GetEventQueueMonitor
+# define PL_GetEventQueueSelectFD VBoxNsplPL_GetEventQueueSelectFD
+# define PL_MapEvents VBoxNsplPL_MapEvents
+# define PL_PostEvent VBoxNsplPL_PostEvent
+# define PL_PostSynchronousEvent VBoxNsplPL_PostSynchronousEvent
+# define PL_ProcessEventsBeforeID VBoxNsplPL_ProcessEventsBeforeID
+# define PL_ProcessPendingEvents VBoxNsplPL_ProcessPendingEvents
+# define PL_RegisterEventIDFunc VBoxNsplPL_RegisterEventIDFunc
+# define PL_RevokeEvents VBoxNsplPL_RevokeEvents
+# define PL_UnregisterEventIDFunc VBoxNsplPL_UnregisterEventIDFunc
+# define PL_WaitForEvent VBoxNsplPL_WaitForEvent
+# define PL_IsQueueNative VBoxNsplPL_IsQueueNative
+# define PL_IsQueueOnCurrentThread VBoxNsplPL_IsQueueOnCurrentThread
+# define PL_FavorPerformanceHint VBoxNsplPL_FavorPerformanceHint
+#endif /* VBOX_WITH_XPCOM_NAMESPACE_CLEANUP */
+
+typedef struct PLEvent PLEvent;
+typedef struct PLEventQueue PLEventQueue;
+
+PR_EXTERN(PLEventQueue*)
+PL_CreateEventQueue(const char* name, PRThread* handlerThread);
+PR_EXTERN(PLEventQueue *)
+    PL_CreateNativeEventQueue(
+        const char *name,
+        PRThread *handlerThread
+    );
+PR_EXTERN(PLEventQueue *)
+    PL_CreateMonitoredEventQueue(
+        const char *name,
+        PRThread *handlerThread
+    );
+PR_EXTERN(void)
+PL_DestroyEventQueue(PLEventQueue* self);
+PR_EXTERN(PRMonitor*)
+PL_GetEventQueueMonitor(PLEventQueue* self);
+
+#define PL_ENTER_EVENT_QUEUE_MONITOR(queue) \
+    PR_EnterMonitor(PL_GetEventQueueMonitor(queue))
+
+#define PL_EXIT_EVENT_QUEUE_MONITOR(queue)  \
+    PR_ExitMonitor(PL_GetEventQueueMonitor(queue))
+
+PR_EXTERN(PRStatus) PL_PostEvent(PLEventQueue* self, PLEvent* event);
+PR_EXTERN(void*) PL_PostSynchronousEvent(PLEventQueue* self, PLEvent* event);
+PR_EXTERN(PLEvent*) PL_GetEvent(PLEventQueue* self);
+PR_EXTERN(PRBool) PL_EventAvailable(PLEventQueue* self);
+
+typedef void (PR_CALLBACK *PLEventFunProc)(PLEvent* event, void* data, PLEventQueue* queue);
+
+PR_EXTERN(void) PL_MapEvents(PLEventQueue* self, PLEventFunProc fun, void* data);
+PR_EXTERN(void) PL_RevokeEvents(PLEventQueue* self, void* owner);
+PR_EXTERN(void) PL_ProcessPendingEvents(PLEventQueue* self);
+PR_EXTERN(PLEvent*) PL_WaitForEvent(PLEventQueue* self);
+PR_EXTERN(void) PL_EventLoop(PLEventQueue* self);
+PR_EXTERN(PRInt32) PL_GetEventQueueSelectFD(PLEventQueue* self);
+PR_EXTERN(PRBool) PL_IsQueueOnCurrentThread( PLEventQueue *queue );
+PR_EXTERN(PRBool) PL_IsQueueNative(PLEventQueue *queue);
+
+typedef void* (PR_CALLBACK *PLHandleEventProc)(PLEvent* self);
+typedef void (PR_CALLBACK *PLDestroyEventProc)(PLEvent* self);
+PR_EXTERN(void)
+PL_InitEvent(PLEvent* self, void* owner,
+             PLHandleEventProc handler,
+             PLDestroyEventProc destructor);
+PR_EXTERN(void*) PL_GetEventOwner(PLEvent* self);
+PR_EXTERN(void) PL_HandleEvent(PLEvent* self);
+PR_EXTERN(void) PL_DestroyEvent(PLEvent* self);
+PR_EXTERN(void) PL_DequeueEvent(PLEvent* self, PLEventQueue* queue);
+PR_EXTERN(void) PL_FavorPerformanceHint(PRBool favorPerformanceOverEventStarvation, PRUint32 starvationDelay);
+
+struct PLEvent {
+    PRCList             link;
+    PLHandleEventProc   handler;
+    PLDestroyEventProc  destructor;
+    void*               owner;
+    void*               synchronousResult;
+    PRLock*             lock;
+    PRCondVar*          condVar;
+    PRBool              handled;
+#ifdef PL_POST_TIMINGS
+    PRIntervalTime      postTime;
+#endif
+#ifdef XP_UNIX
+    unsigned long       id;
+#endif /* XP_UNIX */
+    /* other fields follow... */
+};
+
+#if defined(XP_WIN) || defined(XP_OS2)
+
+PR_EXTERN(HWND)
+    PL_GetNativeEventReceiverWindow(
+        PLEventQueue *eqp
+    );
+#endif /* XP_WIN || XP_OS2 */
+
+#ifdef XP_UNIX
+
+PR_EXTERN(PRInt32)
+PL_ProcessEventsBeforeID(PLEventQueue *aSelf, unsigned long aID);
+
+typedef unsigned long (PR_CALLBACK *PLGetEventIDFunc)(void *aClosure);
+
+PR_EXTERN(void)
+PL_RegisterEventIDFunc(PLEventQueue *aSelf, PLGetEventIDFunc aFunc,
+                       void *aClosure);
+PR_EXTERN(void) PL_UnregisterEventIDFunc(PLEventQueue *aSelf);
+
+#endif /* XP_UNIX */
+
+/* Standard "it worked" return value */
+#define NS_OK                              0
+
+#define NS_ERROR_BASE                      ((nsresult) 0xC1F30000)
+
+/* Returned when an instance is not initialized */
+#define NS_ERROR_NOT_INITIALIZED           (NS_ERROR_BASE + 1)
+
+/* Returned when an instance is already initialized */
+#define NS_ERROR_ALREADY_INITIALIZED       (NS_ERROR_BASE + 2)
+
+/* Returned by a not implemented function */
+#define NS_ERROR_NOT_IMPLEMENTED           ((nsresult) 0x80004001L)
+
+/* Returned when a given interface is not supported. */
+#define NS_NOINTERFACE                     ((nsresult) 0x80004002L)
+#define NS_ERROR_NO_INTERFACE              NS_NOINTERFACE
+
+#define NS_ERROR_INVALID_POINTER           ((nsresult) 0x80004003L)
+#define NS_ERROR_NULL_POINTER              NS_ERROR_INVALID_POINTER
+
+/* Returned when a function aborts */
+#define NS_ERROR_ABORT                     ((nsresult) 0x80004004L)
+
+/* Returned when a function fails */
+#define NS_ERROR_FAILURE                   ((nsresult) 0x80004005L)
+
+/* Returned when an unexpected error occurs */
+#define NS_ERROR_UNEXPECTED                ((nsresult) 0x8000ffffL)
+
+/* Returned when a memory allocation fails */
+#define NS_ERROR_OUT_OF_MEMORY             ((nsresult) 0x8007000eL)
+
+/* Returned when an illegal value is passed */
+#define NS_ERROR_ILLEGAL_VALUE             ((nsresult) 0x80070057L)
+#define NS_ERROR_INVALID_ARG               NS_ERROR_ILLEGAL_VALUE
+
+/* Returned when a class doesn't allow aggregation */
+#define NS_ERROR_NO_AGGREGATION            ((nsresult) 0x80040110L)
+
+/* Returned when an operation can't complete due to an unavailable resource */
+#define NS_ERROR_NOT_AVAILABLE             ((nsresult) 0x80040111L)
+
+/* Returned when a class is not registered */
+#define NS_ERROR_FACTORY_NOT_REGISTERED    ((nsresult) 0x80040154L)
+
+/* Returned when a class cannot be registered, but may be tried again later */
+#define NS_ERROR_FACTORY_REGISTER_AGAIN    ((nsresult) 0x80040155L)
+
+/* Returned when a dynamically loaded factory couldn't be found */
+#define NS_ERROR_FACTORY_NOT_LOADED        ((nsresult) 0x800401f8L)
+
+/* Returned when a factory doesn't support signatures */
+#define NS_ERROR_FACTORY_NO_SIGNATURE_SUPPORT \
+                                           (NS_ERROR_BASE + 0x101)
+
+/* Returned when a factory already is registered */
+#define NS_ERROR_FACTORY_EXISTS            (NS_ERROR_BASE + 0x100)
+
+/**
+ * An "interface id" which can be used to uniquely identify a given
+ * interface.
+ * A "unique identifier". This is modeled after OSF DCE UUIDs.
+ */
+
+struct nsID {
+    PRUint32 m0;
+    PRUint16 m1;
+    PRUint16 m2;
+    PRUint8 m3[8];
+};
+
+typedef struct nsID nsID;
+typedef nsID nsIID;
+typedef nsID nsCID;
+
+#endif /* __cplusplus */
+
+#define VBOX_WINAPI
+
+/* Various COM types defined by their XPCOM equivalent */
+typedef PRInt64 LONG64;
+typedef PRInt32 LONG;
+typedef PRInt32 DWORD;
+typedef PRInt16 SHORT;
+typedef PRUint64 ULONG64;
+typedef PRUint32 ULONG;
+typedef PRUint16 USHORT;
+
+typedef PRBool BOOL;
+
+#ifndef FALSE
+#define FALSE 0
+#define TRUE 1
+#endif
+
+#define HRESULT nsresult
+#define SUCCEEDED NS_SUCCEEDED
+#define FAILED NS_FAILED
+
+/* OLE error codes */
+#define S_OK                ((nsresult)NS_OK)
+#define E_UNEXPECTED        NS_ERROR_UNEXPECTED
+#define E_NOTIMPL           NS_ERROR_NOT_IMPLEMENTED
+#define E_OUTOFMEMORY       NS_ERROR_OUT_OF_MEMORY
+#define E_INVALIDARG        NS_ERROR_INVALID_ARG
+#define E_NOINTERFACE       NS_ERROR_NO_INTERFACE
+#define E_POINTER           NS_ERROR_NULL_POINTER
+#define E_ABORT             NS_ERROR_ABORT
+#define E_FAIL              NS_ERROR_FAILURE
+/* Note: a better analog for E_ACCESSDENIED would probably be
+ * NS_ERROR_NOT_AVAILABLE, but we want binary compatibility for now. */
+#define E_ACCESSDENIED      ((nsresult)0x80070005L)
+
+/* Basic vartype for COM compatibility. */
+typedef enum VARTYPE
+{
+    VT_I2 = 2,
+    VT_I4 = 3,
+    VT_BSTR = 8,
+    VT_DISPATCH = 9,
+    VT_BOOL = 11,
+    VT_UNKNOWN = 13,
+    VT_I1 = 16,
+    VT_UI1 = 17,
+    VT_UI2 = 18,
+    VT_UI4 = 19,
+    VT_I8 = 20,
+    VT_UI8 = 21,
+    VT_HRESULT = 25
+} VARTYPE;
+
+/* Basic safearray type for COM compatibility. */
+typedef struct SAFEARRAY
+{
+    void *pv;
+    ULONG c;
+} SAFEARRAY;
+
+#define ComSafeArrayAsInParam(f) ((f) ? (f)->c : 0), ((f) ? (f)->pv : NULL)
+#define ComSafeArrayAsOutParam(f) (&amp;((f)->c)), (&amp;((f)->pv))
+#define ComSafeArrayAsOutTypeParam(f,t) (&amp;((f)->c)), (t**)(&amp;((f)->pv))
+#define ComSafeArrayAsOutIfaceParam(f,t) (&amp;((f)->c)), (t**)(&amp;((f)->pv))
+
+/* Glossing over differences between COM and XPCOM */
+#define IErrorInfo nsIException
+#define IUnknown nsISupports
+#define IDispatch nsISupports
+
+/* Make things as COM compatible as possible */
+#define interface struct
+#ifdef CONST_VTABLE
+# define CONST_VTBL const
+#else /* !CONST_VTABLE */
+# define CONST_VTBL
+#endif /* !CONST_VTABLE */
+
+#ifndef __cplusplus
+
+/** @todo this first batch of forward declarations (and the corresponding ones
+ * generated for each interface) are 100% redundant, remove eventually. */
+interface nsISupports;   /* forward declaration */
+interface nsIException;  /* forward declaration */
+interface nsIStackFrame; /* forward declaration */
+interface nsIEventTarget;/* forward declaration */
+interface nsIEventQueue; /* forward declaration */
+
+typedef interface nsISupports nsISupports;     /* forward declaration */
+typedef interface nsIException nsIException;   /* forward declaration */
+typedef interface nsIStackFrame nsIStackFrame; /* forward declaration */
+typedef interface nsIEventTarget nsIEventTarget;/* forward declaration */
+typedef interface nsIEventQueue nsIEventQueue; /* forward declaration */
+
+/* starting interface:    nsISupports */
+#define NS_ISUPPORTS_IID_STR "00000000-0000-0000-c000-000000000046"
+
+#define NS_ISUPPORTS_IID \
+    { 0x00000000, 0x0000, 0x0000, \
+      {0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46} }
+
+/**
+ * Reference count values
+ *
+ * This is the return type for AddRef() and Release() in nsISupports.
+ * IUnknown of COM returns an unsigned long from equivalent functions.
+ * The following ifdef exists to maintain binary compatibility with
+ * IUnknown.
+ */
+#if defined(XP_WIN) &amp;&amp; PR_BYTES_PER_LONG == 4
+typedef unsigned long nsrefcnt;
+#else
+typedef PRUint32 nsrefcnt;
+#endif
+
+/**
+ * Basic component object model interface. Objects which implement
+ * this interface support runtime interface discovery (QueryInterface)
+ * and a reference counted memory model (AddRef/Release). This is
+ * modelled after the win32 IUnknown API.
+ */
+#ifndef VBOX_WITH_GLUE
+struct nsISupports_vtbl
+{
+    nsresult (*QueryInterface)(nsISupports *pThis, const nsID *iid, void **resultp);
+    nsrefcnt (*AddRef)(nsISupports *pThis);
+    nsrefcnt (*Release)(nsISupports *pThis);
+};
+#else /* !VBOX_WITH_GLUE */
+struct nsISupportsVtbl
+{
+    nsresult (*QueryInterface)(nsISupports *pThis, const nsID *iid, void **resultp);
+    nsrefcnt (*AddRef)(nsISupports *pThis);
+    nsrefcnt (*Release)(nsISupports *pThis);
+};
+#define nsISupports_QueryInterface(p, iid, resultp) ((p)->lpVtbl->QueryInterface(p, iid, resultp))
+#define nsISupports_AddRef(p) ((p)->lpVtbl->AddRef(p))
+#define nsISupports_Release(p) ((p)->lpVtbl->Release(p))
+#define IUnknown_QueryInterface(p, iid, resultp) ((p)->lpVtbl->QueryInterface(p, iid, resultp))
+#define IUnknown_AddRef(p) ((p)->lpVtbl->AddRef(p))
+#define IUnknown_Release(p) ((p)->lpVtbl->Release(p))
+#define IDispatch_QueryInterface(p, iid, resultp) ((p)->lpVtbl->QueryInterface(p, iid, resultp))
+#define IDispatch_AddRef(p) ((p)->lpVtbl->AddRef(p))
+#define IDispatch_Release(p) ((p)->lpVtbl->Release(p))
+#endif /* !VBOX_WITH_GLUE */
+
+interface nsISupports
+{
+#ifndef VBOX_WITH_GLUE
+    struct nsISupports_vtbl *vtbl;
+#else /* !VBOX_WITH_GLUE */
+    CONST_VTBL struct nsISupportsVtbl *lpVtbl;
+#endif /* !VBOX_WITH_GLUE */
+};
+
+/* starting interface:    nsIException */
+#define NS_IEXCEPTION_IID_STR "f3a8d3b4-c424-4edc-8bf6-8974c983ba78"
+
+#define NS_IEXCEPTION_IID \
+    {0xf3a8d3b4, 0xc424, 0x4edc, \
+      { 0x8b, 0xf6, 0x89, 0x74, 0xc9, 0x83, 0xba, 0x78 }}
+
+#ifndef VBOX_WITH_GLUE
+struct nsIException_vtbl
+{
+    /* Methods from the interface nsISupports */
+    struct nsISupports_vtbl nsisupports;
+
+    nsresult (*GetMessage)(nsIException *pThis, PRUnichar * *aMessage);
+    nsresult (*GetResult)(nsIException *pThis, nsresult *aResult);
+    nsresult (*GetName)(nsIException *pThis, PRUnichar * *aName);
+    nsresult (*GetFilename)(nsIException *pThis, PRUnichar * *aFilename);
+    nsresult (*GetLineNumber)(nsIException *pThis, PRUint32 *aLineNumber);
+    nsresult (*GetColumnNumber)(nsIException *pThis, PRUint32 *aColumnNumber);
+    nsresult (*GetLocation)(nsIException *pThis, nsIStackFrame * *aLocation);
+    nsresult (*GetInner)(nsIException *pThis, nsIException * *aInner);
+    nsresult (*GetData)(nsIException *pThis, nsISupports * *aData);
+    nsresult (*ToString)(nsIException *pThis, PRUnichar **_retval);
+};
+#else /* !VBOX_WITH_GLUE */
+struct nsIExceptionVtbl
+{
+    nsresult (*QueryInterface)(nsIException *pThis, const nsID *iid, void **resultp);
+    nsrefcnt (*AddRef)(nsIException *pThis);
+    nsrefcnt (*Release)(nsIException *pThis);
+
+    nsresult (*GetMessage)(nsIException *pThis, PRUnichar * *aMessage);
+    nsresult (*GetResult)(nsIException *pThis, nsresult *aResult);
+    nsresult (*GetName)(nsIException *pThis, PRUnichar * *aName);
+    nsresult (*GetFilename)(nsIException *pThis, PRUnichar * *aFilename);
+    nsresult (*GetLineNumber)(nsIException *pThis, PRUint32 *aLineNumber);
+    nsresult (*GetColumnNumber)(nsIException *pThis, PRUint32 *aColumnNumber);
+    nsresult (*GetLocation)(nsIException *pThis, nsIStackFrame * *aLocation);
+    nsresult (*GetInner)(nsIException *pThis, nsIException * *aInner);
+    nsresult (*GetData)(nsIException *pThis, nsISupports * *aData);
+    nsresult (*ToString)(nsIException *pThis, PRUnichar **_retval);
+};
+#define nsIException_QueryInterface(p, iid, resultp) ((p)->lpVtbl->QueryInterface(p, iid, resultp))
+#define nsIException_AddRef(p) ((p)->lpVtbl->AddRef(p))
+#define nsIException_Release(p) ((p)->lpVtbl->Release(p))
+#define nsIException_get_Message(p, aMessage) ((p)->lpVtbl->GetMessage(p, aMessage))
+#define nsIException_GetMessage(p, aMessage) ((p)->lpVtbl->GetMessage(p, aMessage))
+#define nsIException_get_Result(p, aResult) ((p)->lpVtbl->GetResult(p, aResult))
+#define nsIException_GetResult(p, aResult) ((p)->lpVtbl->GetResult(p, aResult))
+#define nsIException_get_Name(p, aName) ((p)->lpVtbl->GetName(p, aName))
+#define nsIException_GetName(p, aName) ((p)->lpVtbl->GetName(p, aName))
+#define nsIException_get_Filename(p, aFilename) ((p)->lpVtbl->GetFilename(p, aFilename))
+#define nsIException_GetFilename(p, aFilename) ((p)->lpVtbl->GetFilename(p, aFilename))
+#define nsIException_get_LineNumber(p, aLineNumber) ((p)->lpVtbl->GetLineNumber(p, aLineNumber))
+#define nsIException_GetLineNumber(p, aLineNumber) ((p)->lpVtbl->GetLineNumber(p, aLineNumber))
+#define nsIException_get_ColumnNumber(p, aColumnNumber) ((p)->lpVtbl->GetColumnNumber(p, aColumnNumber))
+#define nsIException_GetColumnNumber(p, aColumnNumber) ((p)->lpVtbl->GetColumnNumber(p, aColumnNumber))
+#define nsIException_get_Inner(p, aInner) ((p)->lpVtbl->GetInner(p, aInner))
+#define nsIException_GetInner(p, aInner) ((p)->lpVtbl->GetInner(p, aInner))
+#define nsIException_get_Data(p, aData) ((p)->lpVtbl->GetData(p, aData))
+#define nsIException_GetData(p, aData) ((p)->lpVtbl->GetData(p, aData))
+#define nsIException_ToString(p, retval) ((p)->lpVtbl->ToString(p, retval))
+#define IErrorInfo_QueryInterface(p, iid, resultp) ((p)->lpVtbl->QueryInterface(p, iid, resultp))
+#define IErrorInfo_AddRef(p) ((p)->lpVtbl->AddRef(p))
+#define IErrorInfo_Release(p) ((p)->lpVtbl->Release(p))
+#define IErrorInfo_get_Message(p, aMessage) ((p)->lpVtbl->GetMessage(p, aMessage))
+#define IErrorInfo_GetMessage(p, aMessage) ((p)->lpVtbl->GetMessage(p, aMessage))
+#define IErrorInfo_get_Result(p, aResult) ((p)->lpVtbl->GetResult(p, aResult))
+#define IErrorInfo_GetResult(p, aResult) ((p)->lpVtbl->GetResult(p, aResult))
+#define IErrorInfo_get_Name(p, aName) ((p)->lpVtbl->GetName(p, aName))
+#define IErrorInfo_GetName(p, aName) ((p)->lpVtbl->GetName(p, aName))
+#define IErrorInfo_get_Filename(p, aFilename) ((p)->lpVtbl->GetFilename(p, aFilename))
+#define IErrorInfo_GetFilename(p, aFilename) ((p)->lpVtbl->GetFilename(p, aFilename))
+#define IErrorInfo_get_LineNumber(p, aLineNumber) ((p)->lpVtbl->GetLineNumber(p, aLineNumber))
+#define IErrorInfo_GetLineNumber(p, aLineNumber) ((p)->lpVtbl->GetLineNumber(p, aLineNumber))
+#define IErrorInfo_get_ColumnNumber(p, aColumnNumber) ((p)->lpVtbl->GetColumnNumber(p, aColumnNumber))
+#define IErrorInfo_GetColumnNumber(p, aColumnNumber) ((p)->lpVtbl->GetColumnNumber(p, aColumnNumber))
+#define IErrorInfo_get_Inner(p, aInner) ((p)->lpVtbl->GetInner(p, aInner))
+#define IErrorInfo_GetInner(p, aInner) ((p)->lpVtbl->GetInner(p, aInner))
+#define IErrorInfo_get_Data(p, aData) ((p)->lpVtbl->GetData(p, aData))
+#define IErrorInfo_GetData(p, aData) ((p)->lpVtbl->GetData(p, aData))
+#define IErrorInfo_ToString(p, retval) ((p)->lpVtbl->ToString(p, retval))
+#endif /* !VBOX_WITH_GLUE */
+
+interface nsIException
+{
+#ifndef VBOX_WITH_GLUE
+    struct nsIException_vtbl *vtbl;
+#else /* !VBOX_WITH_GLUE */
+    CONST_VTBL struct nsIExceptionVtbl *lpVtbl;
+#endif /* !VBOX_WITH_GLUE */
+};
+
+/* starting interface:    nsIStackFrame */
+#define NS_ISTACKFRAME_IID_STR "91d82105-7c62-4f8b-9779-154277c0ee90"
+
+#define NS_ISTACKFRAME_IID \
+    {0x91d82105, 0x7c62, 0x4f8b, \
+      { 0x97, 0x79, 0x15, 0x42, 0x77, 0xc0, 0xee, 0x90 }}
+
+#ifndef VBOX_WITH_GLUE
+struct nsIStackFrame_vtbl
+{
+    /* Methods from the interface nsISupports */
+    struct nsISupports_vtbl nsisupports;
+
+    nsresult (*GetLanguage)(nsIStackFrame *pThis, PRUint32 *aLanguage);
+    nsresult (*GetLanguageName)(nsIStackFrame *pThis, PRUnichar * *aLanguageName);
+    nsresult (*GetFilename)(nsIStackFrame *pThis, PRUnichar * *aFilename);
+    nsresult (*GetName)(nsIStackFrame *pThis, PRUnichar * *aName);
+    nsresult (*GetLineNumber)(nsIStackFrame *pThis, PRInt32 *aLineNumber);
+    nsresult (*GetSourceLine)(nsIStackFrame *pThis, PRUnichar * *aSourceLine);
+    nsresult (*GetCaller)(nsIStackFrame *pThis, nsIStackFrame * *aCaller);
+    nsresult (*ToString)(nsIStackFrame *pThis, PRUnichar **_retval);
+};
+#else /* !VBOX_WITH_GLUE */
+struct nsIStackFrameVtbl
+{
+    nsresult (*QueryInterface)(nsIStackFrame *pThis, const nsID *iid, void **resultp);
+    nsrefcnt (*AddRef)(nsIStackFrame *pThis);
+    nsrefcnt (*Release)(nsIStackFrame *pThis);
+
+    nsresult (*GetLanguage)(nsIStackFrame *pThis, PRUint32 *aLanguage);
+    nsresult (*GetLanguageName)(nsIStackFrame *pThis, PRUnichar * *aLanguageName);
+    nsresult (*GetFilename)(nsIStackFrame *pThis, PRUnichar * *aFilename);
+    nsresult (*GetName)(nsIStackFrame *pThis, PRUnichar * *aName);
+    nsresult (*GetLineNumber)(nsIStackFrame *pThis, PRInt32 *aLineNumber);
+    nsresult (*GetSourceLine)(nsIStackFrame *pThis, PRUnichar * *aSourceLine);
+    nsresult (*GetCaller)(nsIStackFrame *pThis, nsIStackFrame * *aCaller);
+    nsresult (*ToString)(nsIStackFrame *pThis, PRUnichar **_retval);
+};
+#define nsIStackFrame_QueryInterface(p, iid, resultp) ((p)->lpVtbl->QueryInterface(p, iid, resultp))
+#define nsIStackFrame_AddRef(p) ((p)->lpVtbl->AddRef(p))
+#define nsIStackFrame_Release(p) ((p)->lpVtbl->Release(p))
+#define nsIStackFrame_get_Language(p, aLanguage) ((p)->lpVtbl->GetLanguge(p, aLanguage))
+#define nsIStackFrame_GetLanguage(p, aLanguage) ((p)->lpVtbl->GetLanguge(p, aLanguage))
+#define nsIStackFrame_get_LanguageName(p, aLanguageName) ((p)->lpVtbl->GetLanguageName(p, aLanguageName))
+#define nsIStackFrame_GetLanguageName(p, aLanguageName) ((p)->lpVtbl->GetLanguageName(p, aLanguageName))
+#define nsIStackFrame_get_Filename(p, aFilename) ((p)->lpVtbl->GetFilename(p, aFilename))
+#define nsIStackFrame_GetFilename(p, aFilename) ((p)->lpVtbl->GetFilename(p, aFilename))
+#define nsIStackFrame_get_Name(p, aName) ((p)->lpVtbl->GetName(p, aName))
+#define nsIStackFrame_GetName(p, aName) ((p)->lpVtbl->GetName(p, aName))
+#define nsIStackFrame_get_LineNumber(p, aLineNumber) ((p)->lpVtbl->GetLineNumber(p, aLineNumber))
+#define nsIStackFrame_GetLineNumber(p, aLineNumber) ((p)->lpVtbl->GetLineNumber(p, aLineNumber))
+#define nsIStackFrame_get_SourceLine(p, aSourceLine) ((p)->lpVtbl->GetSourceLine(p, aSourceLine))
+#define nsIStackFrame_GetSourceLine(p, aSourceLine) ((p)->lpVtbl->GetSourceLine(p, aSourceLine))
+#define nsIStackFrame_get_Caller(p, aCaller) ((p)->lpVtbl->GetCaller(p, aCaller))
+#define nsIStackFrame_GetCaller(p, aCaller) ((p)->lpVtbl->GetCaller(p, aCaller))
+#define nsIStackFrame_ToString(p, retval) ((p)->lpVtbl->ToString(p, retval))
+#endif /* !VBOX_WITH_GLUE */
+
+interface nsIStackFrame
+{
+#ifndef VBOX_WITH_GLUE
+    struct nsIStackFrame_vtbl *vtbl;
+#else /* !VBOX_WITH_GLUE */
+    CONST_VTBL struct nsIStackFrameVtbl *lpVtbl;
+#endif /* !VBOX_WITH_GLUE */
+};
+
+/* starting interface:    nsIEventTarget */
+#define NS_IEVENTTARGET_IID_STR "ea99ad5b-cc67-4efb-97c9-2ef620a59f2a"
+
+#define NS_IEVENTTARGET_IID \
+    {0xea99ad5b, 0xcc67, 0x4efb, \
+      { 0x97, 0xc9, 0x2e, 0xf6, 0x20, 0xa5, 0x9f, 0x2a }}
+
+#ifndef VBOX_WITH_GLUE
+struct nsIEventTarget_vtbl
+{
+    struct nsISupports_vtbl nsisupports;
+
+    nsresult (*PostEvent)(nsIEventTarget *pThis, PLEvent * aEvent);
+    nsresult (*IsOnCurrentThread)(nsIEventTarget *pThis, PRBool *_retval);
+};
+#else /* !VBOX_WITH_GLUE */
+struct nsIEventTargetVtbl
+{
+    nsresult (*QueryInterface)(nsIEventTarget *pThis, const nsID *iid, void **resultp);
+    nsrefcnt (*AddRef)(nsIEventTarget *pThis);
+    nsrefcnt (*Release)(nsIEventTarget *pThis);
+
+    nsresult (*PostEvent)(nsIEventTarget *pThis, PLEvent * aEvent);
+    nsresult (*IsOnCurrentThread)(nsIEventTarget *pThis, PRBool *_retval);
+};
+#define nsIEventTarget_QueryInterface(p, iid, resultp) ((p)->lpVtbl->QueryInterface(p, iid, resultp))
+#define nsIEventTarget_AddRef(p) ((p)->lpVtbl->AddRef(p))
+#define nsIEventTarget_Release(p) ((p)->lpVtbl->Release(p))
+#define nsIEventTarget_PostEvent(p, aEvent) ((p)->lpVtbl->PostEvent(p, aEvent))
+#define nsIEventTarget_IsOnCurrentThread(p, retval) ((p)->lpVtbl->IsOnCurrentThread(p, retval))
+#endif /* !VBOX_WITH_GLUE */
+
+interface nsIEventTarget
+{
+#ifndef VBOX_WITH_GLUE
+    struct nsIEventTarget_vtbl *vtbl;
+#else /* !VBOX_WITH_GLUE */
+    CONST_VTBL struct nsIEventTargetVtbl *lpVtbl;
+#endif /* !VBOX_WITH_GLUE */
+};
+
+/* starting interface:    nsIEventQueue */
+#define NS_IEVENTQUEUE_IID_STR "176afb41-00a4-11d3-9f2a-00400553eef0"
+
+#define NS_IEVENTQUEUE_IID \
+  {0x176afb41, 0x00a4, 0x11d3, \
+    { 0x9f, 0x2a, 0x00, 0x40, 0x05, 0x53, 0xee, 0xf0 }}
+
+#ifndef VBOX_WITH_GLUE
+struct nsIEventQueue_vtbl
+{
+    struct nsIEventTarget_vtbl nsieventtarget;
+
+    nsresult (*InitEvent)(nsIEventQueue *pThis, PLEvent * aEvent, void * owner, PLHandleEventProc handler, PLDestroyEventProc destructor);
+    nsresult (*PostSynchronousEvent)(nsIEventQueue *pThis, PLEvent * aEvent, void * *aResult);
+    nsresult (*PendingEvents)(nsIEventQueue *pThis, PRBool *_retval);
+    nsresult (*ProcessPendingEvents)(nsIEventQueue *pThis);
+    nsresult (*EventLoop)(nsIEventQueue *pThis);
+    nsresult (*EventAvailable)(nsIEventQueue *pThis, PRBool *aResult);
+    nsresult (*GetEvent)(nsIEventQueue *pThis, PLEvent * *_retval);
+    nsresult (*HandleEvent)(nsIEventQueue *pThis, PLEvent * aEvent);
+    nsresult (*WaitForEvent)(nsIEventQueue *pThis, PLEvent * *_retval);
+    PRInt32 (*GetEventQueueSelectFD)(nsIEventQueue *pThis);
+    nsresult (*Init)(nsIEventQueue *pThis, PRBool aNative);
+    nsresult (*InitFromPRThread)(nsIEventQueue *pThis, PRThread * thread, PRBool aNative);
+    nsresult (*InitFromPLQueue)(nsIEventQueue *pThis, PLEventQueue * aQueue);
+    nsresult (*EnterMonitor)(nsIEventQueue *pThis);
+    nsresult (*ExitMonitor)(nsIEventQueue *pThis);
+    nsresult (*RevokeEvents)(nsIEventQueue *pThis, void * owner);
+    nsresult (*GetPLEventQueue)(nsIEventQueue *pThis, PLEventQueue * *_retval);
+    nsresult (*IsQueueNative)(nsIEventQueue *pThis, PRBool *_retval);
+    nsresult (*StopAcceptingEvents)(nsIEventQueue *pThis);
+};
+#else /* !VBOX_WITH_GLUE */
+struct nsIEventQueueVtbl
+{
+    nsresult (*QueryInterface)(nsIEventQueue *pThis, const nsID *iid, void **resultp);
+    nsrefcnt (*AddRef)(nsIEventQueue *pThis);
+    nsrefcnt (*Release)(nsIEventQueue *pThis);
+
+    nsresult (*PostEvent)(nsIEventQueue *pThis, PLEvent * aEvent);
+    nsresult (*IsOnCurrentThread)(nsIEventQueue *pThis, PRBool *_retval);
+
+    nsresult (*InitEvent)(nsIEventQueue *pThis, PLEvent * aEvent, void * owner, PLHandleEventProc handler, PLDestroyEventProc destructor);
+    nsresult (*PostSynchronousEvent)(nsIEventQueue *pThis, PLEvent * aEvent, void * *aResult);
+    nsresult (*PendingEvents)(nsIEventQueue *pThis, PRBool *_retval);
+    nsresult (*ProcessPendingEvents)(nsIEventQueue *pThis);
+    nsresult (*EventLoop)(nsIEventQueue *pThis);
+    nsresult (*EventAvailable)(nsIEventQueue *pThis, PRBool *aResult);
+    nsresult (*GetEvent)(nsIEventQueue *pThis, PLEvent * *_retval);
+    nsresult (*HandleEvent)(nsIEventQueue *pThis, PLEvent * aEvent);
+    nsresult (*WaitForEvent)(nsIEventQueue *pThis, PLEvent * *_retval);
+    PRInt32 (*GetEventQueueSelectFD)(nsIEventQueue *pThis);
+    nsresult (*Init)(nsIEventQueue *pThis, PRBool aNative);
+    nsresult (*InitFromPRThread)(nsIEventQueue *pThis, PRThread * thread, PRBool aNative);
+    nsresult (*InitFromPLQueue)(nsIEventQueue *pThis, PLEventQueue * aQueue);
+    nsresult (*EnterMonitor)(nsIEventQueue *pThis);
+    nsresult (*ExitMonitor)(nsIEventQueue *pThis);
+    nsresult (*RevokeEvents)(nsIEventQueue *pThis, void * owner);
+    nsresult (*GetPLEventQueue)(nsIEventQueue *pThis, PLEventQueue * *_retval);
+    nsresult (*IsQueueNative)(nsIEventQueue *pThis, PRBool *_retval);
+    nsresult (*StopAcceptingEvents)(nsIEventQueue *pThis);
+};
+#define nsIEventQueue_QueryInterface(p, iid, resultp) ((p)->lpVtbl->QueryInterface(p, iid, resultp))
+#define nsIEventQueue_AddRef(p) ((p)->lpVtbl->AddRef(p))
+#define nsIEventQueue_Release(p) ((p)->lpVtbl->Release(p))
+#define nsIEventQueue_PostEvent(p, aEvent) ((p)->lpVtbl->PostEvent(p, aEvent))
+#define nsIEventQueue_IsOnCurrentThread(p, retval) ((p)->lpVtbl->IsOnCurrentThread(p, retval))
+#define nsIEventQueue_InitEvent(p, aEvent, owner, handler, destructor) ((p)->lpVtbl->InitEvent(p, aEvent, owner, handler, destructor))
+#define nsIEventQueue_PostSynchronousEvent(p, aEvent, aResult) ((p)->lpVtbl->PostSynchronousEvent(p, aEvent, aResult))
+#define nsIEventQueue_ProcessPendingEvents(p) ((p)->lpVtbl->ProcessPendingEvents(p))
+#define nsIEventQueue_EventLoop(p) ((p)->lpVtbl->EventLoop(p))
+#define nsIEventQueue_EventAvailable(p, aResult) ((p)->lpVtbl->EventAvailable(p, aResult))
+#define nsIEventQueue_get_Event(p, aEvent) ((p)->lpVtbl->GetEvent(p, aEvent))
+#define nsIEventQueue_GetEvent(p, aEvent) ((p)->lpVtbl->GetEvent(p, aEvent))
+#define nsIEventQueue_HandleEvent(p, aEvent) ((p)->lpVtbl->HandleEvent(p, aEvent))
+#define nsIEventQueue_WaitForEvent(p, aEvent) ((p)->lpVtbl->WaitForEvent(p, aEvent))
+#define nsIEventQueue_GetEventQueueSelectFD(p) ((p)->lpVtbl->GetEventQueueSelectFD(p))
+#define nsIEventQueue_Init(p, aNative) ((p)->lpVtbl->Init(p, aNative))
+#define nsIEventQueue_InitFromPLQueue(p, aQueue) ((p)->lpVtbl->InitFromPLQueue(p, aQueue))
+#define nsIEventQueue_EnterMonitor(p) ((p)->lpVtbl->EnterMonitor(p))
+#define nsIEventQueue_ExitMonitor(p) ((p)->lpVtbl->ExitMonitor(p))
+#define nsIEventQueue_RevokeEvents(p, owner) ((p)->lpVtbl->RevokeEvents(p, owner))
+#define nsIEventQueue_GetPLEventQueue(p, retval) ((p)->lpVtbl->GetPLEventQueue(p, retval))
+#define nsIEventQueue_IsQueueNative(p, retval) ((p)->lpVtbl->IsQueueNative(p, retval))
+#define nsIEventQueue_StopAcceptingEvents(p) ((p)->lpVtbl->StopAcceptingEvents(p))
+#endif /* !VBOX_WITH_GLUE */
+
+interface nsIEventQueue
+{
+#ifndef VBOX_WITH_GLUE
+    struct nsIEventQueue_vtbl *vtbl;
+#else /* !VBOX_WITH_GLUE */
+    CONST_VTBL struct nsIEventQueueVtbl *lpVtbl;
+#endif /* !VBOX_WITH_GLUE */
+};
+</xsl:text>
+ <xsl:call-template name="xsltprocNewlineOutputHack"/>
+ <xsl:apply-templates/>
+ <xsl:text>
+
+#endif /* __cplusplus */
+
+#endif /* !WIN32 */
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+
+/**
+ * Function table for dynamic linking.
+ * Use VBoxGetCAPIFunctions() to obtain the pointer to it.
+ */
+typedef struct VBOXCAPI
+{
+    /** The size of the structure. */
+    unsigned cb;
+    /** The structure version. */
+    unsigned uVersion;
+
+    /** Gets the VirtualBox version, major * 1000000 + minor * 1000 + patch. */
+    unsigned int (*pfnGetVersion)(void);
+
+    /** Gets the VirtualBox API version, major * 1000 + minor, e.g. 4003. */
+    unsigned int (*pfnGetAPIVersion)(void);
+
+    /**
+     * New and preferred way to initialize the C bindings for an API client.
+     *
+     * This way is much more flexible, as it can easily handle multiple
+     * sessions (important with more complicated API clients, including
+     * multithreaded ones), and even VBoxSVC crashes can be detected and
+     * processed appropriately by listening for events from the associated
+     * event source in VirtualBoxClient. It is completely up to the client
+     * to decide what to do (terminate or continue after getting new
+     * object references to server-side objects). Must be called in the
+     * primary thread of the client, later API use can be done in any
+     * thread.
+     *
+     * Note that the returned reference is owned by the caller, and thus it's
+     * the caller's responsibility to handle the reference count appropriately.
+     *
+     * @param pszVirtualBoxClientIID    pass IVIRTUALBOXCLIENT_IID_STR
+     * @param ppVirtualBoxClient        output parameter for VirtualBoxClient
+     *              reference, handled as usual with COM/XPCOM.
+     * @returns COM/XPCOM error code
+     */
+    HRESULT (*pfnClientInitialize)(const char *pszVirtualBoxClientIID,
+                                   IVirtualBoxClient **ppVirtualBoxClient);
+    /**
+     * Initialize the use of the C bindings in a non-primary thread.
+     *
+     * Must be called on any newly created thread which wants to use the
+     * VirtualBox API.
+     *
+     * @returns COM/XPCOM error code
+     */
+    HRESULT (*pfnClientThreadInitialize)(void);
+    /**
+     * Uninitialize the use of the C bindings in a non-primary thread.
+     *
+     * Should be called before terminating the thread which initialized the
+     * C bindings using pfnClientThreadInitialize.
+     *
+     * @returns COM/XPCOM error code
+     */
+    HRESULT (*pfnClientThreadUninitialize)(void);
+    /**
+     * Uninitialize the C bindings for an API client.
+     *
+     * Should be called when the API client is about to terminate and does
+     * not want to use the C bindings any more. It will invalidate all
+     * object references. It is possible, however, to change one's mind,
+     * and call pfnClientInitialize again to continue using the API, as long
+     * as none of the object references from before the re-initialization
+     * are used. Must be called from the primary thread of the client.
+     */
+    void (*pfnClientUninitialize)(void);
+
+    /**
+     * Deprecated way to initialize the C bindings and getting important
+     * object references. Kept for backwards compatibility.
+     *
+     * If any returned reference is NULL then the initialization failed.
+     * Note that the returned references are owned by the C bindings. The
+     * number of calls to Release in the client code must match the number
+     * of calls to AddRef, and additionally at no point in time there can
+     * be more Release calls than AddRef calls.
+     *
+     * @param pszVirtualBoxIID      pass IVIRTUALBOX_IID_STR
+     * @param ppVirtualBox          output parameter for VirtualBox reference,
+     *          owned by C bindings
+     * @param pszSessionIID         pass ISESSION_IID_STR
+     * @param ppSession             output parameter for Session reference,
+     *          owned by C bindings
+     */
+    void (*pfnComInitialize)(const char *pszVirtualBoxIID,
+                             IVirtualBox **ppVirtualBox,
+                             const char *pszSessionIID,
+                             ISession **ppSession);
+    /**
+     * Deprecated way to uninitialize the C bindings for an API client.
+     * Kept for backwards compatibility and must be used if the C bindings
+     * were initialized using pfnComInitialize. */
+    void (*pfnComUninitialize)(void);
+
+    /**
+     * Free string managed by COM/XPCOM.
+     *
+     * @param pwsz          pointer to string to be freed
+     */
+    void (*pfnComUnallocString)(BSTR pwsz);
+#ifndef WIN32
+    /** Legacy function, was always for freeing strings only. */
+#define pfnComUnallocMem(pv) pfnComUnallocString((BSTR)(pv))
+#endif /* !WIN32 */
+
+    /**
+     * Convert string from UTF-16 encoding to UTF-8 encoding.
+     *
+     * @param pwszString    input string
+     * @param ppszString    output string
+     * @returns IPRT status code
+     */
+    int (*pfnUtf16ToUtf8)(CBSTR pwszString, char **ppszString);
+    /**
+     * Convert string from UTF-8 encoding to UTF-16 encoding.
+     *
+     * @param pszString     input string
+     * @param ppwszString   output string
+     * @returns IPRT status code
+     */
+    int (*pfnUtf8ToUtf16)(const char *pszString, BSTR *ppwszString);
+    /**
+     * Free memory returned by pfnUtf16ToUtf8. Do not use for anything else.
+     *
+     * @param pszString     string to be freed.
+     */
+    void (*pfnUtf8Free)(char *pszString);
+    /**
+     * Free memory returned by pfnUtf8ToUtf16. Do not use for anything else.
+     *
+     * @param pwszString    string to be freed.
+     */
+    void (*pfnUtf16Free)(BSTR pwszString);
+
+    /**
+     * Create a safearray (used for passing arrays to COM/XPCOM)
+     *
+     * Must be freed by pfnSafeArrayDestroy.
+     *
+     * @param vt            variant type, defines the size of the elements
+     * @param lLbound       lower bound of the index, should be 0
+     * @param cElements     number of elements
+     * @returns pointer to safearray
+     */
+    SAFEARRAY *(*pfnSafeArrayCreateVector)(VARTYPE vt, LONG lLbound, ULONG cElements);
+    /**
+     * Pre-allocate a safearray to be used by an out safearray parameter
+     *
+     * Must be freed by pfnSafeArrayDestroy.
+     *
+     * @returns pointer to safearray (system dependent, may be NULL if
+     *    there is no need to pre-allocate a safearray)
+     */
+    SAFEARRAY *(*pfnSafeArrayOutParamAlloc)(void);
+    /**
+     * Copy a C array into a safearray (for passing as an input parameter)
+     *
+     * @param psa           pointer to already created safearray.
+     * @param pv            pointer to memory block to copy into safearray.
+     * @param cb            number of bytes to copy.
+     * @returns COM/XPCOM error code
+     */
+    HRESULT (*pfnSafeArrayCopyInParamHelper)(SAFEARRAY *psa, const void *pv, ULONG cb);
+    /**
+     * Copy a safearray into a C array (for getting an output parameter)
+     *
+     * @param ppv           output pointer to newly created array, which has to
+     *          be freed with pfnArrayOutFree.
+     * @param pcb           number of bytes in the output buffer.
+     * @param vt            variant type, defines the size of the elements
+     * @param psa           pointer to safearray for getting the data
+     * @returns COM/XPCOM error code
+     */
+    HRESULT (*pfnSafeArrayCopyOutParamHelper)(void **ppv, ULONG *pcb, VARTYPE vt, SAFEARRAY *psa);
+    /**
+     * Copy a safearray into a C array (special variant for interface pointers)
+     *
+     * @param ppaObj        output pointer to newly created array, which has
+     *          to be freed with pfnArrayOutFree. Note that it's the caller's
+     *          responsibility to call Release() on each non-NULL interface
+     *          pointer before freeing.
+     * @param pcObj         number of pointers in the output buffer.
+     * @param psa           pointer to safearray for getting the data
+     * @returns COM/XPCOM error code
+     */
+    HRESULT (*pfnSafeArrayCopyOutIfaceParamHelper)(IUnknown ***ppaObj, ULONG *pcObj, SAFEARRAY *psa);
+    /**
+     * Free a safearray
+     *
+     * @param psa           pointer to safearray
+     * @returns COM/XPCOM error code
+     */
+    HRESULT (*pfnSafeArrayDestroy)(SAFEARRAY *psa);
+    /**
+     * Free an out array created by pfnSafeArrayCopyOutParamHelper or
+     * pdnSafeArrayCopyOutIfaceParamHelper.
+     *
+     * @param psa           pointer to memory block
+     * @returns COM/XPCOM error code
+     */
+    HRESULT (*pfnArrayOutFree)(void *pv);
+
+#ifndef WIN32
+    /**
+     * Get XPCOM event queue. Deprecated!
+     *
+     * @param ppEventQueue      output parameter for nsIEventQueue reference,
+     *              owned by C bindings.
+     */
+    void (*pfnGetEventQueue)(nsIEventQueue **ppEventQueue);
+#endif /* !WIN32 */
+
+    /**
+     * Get current COM/XPCOM exception.
+     *
+     * @param ppException       output parameter for exception info reference,
+     *              may be @c NULL if no exception object has been created by
+     *              a previous COM/XPCOM call.
+     * @returns COM/XPCOM error code
+     */
+    HRESULT (*pfnGetException)(IErrorInfo **ppException);
+    /**
+     * Clears current COM/XPCOM exception.
+     *
+     * @returns COM/XPCOM error code
+     */
+    HRESULT (*pfnClearException)(void);
+
+    /**
+     * Process the event queue for a given amount of time.
+     *
+     * Must be called on the primary thread. Typical timeouts are from 200 to
+     * 5000 msecs, to allow for checking a volatile variable if the event queue
+     * processing should be terminated (,
+     * or 0 if only the pending events should be processed, without waiting.
+     *
+     * @param iTimeoutMS        how long to process the event queue, -1 means
+     *              infinitely long
+     * @returns status code
+     * @retval 0 if at least one event has been processed
+     * @retval 1 if any signal interrupted the native system call (or returned
+     *      otherwise)
+     * @retval 2 if the event queue was explicitly interrupted
+     * @retval 3 if the timeout expired
+     * @retval 4 if the function was called from the wrong thread
+     * @retval 5 for all other (unexpected) errors
+     */
+    int (*pfnProcessEventQueue)(LONG64 iTimeoutMS);
+    /**
+     * Interrupt event queue processing.
+     *
+     * Can be called on any thread. Note that this function is not async-signal
+     * safe, so never use it in such a context, instead use a volatile global
+     * variable and a sensible timeout.
+     * @returns 0 if successful, 1 otherwise.
+     */
+    int (*pfnInterruptEventQueueProcessing)(void);
+
+    /**
+     * Clear memory used by a UTF-8 string. Must be zero terminated.
+     * Can be used for any UTF-8 or ASCII/ANSI string.
+     *
+     * @param pszString     input/output string
+     */
+    void (*pfnUtf8Clear)(char *pszString);
+    /**
+     * Clear memory used by a UTF-16 string. Must be zero terminated.
+     * Can be used for any UTF-16 or UCS-2 string.
+     *
+     * @param pwszString    input/output string
+     */
+     void (*pfnUtf16Clear)(BSTR pwszString);
+
+    /** Tail version, same as uVersion.
+     *
+     * This should only be accessed if for some reason an API client needs
+     * exactly the version it requested, or if cb is used to calculate the
+     * address of this field. It may move as the structure before this is
+     * allowed to grow as long as all the data from earlier minor versions
+     * remains at the same place.
+     */
+    unsigned uEndVersion;
+} VBOXCAPI;
+/** Pointer to a const VBOXCAPI function table. */
+typedef VBOXCAPI const *PCVBOXCAPI;
+#ifndef WIN32
+/** Backwards compatibility: Pointer to a const VBOXCAPI function table.
+ * Use PCVBOXCAPI instead. */
+typedef VBOXCAPI const *PCVBOXXPCOM;
+#endif /* !WIN32 */
+
+#ifndef WIN32
+/** Backwards compatibility: make sure old code using VBOXXPCOMC still compiles.
+ * Use VBOXCAPI instead. */
+#define VBOXXPCOMC VBOXCAPI
+#endif /* !WIN32 */
+
+/** Extract the C API style major version.
+ * Useful for comparing the interface version in VBOXCAPI::uVersion. */
+#define VBOX_CAPI_MAJOR(x) (((x) &amp; 0xffff0000U) &gt;&gt; 16)
+
+/** Extract the C API style major version.
+ * Useful for comparing the interface version in VBOXCAPI::uVersion. */
+#define VBOX_CAPI_MINOR(x) ((x) &amp; 0x0000ffffU)
+
+/** The current interface version.
+ * For use with VBoxGetCAPIFunctions and to be found in VBOXCAPI::uVersion. */
+#define VBOX_CAPI_VERSION 0x00040001U
+
+#ifndef WIN32
+/** Backwards compatibility: The current interface version.
+ * Use VBOX_CAPI_VERSION instead. */
+#define VBOX_XPCOMC_VERSION VBOX_CAPI_VERSION
+#endif /* !WIN32 */
+
+/** VBoxGetCAPIFunctions. */
+VBOXCAPI_DECL(PCVBOXCAPI) VBoxGetCAPIFunctions(unsigned uVersion);
+#ifndef WIN32
+/** Backwards compatibility: VBoxGetXPCOMCFunctions.
+ * Use VBoxGetCAPIFunctions instead. */
+VBOXCAPI_DECL(PCVBOXCAPI) VBoxGetXPCOMCFunctions(unsigned uVersion);
+#endif /* !WIN32 */
+
+/** Typedef for VBoxGetCAPIFunctions. */
+typedef PCVBOXCAPI (*PFNVBOXGETCAPIFUNCTIONS)(unsigned uVersion);
+#ifndef WIN32
+/** Backwards compatibility: Typedef for VBoxGetXPCOMCFunctions.
+ * Use PFNVBOXGETCAPIFUNCTIONS instead. */
+typedef PCVBOXCAPI (*PFNVBOXGETXPCOMCFUNCTIONS)(unsigned uVersion);
+#endif /* !WIN32 */
+
+/** The symbol name of VBoxGetCAPIFunctions. */
+#ifdef __OS2__
+# define VBOX_GET_CAPI_FUNCTIONS_SYMBOL_NAME "_VBoxGetCAPIFunctions"
+#else /* !__OS2__ */
+# define VBOX_GET_CAPI_FUNCTIONS_SYMBOL_NAME "VBoxGetCAPIFunctions"
+#endif /* !__OS2__ */
+#ifndef WIN32
+/** Backwards compatibility: The symbol name of VBoxGetXPCOMCFunctions.
+ * Use VBOX_GET_CAPI_FUNCTIONS_SYMBOL_NAME instead. */
+# ifdef __OS2__
+#  define VBOX_GET_XPCOMC_FUNCTIONS_SYMBOL_NAME "_VBoxGetXPCOMCFunctions"
+# else /* !__OS2__ */
+#  define VBOX_GET_XPCOMC_FUNCTIONS_SYMBOL_NAME "VBoxGetXPCOMCFunctions"
+# endif /* !__OS2__ */
+#endif /* !WIN32 */
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* !___VirtualBox_CAPI_h */
+</xsl:text>
+</xsl:template>
+
+<!--
+ *  ignore all |if|s except those for XPIDL target
+-->
+<xsl:template match="if">
+  <xsl:if test="@target='xpidl'">
+    <xsl:apply-templates/>
+  </xsl:if>
+</xsl:template>
+<xsl:template match="if" mode="forward">
+  <xsl:if test="@target='xpidl'">
+    <xsl:apply-templates mode="forward"/>
+  </xsl:if>
+</xsl:template>
+<xsl:template match="if" mode="forwarder">
+  <xsl:if test="@target='midl'">
+    <xsl:apply-templates mode="forwarder"/>
+  </xsl:if>
+</xsl:template>
+
+
+<!--
+ *  libraries
+-->
+<xsl:template match="idl/library">
+  <!-- result codes -->
+  <xsl:call-template name="xsltprocNewlineOutputHack"/>
+  <xsl:for-each select="application/result">
+    <xsl:apply-templates select="."/>
+  </xsl:for-each>
+  <xsl:call-template name="xsltprocNewlineOutputHack"/>
+  <xsl:call-template name="xsltprocNewlineOutputHack"/>
+  <!-- forward declarations -->
+  <xsl:apply-templates select="application/interface | application/if/interface" mode="forward"/>
+  <xsl:call-template name="xsltprocNewlineOutputHack"/>
+  <!-- typedef'ing the struct declarations -->
+  <xsl:apply-templates select="application/interface | application/if/interface" mode="typedef"/>
+  <xsl:call-template name="xsltprocNewlineOutputHack"/>
+  <!-- all enums go first -->
+  <xsl:apply-templates select="application/enum | application/if/enum"/>
+  <!-- everything else but result codes and enums
+  <xsl:apply-templates select="*[not(self::result or self::enum) and
+                                 not(self::if[result] or self::if[enum])]"/> -->
+    <!-- the modules (i.e. everything else) -->
+  <xsl:apply-templates select="application/interface | application/if[interface]
+                                   | application/module | application/if[module]"/>
+  <!-- -->
+</xsl:template>
+
+
+<!--
+ *  result codes
+-->
+<xsl:template match="result">
+  <xsl:value-of select="concat('#define ',@name,' ((HRESULT)',@value, ')')"/>
+  <xsl:text>&#x0A;</xsl:text>
+</xsl:template>
+
+
+<!--
+ *  forward declarations
+-->
+<xsl:template match="interface" mode="forward">
+  <xsl:if test="not(@internal='yes')">
+    <xsl:text>interface </xsl:text>
+    <xsl:value-of select="@name"/>
+    <xsl:text>;&#x0A;</xsl:text>
+  </xsl:if>
+</xsl:template>
+
+
+<!--
+ *  typedef'ing the struct declarations
+-->
+<xsl:template match="interface" mode="typedef">
+  <xsl:if test="not(@internal='yes')">
+    <xsl:text>typedef interface </xsl:text>
+    <xsl:value-of select="@name"/>
+    <xsl:text> </xsl:text>
+    <xsl:value-of select="@name"/>
+    <xsl:text>;&#x0A;</xsl:text>
+  </xsl:if>
+</xsl:template>
+
+
+<!--
+ *  COBJMACRO style convenience macros for calling methods
+-->
+<xsl:template match="interface" mode="cobjmacro">
+  <xsl:param name="iface"/>
+
+  <xsl:variable name="extends" select="@extends"/>
+  <xsl:choose>
+    <xsl:when test="$extends='$unknown'">
+      <xsl:text>#define </xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text>_QueryInterface(p, iid, resultp) ((p)->lpVtbl->QueryInterface(p, iid, resultp))&#x0A;</xsl:text>
+      <xsl:text>#define </xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text>_AddRef(p) ((p)->lpVtbl->AddRef(p))&#x0A;</xsl:text>
+      <xsl:text>#define </xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text>_Release(p) ((p)->lpVtbl->Release(p))&#x0A;</xsl:text>
+    </xsl:when>
+    <xsl:when test="$extends='$errorinfo'">
+      <xsl:text>#define </xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text>_QueryInterface(p, iid, resultp) ((p)->lpVtbl->QueryInterface(p, iid, resultp))&#x0A;</xsl:text>
+      <xsl:text>#define </xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text>_AddRef(p) ((p)->lpVtbl->AddRef(p))&#x0A;</xsl:text>
+      <xsl:text>#define </xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text>_Release(p) ((p)->lpVtbl->Release(p))&#x0A;</xsl:text>
+      <xsl:text>#define </xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text>_get_Message(p, aMessage) ((p)->lpVtbl->GetMessage(p, aMessage))&#x0A;</xsl:text>
+      <xsl:text>#define </xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text>_GetMessage(p, aMessage) ((p)->lpVtbl->GetMessage(p, aMessage))&#x0A;</xsl:text>
+      <xsl:text>#define </xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text>_get_Result(p, aResult) ((p)->lpVtbl->GetResult(p, aResult))&#x0A;</xsl:text>
+      <xsl:text>#define </xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text>_GetResult(p, aResult) ((p)->lpVtbl->GetResult(p, aResult))&#x0A;</xsl:text>
+      <xsl:text>#define </xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text>_get_Name(p, aName) ((p)->lpVtbl->GetName(p, aName))&#x0A;</xsl:text>
+      <xsl:text>#define </xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text>_GetName(p, aName) ((p)->lpVtbl->GetName(p, aName))&#x0A;</xsl:text>
+      <xsl:text>#define </xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text>_get_Filename(p, aFilename) ((p)->lpVtbl->GetFilename(p, aFilename))&#x0A;</xsl:text>
+      <xsl:text>#define </xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text>_GetFilename(p, aFilename) ((p)->lpVtbl->GetFilename(p, aFilename))&#x0A;</xsl:text>
+      <xsl:text>#define </xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text>_get_LineNumber(p, aLineNumber) ((p)->lpVtbl->GetLineNumber(p, aLineNumber))&#x0A;</xsl:text>
+      <xsl:text>#define </xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text>_GetLineNumber(p, aLineNumber) ((p)->lpVtbl->GetLineNumber(p, aLineNumber))&#x0A;</xsl:text>
+      <xsl:text>#define </xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text>_get_ColumnNumber(p, aColumnNumber) ((p)->lpVtbl->GetColumnNumber(p, aColumnNumber))&#x0A;</xsl:text>
+      <xsl:text>#define </xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text>_GetColumnNumber(p, aColumnNumber) ((p)->lpVtbl->GetColumnNumber(p, aColumnNumber))&#x0A;</xsl:text>
+      <xsl:text>#define </xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text>_get_Location(p, aLocation) ((p)->lpVtbl->GetLocation(p, aLocation))&#x0A;</xsl:text>
+      <xsl:text>#define </xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text>_GetLocation(p, aLocation) ((p)->lpVtbl->GetLocation(p, aLocation))&#x0A;</xsl:text>
+      <xsl:text>#define </xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text>_get_Inner(p, aInner) ((p)->lpVtbl->GetInner(p, aInner))&#x0A;</xsl:text>
+      <xsl:text>#define </xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text>_GetInner(p, aInner) ((p)->lpVtbl->GetInner(p, aInner))&#x0A;</xsl:text>
+      <xsl:text>#define </xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text>_get_Data(p, aData) ((p)->lpVtbl->GetData(p, aData))&#x0A;</xsl:text>
+      <xsl:text>#define </xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text>_GetData(p, aData) ((p)->lpVtbl->GetData(p, aData))&#x0A;</xsl:text>
+      <xsl:text>#define </xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text>_ToString(p, retval) ((p)->lpVtbl->ToString(p, retval))&#x0A;</xsl:text>
+    </xsl:when>
+    <xsl:otherwise>
+      <xsl:apply-templates select="key('G_keyInterfacesByName', $extends)" mode="cobjmacro">
+        <xsl:with-param name="iface" select="$iface"/>
+      </xsl:apply-templates>
+    </xsl:otherwise>
+  </xsl:choose>
+  <!-- attributes (properties) -->
+  <xsl:apply-templates select="attribute | if/attribute" mode="cobjmacro">
+    <xsl:with-param name="iface" select="$iface"/>
+  </xsl:apply-templates>
+  <!-- methods -->
+  <xsl:apply-templates select="method | if/method" mode="cobjmacro">
+    <xsl:with-param name="iface" select="$iface"/>
+  </xsl:apply-templates>
+</xsl:template>
+
+
+<!--
+ *  emit flat vtable, compatible with COM
+-->
+<xsl:template match="interface" mode="vtab_flat">
+  <xsl:param name="iface"/>
+
+  <xsl:variable name="name" select="@name"/>
+  <xsl:variable name="extends" select="@extends"/>
+  <xsl:choose>
+    <xsl:when test="$extends='$unknown'">
+      <xsl:text>    nsresult (*QueryInterface)(</xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text> *pThis, const nsID *iid, void **resultp);&#x0A;</xsl:text>
+      <xsl:text>    nsrefcnt (*AddRef)(</xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text> *pThis);&#x0A;</xsl:text>
+      <xsl:text>    nsrefcnt (*Release)(</xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text> *pThis);&#x0A;</xsl:text>
+    </xsl:when>
+    <xsl:when test="$extends='$errorinfo'">
+      <xsl:text>    nsresult (*QueryInterface)(</xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text> *pThis, const nsID *iid, void **resultp);&#x0A;</xsl:text>
+      <xsl:text>    nsrefcnt (*AddRef)(</xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text> *pThis);&#x0A;</xsl:text>
+      <xsl:text>    nsrefcnt (*Release)(</xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text> *pThis);&#x0A;</xsl:text>
+      <xsl:text>    nsresult (*GetMessage)(</xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text> *pThis, PRUnichar * *aMessage);&#x0A;</xsl:text>
+      <xsl:text>    nsresult (*GetResult)(</xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text> *pThis, nsresult *aResult);&#x0A;</xsl:text>
+      <xsl:text>    nsresult (*GetName)(</xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text>*pThis, PRUnichar * *aName);&#x0A;</xsl:text>
+      <xsl:text>    nsresult (*GetFilename)(</xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text> *pThis, PRUnichar * *aFilename);&#x0A;</xsl:text>
+      <xsl:text>    nsresult (*GetLineNumber)(</xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text> *pThis, PRUint32 *aLineNumber);&#x0A;</xsl:text>
+      <xsl:text>    nsresult (*GetColumnNumber)(</xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text> *pThis, PRUint32 *aColumnNumber);&#x0A;</xsl:text>
+      <xsl:text>    nsresult (*GetLocation)(</xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text> *pThis, nsIStackFrame * *aLocation);&#x0A;</xsl:text>
+      <xsl:text>    nsresult (*GetInner)(</xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text> *pThis, nsIException * *aInner);&#x0A;</xsl:text>
+      <xsl:text>    nsresult (*GetData)(</xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text> *pThis, nsISupports * *aData);&#x0A;</xsl:text>
+      <xsl:text>    nsresult (*ToString)(</xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text> *pThis, PRUnichar **_retval);&#x0A;</xsl:text>
+    </xsl:when>
+    <xsl:otherwise>
+      <xsl:apply-templates select="key('G_keyInterfacesByName', $extends)" mode="vtab_flat">
+        <xsl:with-param name="iface" select="$iface"/>
+      </xsl:apply-templates>
+    </xsl:otherwise>
+  </xsl:choose>
+  <!-- attributes (properties) -->
+  <xsl:apply-templates select="attribute | if/attribute">
+    <xsl:with-param name="iface" select="$iface"/>
+  </xsl:apply-templates>
+  <xsl:variable name="reservedAttributes" select="@reservedAttributes"/>
+  <xsl:if test="$reservedAttributes > 0">
+    <!-- tricky way to do a "for" loop without recursion -->
+    <xsl:for-each select="(//*)[position() &lt;= $reservedAttributes]">
+      <xsl:text>    nsresult (*GetInternalAndReservedAttribute</xsl:text>
+      <xsl:value-of select="concat(position(), $name)"/>
+      <xsl:text>)(</xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text> *pThis, PRUint32 *reserved);&#x0A;&#x0A;</xsl:text>
+    </xsl:for-each>
+  </xsl:if>
+  <!-- methods -->
+  <xsl:apply-templates select="method | if/method">
+    <xsl:with-param name="iface" select="$iface"/>
+  </xsl:apply-templates>
+  <xsl:variable name="reservedMethods" select="@reservedMethods"/>
+  <xsl:if test="$reservedMethods > 0">
+    <!-- tricky way to do a "for" loop without recursion -->
+    <xsl:for-each select="(//*)[position() &lt;= $reservedMethods]">
+      <xsl:text>    nsresult (*InternalAndReservedMethod</xsl:text>
+      <xsl:value-of select="concat(position(), $name)"/>
+      <xsl:text>)(</xsl:text>
+      <xsl:value-of select="$iface"/>
+      <xsl:text> *pThis);&#x0A;&#x0A;</xsl:text>
+    </xsl:for-each>
+  </xsl:if>
+</xsl:template>
+
+
+<!--
+ *  interfaces
+-->
+<xsl:template match="interface">
+  <xsl:if test="not(@internal='yes')">
+    <xsl:variable name="name" select="@name"/>
+    <xsl:text>/* Start of struct </xsl:text>
+    <xsl:value-of select="$name"/>
+    <xsl:text> declaration */&#x0A;</xsl:text>
+    <xsl:text>#define </xsl:text>
+    <xsl:call-template name="string-to-upper">
+      <xsl:with-param name="str" select="$name"/>
+    </xsl:call-template>
+    <xsl:value-of select="concat('_IID_STR &quot;',@uuid,'&quot;')"/>
+    <xsl:text>&#x0A;</xsl:text>
+    <xsl:text>#define </xsl:text>
+    <xsl:call-template name="string-to-upper">
+      <xsl:with-param name="str" select="$name"/>
+    </xsl:call-template>
+    <xsl:text>_IID { \&#x0A;</xsl:text>
+    <xsl:text>    0x</xsl:text><xsl:value-of select="substring(@uuid,1,8)"/>
+    <xsl:text>, 0x</xsl:text><xsl:value-of select="substring(@uuid,10,4)"/>
+    <xsl:text>, 0x</xsl:text><xsl:value-of select="substring(@uuid,15,4)"/>
+    <xsl:text>, \&#x0A;    </xsl:text>
+    <xsl:text>{ 0x</xsl:text><xsl:value-of select="substring(@uuid,20,2)"/>
+    <xsl:text>, 0x</xsl:text><xsl:value-of select="substring(@uuid,22,2)"/>
+    <xsl:text>, 0x</xsl:text><xsl:value-of select="substring(@uuid,25,2)"/>
+    <xsl:text>, 0x</xsl:text><xsl:value-of select="substring(@uuid,27,2)"/>
+    <xsl:text>, 0x</xsl:text><xsl:value-of select="substring(@uuid,29,2)"/>
+    <xsl:text>, 0x</xsl:text><xsl:value-of select="substring(@uuid,31,2)"/>
+    <xsl:text>, 0x</xsl:text><xsl:value-of select="substring(@uuid,33,2)"/>
+    <xsl:text>, 0x</xsl:text><xsl:value-of select="substring(@uuid,35,2)"/>
+    <xsl:text> } \&#x0A;}&#x0A;</xsl:text>
+    <xsl:text>/* COM compatibility */&#x0A;</xsl:text>
+    <xsl:text>VBOX_EXTERN_CONST(nsIID, IID_</xsl:text>
+    <xsl:value-of select="$name"/>
+    <xsl:text>);&#x0A;</xsl:text>
+    <xsl:text>#ifndef VBOX_WITH_GLUE&#x0A;</xsl:text>
+    <xsl:text>struct </xsl:text>
+    <xsl:value-of select="$name"/>
+    <xsl:text>_vtbl&#x0A;{&#x0A;</xsl:text>
+    <xsl:text>    </xsl:text>
+    <xsl:choose>
+      <xsl:when test="@extends='$unknown'">struct nsISupports_vtbl nsisupports;</xsl:when>
+      <xsl:when test="@extends='$errorinfo'">struct nsIException_vtbl nsiexception;</xsl:when>
+      <xsl:otherwise>
+        <xsl:text>struct </xsl:text>
+        <xsl:value-of select="@extends"/>
+        <xsl:text>_vtbl </xsl:text>
+        <xsl:call-template name="string-to-lower">
+          <xsl:with-param name="str" select="@extends"/>
+        </xsl:call-template>
+        <xsl:text>;</xsl:text>
+      </xsl:otherwise>
+    </xsl:choose>
+    <xsl:text>&#x0A;&#x0A;</xsl:text>
+    <!-- attributes (properties) -->
+    <xsl:apply-templates select="attribute | if/attribute"/>
+    <xsl:variable name="reservedAttributes" select="@reservedAttributes"/>
+    <xsl:if test="$reservedAttributes > 0">
+      <!-- tricky way to do a "for" loop without recursion -->
+      <xsl:for-each select="(//*)[position() &lt;= $reservedAttributes]">
+        <xsl:text>    nsresult (*GetInternalAndReservedAttribute</xsl:text>
+        <xsl:value-of select="concat(position(), $name)"/>
+        <xsl:text>)(</xsl:text>
+        <xsl:value-of select="$name"/>
+        <xsl:text> *pThis, PRUint32 *reserved);&#x0A;&#x0A;</xsl:text>
+      </xsl:for-each>
+    </xsl:if>
+    <!-- methods -->
+    <xsl:apply-templates select="method | if/method"/>
+    <xsl:variable name="reservedMethods" select="@reservedMethods"/>
+    <xsl:if test="$reservedMethods > 0">
+      <!-- tricky way to do a "for" loop without recursion -->
+      <xsl:for-each select="(//*)[position() &lt;= $reservedMethods]">
+        <xsl:text>    nsresult (*InternalAndReservedMethod</xsl:text>
+        <xsl:value-of select="concat(position(), $name)"/>
+        <xsl:text>)(</xsl:text>
+        <xsl:value-of select="$name"/>
+        <xsl:text> *pThis);&#x0A;&#x0A;</xsl:text>
+      </xsl:for-each>
+    </xsl:if>
+    <!-- -->
+    <xsl:text>};&#x0A;</xsl:text>
+    <xsl:text>#else /* VBOX_WITH_GLUE */&#x0A;</xsl:text>
+    <xsl:text>struct </xsl:text>
+    <xsl:value-of select="$name"/>
+    <xsl:text>Vtbl&#x0A;{&#x0A;</xsl:text>
+    <xsl:apply-templates select="." mode="vtab_flat">
+      <xsl:with-param name="iface" select="$name"/>
+    </xsl:apply-templates>
+    <xsl:text>};&#x0A;</xsl:text>
+    <xsl:apply-templates select="." mode="cobjmacro">
+      <xsl:with-param name="iface" select="$name"/>
+    </xsl:apply-templates>
+    <!-- -->
+    <xsl:text>#endif /* VBOX_WITH_GLUE */&#x0A;</xsl:text>
+    <xsl:text>&#x0A;</xsl:text>
+    <xsl:text>interface </xsl:text>
+    <xsl:value-of select="$name"/>
+    <xsl:text>&#x0A;{&#x0A;</xsl:text>
+    <xsl:text>#ifndef VBOX_WITH_GLUE&#x0A;</xsl:text>
+    <xsl:text>    struct </xsl:text>
+    <xsl:value-of select="$name"/>
+    <xsl:text>_vtbl *vtbl;&#x0A;</xsl:text>
+    <xsl:text>#else /* VBOX_WITH_GLUE */&#x0A;</xsl:text>
+    <xsl:text>    CONST_VTBL struct </xsl:text>
+    <xsl:value-of select="$name"/>
+    <xsl:text>Vtbl *lpVtbl;&#x0A;</xsl:text>
+    <xsl:text>#endif /* VBOX_WITH_GLUE */&#x0A;</xsl:text>
+    <xsl:text>};&#x0A;</xsl:text>
+    <xsl:text>/* End of struct </xsl:text>
+    <xsl:value-of select="$name"/>
+    <xsl:text> declaration */&#x0A;&#x0A;</xsl:text>
+    <xsl:call-template name="xsltprocNewlineOutputHack"/>
+  </xsl:if>
+</xsl:template>
+
+
+<!--
+ *  attributes
+-->
+<xsl:template match="attribute">
+  <xsl:param name="iface" select="ancestor::interface/@name"/>
+
+  <xsl:choose>
+    <!-- safearray pseudo attribute -->
+    <xsl:when test="@safearray='yes'">
+      <!-- getter -->
+      <xsl:text>    nsresult (*Get</xsl:text>
+      <xsl:call-template name="capitalize">
+        <xsl:with-param name="str" select="@name"/>
+      </xsl:call-template>
+      <xsl:text>)(</xsl:text>
+      <xsl:value-of select="$iface" />
+      <xsl:text> *pThis, </xsl:text>
+      <!-- array size -->
+      <xsl:text>PRUint32 *</xsl:text>
+      <xsl:value-of select="@name"/>
+      <xsl:text>Size, </xsl:text>
+      <!-- array pointer -->
+      <xsl:apply-templates select="@type" mode="forwarder"/>
+      <xsl:text> **</xsl:text>
+      <xsl:value-of select="@name"/>
+      <xsl:text>);&#x0A;</xsl:text>
+      <!-- setter -->
+      <xsl:if test="not(@readonly='yes')">
+        <xsl:text>    nsresult (*Set</xsl:text>
+        <xsl:call-template name="capitalize">
+          <xsl:with-param name="str" select="@name"/>
+        </xsl:call-template>
+        <xsl:text>)(</xsl:text>
+        <xsl:value-of select="$iface" />
+        <xsl:text> *pThis, </xsl:text>
+        <!-- array size -->
+        <xsl:text>PRUint32 </xsl:text>
+        <xsl:value-of select="@name"/>
+        <xsl:text>Size, </xsl:text>
+        <!-- array pointer -->
+        <xsl:apply-templates select="@type" mode="forwarder"/>
+        <xsl:text> *</xsl:text>
+        <xsl:value-of select="@name"/>
+        <xsl:text>);&#x0A;</xsl:text>
+      </xsl:if>
+    </xsl:when>
+    <!-- normal attribute -->
+    <xsl:otherwise>
+      <xsl:text>    </xsl:text>
+      <xsl:if test="@readonly='yes'">
+        <xsl:text>nsresult (*Get</xsl:text>
+        <xsl:call-template name="capitalize">
+          <xsl:with-param name="str" select="@name"/>
+        </xsl:call-template>
+        <xsl:text>)(</xsl:text>
+        <xsl:value-of select="$iface" />
+        <xsl:text> *pThis, </xsl:text>
+        <xsl:apply-templates select="@type" mode="forwarder"/>
+        <xsl:text> *</xsl:text>
+        <xsl:value-of select="@name"/>
+        <xsl:text>);&#x0A;</xsl:text>
+      </xsl:if>
+      <xsl:choose>
+        <xsl:when test="@readonly='yes'">
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:text>nsresult (*Get</xsl:text>
+          <xsl:call-template name="capitalize">
+            <xsl:with-param name="str" select="@name"/>
+          </xsl:call-template>
+          <xsl:text>)(</xsl:text>
+          <xsl:value-of select="$iface" />
+          <xsl:text> *pThis, </xsl:text>
+          <xsl:apply-templates select="@type" mode="forwarder"/>
+          <xsl:text> *</xsl:text>
+          <xsl:value-of select="@name"/>
+          <xsl:text>);&#x0A;    </xsl:text>
+          <xsl:text>nsresult (*Set</xsl:text>
+          <xsl:call-template name="capitalize">
+            <xsl:with-param name="str" select="@name"/>
+          </xsl:call-template>
+          <xsl:text>)(</xsl:text>
+          <xsl:value-of select="$iface" />
+          <xsl:text> *pThis, </xsl:text>
+          <xsl:apply-templates select="@type" mode="forwarder"/>
+          <xsl:text> </xsl:text>
+          <xsl:value-of select="@name"/>
+          <xsl:text>);&#x0A;</xsl:text>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:otherwise>
+  </xsl:choose>
+  <xsl:text>&#x0A;</xsl:text>
+</xsl:template>
+
+<xsl:template match="attribute" mode="cobjmacro">
+  <xsl:param name="iface"/>
+
+  <!-- getter (COM compatible) -->
+  <xsl:text>#define </xsl:text>
+  <xsl:value-of select="concat($iface, '_get_')"/>
+  <xsl:call-template name="capitalize">
+    <xsl:with-param name="str" select="@name"/>
+  </xsl:call-template>
+  <xsl:text>(p, a</xsl:text>
+  <xsl:call-template name="capitalize">
+    <xsl:with-param name="str" select="@name"/>
+  </xsl:call-template>
+  <xsl:text>) ((p)->lpVtbl->Get</xsl:text>
+  <xsl:call-template name="capitalize">
+    <xsl:with-param name="str" select="@name"/>
+  </xsl:call-template>
+  <xsl:text>(p, a</xsl:text>
+  <xsl:call-template name="capitalize">
+    <xsl:with-param name="str" select="@name"/>
+  </xsl:call-template>
+  <xsl:text>))&#x0A;</xsl:text>
+
+  <!-- getter (XPCOM compatible) -->
+  <xsl:text>#define </xsl:text>
+  <xsl:value-of select="concat($iface, '_Get')"/>
+  <xsl:call-template name="capitalize">
+    <xsl:with-param name="str" select="@name"/>
+  </xsl:call-template>
+  <xsl:text>(p, a</xsl:text>
+  <xsl:call-template name="capitalize">
+    <xsl:with-param name="str" select="@name"/>
+  </xsl:call-template>
+  <xsl:text>) ((p)->lpVtbl->Get</xsl:text>
+  <xsl:call-template name="capitalize">
+    <xsl:with-param name="str" select="@name"/>
+  </xsl:call-template>
+  <xsl:text>(p, a</xsl:text>
+  <xsl:call-template name="capitalize">
+    <xsl:with-param name="str" select="@name"/>
+  </xsl:call-template>
+  <xsl:text>))&#x0A;</xsl:text>
+
+  <xsl:if test="not(@readonly='yes')">
+    <!-- setter (COM compatible) -->
+    <xsl:text>#define </xsl:text>
+    <xsl:value-of select="concat($iface, '_put_')"/>
+    <xsl:call-template name="capitalize">
+      <xsl:with-param name="str" select="@name"/>
+    </xsl:call-template>
+    <xsl:text>(p, a</xsl:text>
+    <xsl:call-template name="capitalize">
+      <xsl:with-param name="str" select="@name"/>
+    </xsl:call-template>
+    <xsl:text>) ((p)->lpVtbl->Set</xsl:text>
+    <xsl:call-template name="capitalize">
+      <xsl:with-param name="str" select="@name"/>
+    </xsl:call-template>
+    <xsl:text>(p, a</xsl:text>
+    <xsl:call-template name="capitalize">
+      <xsl:with-param name="str" select="@name"/>
+    </xsl:call-template>
+    <xsl:text>))&#x0A;</xsl:text>
+
+    <!-- setter (XPCOM compatible) -->
+    <xsl:text>#define </xsl:text>
+    <xsl:value-of select="concat($iface, '_Set')"/>
+    <xsl:call-template name="capitalize">
+      <xsl:with-param name="str" select="@name"/>
+    </xsl:call-template>
+    <xsl:text>(p, a</xsl:text>
+    <xsl:call-template name="capitalize">
+      <xsl:with-param name="str" select="@name"/>
+    </xsl:call-template>
+    <xsl:text>) ((p)->lpVtbl->Set</xsl:text>
+    <xsl:call-template name="capitalize">
+      <xsl:with-param name="str" select="@name"/>
+    </xsl:call-template>
+    <xsl:text>(p, a</xsl:text>
+    <xsl:call-template name="capitalize">
+      <xsl:with-param name="str" select="@name"/>
+    </xsl:call-template>
+    <xsl:text>))&#x0A;</xsl:text>
+
+  </xsl:if>
+</xsl:template>
+
+<!--
+ *  methods
+-->
+<xsl:template match="method">
+  <xsl:param name="iface" select="ancestor::interface/@name"/>
+
+  <xsl:if test="param/@mod='ptr'">
+    <!-- methods using native types must be non-scriptable
+    <xsl:text>    [noscript]&#x0A;</xsl:text>-->
+  </xsl:if>
+  <xsl:text>    nsresult (*</xsl:text>
+  <xsl:call-template name="capitalize">
+    <xsl:with-param name="str" select="@name"/>
+  </xsl:call-template>
+  <xsl:if test="param">
+    <xsl:text>)(&#x0A;</xsl:text>
+    <xsl:text>        </xsl:text>
+    <xsl:value-of select="$iface" />
+    <xsl:text> *pThis,&#x0A;</xsl:text>
+    <xsl:for-each select="param [position() != last()]">
+      <xsl:text>        </xsl:text>
+      <xsl:apply-templates select="."/>
+      <xsl:text>,&#x0A;</xsl:text>
+    </xsl:for-each>
+    <xsl:text>        </xsl:text>
+    <xsl:apply-templates select="param [last()]"/>
+    <xsl:text>&#x0A;    );&#x0A;</xsl:text>
+  </xsl:if>
+  <xsl:if test="not(param)">
+    <xsl:text>)(</xsl:text>
+    <xsl:value-of select="$iface" />
+    <xsl:text> *pThis );&#x0A;</xsl:text>
+  </xsl:if>
+  <xsl:text>&#x0A;</xsl:text>
+</xsl:template>
+
+<xsl:template match="method" mode="cobjmacro">
+  <xsl:param name="iface"/>
+
+  <xsl:text>#define </xsl:text>
+  <xsl:value-of select="concat($iface, '_')"/>
+  <xsl:call-template name="capitalize">
+    <xsl:with-param name="str" select="@name"/>
+  </xsl:call-template>
+  <xsl:text>(p</xsl:text>
+  <xsl:for-each select="param">
+    <xsl:text>, a</xsl:text>
+    <xsl:call-template name="capitalize">
+      <xsl:with-param name="str" select="@name"/>
+    </xsl:call-template>
+  </xsl:for-each>
+  <xsl:text>) ((p)->lpVtbl-></xsl:text>
+  <xsl:call-template name="capitalize">
+    <xsl:with-param name="str" select="@name"/>
+  </xsl:call-template>
+  <xsl:text>(p</xsl:text>
+  <xsl:for-each select="param">
+    <xsl:text>, a</xsl:text>
+    <xsl:call-template name="capitalize">
+      <xsl:with-param name="str" select="@name"/>
+    </xsl:call-template>
+  </xsl:for-each>
+  <xsl:text>))&#x0A;</xsl:text>
+</xsl:template>
+
+
+<!--
+ *  modules
+-->
+<xsl:template match="module">
+  <xsl:apply-templates select="class"/>
+</xsl:template>
+
+
+<!--
+ *  co-classes
+-->
+<xsl:template match="module/class">
+  <!-- class and contract id -->
+  <xsl:text>&#x0A;</xsl:text>
+  <xsl:text>#define NS_</xsl:text>
+  <xsl:call-template name="string-to-upper">
+    <xsl:with-param name="str" select="@name"/>
+  </xsl:call-template>
+  <xsl:text>_CID { \&#x0A;</xsl:text>
+  <xsl:text>    0x</xsl:text><xsl:value-of select="substring(@uuid,1,8)"/>
+  <xsl:text>, 0x</xsl:text><xsl:value-of select="substring(@uuid,10,4)"/>
+  <xsl:text>, 0x</xsl:text><xsl:value-of select="substring(@uuid,15,4)"/>
+  <xsl:text>, \&#x0A;    </xsl:text>
+  <xsl:text>{ 0x</xsl:text><xsl:value-of select="substring(@uuid,20,2)"/>
+  <xsl:text>, 0x</xsl:text><xsl:value-of select="substring(@uuid,22,2)"/>
+  <xsl:text>, 0x</xsl:text><xsl:value-of select="substring(@uuid,25,2)"/>
+  <xsl:text>, 0x</xsl:text><xsl:value-of select="substring(@uuid,27,2)"/>
+  <xsl:text>, 0x</xsl:text><xsl:value-of select="substring(@uuid,29,2)"/>
+  <xsl:text>, 0x</xsl:text><xsl:value-of select="substring(@uuid,31,2)"/>
+  <xsl:text>, 0x</xsl:text><xsl:value-of select="substring(@uuid,33,2)"/>
+  <xsl:text>, 0x</xsl:text><xsl:value-of select="substring(@uuid,35,2)"/>
+  <xsl:text> } \&#x0A;}&#x0A;</xsl:text>
+  <xsl:text>#define NS_</xsl:text>
+  <xsl:call-template name="string-to-upper">
+    <xsl:with-param name="str" select="@name"/>
+  </xsl:call-template>
+  <!-- Contract ID -->
+  <xsl:text>_CONTRACTID &quot;@</xsl:text>
+  <xsl:value-of select="@namespace"/>
+  <xsl:text>/</xsl:text>
+  <xsl:value-of select="@name"/>
+  <xsl:text>;1&quot;&#x0A;</xsl:text>
+  <!-- CLSID_xxx declarations for XPCOM, for compatibility with Win32 -->
+  <xsl:text>/* COM compatibility */&#x0A;</xsl:text>
+  <xsl:text>VBOX_EXTERN_CONST(nsCID, CLSID_</xsl:text>
+  <xsl:value-of select="@name"/>
+  <xsl:text>);&#x0A;</xsl:text>
+  <xsl:text>&#x0A;&#x0A;</xsl:text>
+</xsl:template>
+
+
+<!--
+ *  enums
+-->
+<xsl:template match="enum">
+  <xsl:text>/* Start of enum </xsl:text>
+  <xsl:value-of select="@name"/>
+  <xsl:text> declaration */&#x0A;</xsl:text>
+  <xsl:text>#define </xsl:text>
+  <xsl:call-template name="string-to-upper">
+    <xsl:with-param name="str" select="@name"/>
+  </xsl:call-template>
+  <xsl:value-of select="concat('_IID_STR &quot;',@uuid,'&quot;')"/>
+  <xsl:text>&#x0A;</xsl:text>
+  <xsl:text>#define </xsl:text>
+  <xsl:call-template name="string-to-upper">
+    <xsl:with-param name="str" select="@name"/>
+  </xsl:call-template>
+  <xsl:text>_IID { \&#x0A;</xsl:text>
+  <xsl:text>    0x</xsl:text><xsl:value-of select="substring(@uuid,1,8)"/>
+  <xsl:text>, 0x</xsl:text><xsl:value-of select="substring(@uuid,10,4)"/>
+  <xsl:text>, 0x</xsl:text><xsl:value-of select="substring(@uuid,15,4)"/>
+  <xsl:text>, \&#x0A;    </xsl:text>
+  <xsl:text>{ 0x</xsl:text><xsl:value-of select="substring(@uuid,20,2)"/>
+  <xsl:text>, 0x</xsl:text><xsl:value-of select="substring(@uuid,22,2)"/>
+  <xsl:text>, 0x</xsl:text><xsl:value-of select="substring(@uuid,25,2)"/>
+  <xsl:text>, 0x</xsl:text><xsl:value-of select="substring(@uuid,27,2)"/>
+  <xsl:text>, 0x</xsl:text><xsl:value-of select="substring(@uuid,29,2)"/>
+  <xsl:text>, 0x</xsl:text><xsl:value-of select="substring(@uuid,31,2)"/>
+  <xsl:text>, 0x</xsl:text><xsl:value-of select="substring(@uuid,33,2)"/>
+  <xsl:text>, 0x</xsl:text><xsl:value-of select="substring(@uuid,35,2)"/>
+  <xsl:text> } \&#x0A;}&#x0A;</xsl:text>
+  <xsl:text>typedef enum </xsl:text>
+  <xsl:value-of select="@name"/>
+  <xsl:text>&#x0A;{&#x0A;</xsl:text>
+  <xsl:variable name="this" select="."/>
+  <xsl:for-each select="const">
+    <xsl:text>    </xsl:text>
+    <xsl:value-of select="$this/@name"/>
+    <xsl:text>_</xsl:text>
+    <xsl:value-of select="@name"/> = <xsl:value-of select="@value"/>
+    <xsl:if test="position() != last()">
+      <xsl:text>,</xsl:text>
+    </xsl:if>
+    <xsl:text>&#x0A;</xsl:text>
+  </xsl:for-each>
+  <xsl:text>} </xsl:text>
+  <xsl:value-of select="@name"/>
+  <xsl:text>;&#x0A;</xsl:text>
+  <xsl:text>/* End of enum </xsl:text>
+  <xsl:value-of select="@name"/>
+  <xsl:text> declaration */
+#define </xsl:text>
+  <xsl:value-of select="concat(@name, '_T PRUint32&#x0A;&#x0A;&#x0A;')"/>
+</xsl:template>
+
+
+<!--
+ *  method parameters
+-->
+<xsl:template match="method/param">
+  <xsl:choose>
+    <!-- safearray parameters -->
+    <xsl:when test="@safearray='yes'">
+      <!-- array size -->
+      <xsl:choose>
+        <xsl:when test="@dir='in'">
+          <xsl:text>PRUint32 </xsl:text>
+          <xsl:value-of select="@name"/>
+          <xsl:text>Size,&#x0A;</xsl:text>
+        </xsl:when>
+        <xsl:when test="@dir='out'">
+          <xsl:text>PRUint32 *</xsl:text>
+          <xsl:value-of select="@name"/>
+          <xsl:text>Size,&#x0A;</xsl:text>
+        </xsl:when>
+        <xsl:when test="@dir='return'">
+          <xsl:text>PRUint32 *</xsl:text>
+          <xsl:value-of select="@name"/>
+          <xsl:text>Size,&#x0A;</xsl:text>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:text>PRUint32 </xsl:text>
+          <xsl:value-of select="@name"/>
+          <xsl:text>Size,&#x0A;</xsl:text>
+        </xsl:otherwise>
+      </xsl:choose>
+      <!-- array pointer -->
+      <xsl:text>        </xsl:text>
+      <xsl:choose>
+        <xsl:when test="@dir='in'">
+          <xsl:apply-templates select="@type" mode="forwarder"/>
+          <xsl:text>*</xsl:text>
+        </xsl:when>
+        <xsl:when test="@dir='out'">
+          <xsl:apply-templates select="@type" mode="forwarder"/>
+          <xsl:text>**</xsl:text>
+        </xsl:when>
+        <xsl:when test="@dir='return'">
+          <xsl:apply-templates select="@type" mode="forwarder"/>
+          <xsl:text>**</xsl:text>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:apply-templates select="@type" mode="forwarder"/>
+          <xsl:text>*</xsl:text>
+        </xsl:otherwise>
+      </xsl:choose>
+      <xsl:text> </xsl:text>
+      <xsl:value-of select="@name"/>
+    </xsl:when>
+    <!-- normal and array parameters -->
+    <xsl:otherwise>
+      <xsl:choose>
+        <xsl:when test="@dir='in'">
+          <xsl:apply-templates select="@type" mode="forwarder"/>
+          <xsl:text></xsl:text>
+        </xsl:when>
+        <xsl:when test="@dir='out'">
+          <xsl:apply-templates select="@type" mode="forwarder"/>
+          <xsl:text> *</xsl:text>
+        </xsl:when>
+        <xsl:when test="@dir='return'">
+          <xsl:apply-templates select="@type" mode="forwarder"/>
+          <xsl:text> *</xsl:text>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:apply-templates select="@type" mode="forwarder"/>
+          <xsl:text></xsl:text>
+        </xsl:otherwise>
+      </xsl:choose>
+      <xsl:text> </xsl:text>
+      <xsl:value-of select="@name"/>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match="method/param" mode="forwarder">
+  <xsl:if test="@safearray='yes'">
+    <xsl:text>PRUint32</xsl:text>
+    <xsl:if test="@dir='out' or @dir='return'">
+      <xsl:text> *</xsl:text>
+    </xsl:if>
+    <xsl:text> a</xsl:text>
+    <xsl:call-template name="capitalize">
+      <xsl:with-param name="str" select="@name"/>
+    </xsl:call-template>
+    <xsl:text>Size, </xsl:text>
+  </xsl:if>
+  <xsl:apply-templates select="@type" mode="forwarder"/>
+  <xsl:if test="@dir='out' or @dir='return'">
+    <xsl:text> *</xsl:text>
+  </xsl:if>
+  <xsl:if test="@safearray='yes'">
+    <xsl:text> *</xsl:text>
+  </xsl:if>
+  <xsl:text> a</xsl:text>
+  <xsl:call-template name="capitalize">
+    <xsl:with-param name="str" select="@name"/>
+  </xsl:call-template>
+</xsl:template>
+
+
+<!--
+ *  attribute/parameter type conversion
+-->
+<xsl:template match="attribute/@type | param/@type">
+  <xsl:variable name="self_target" select="current()/ancestor::if/@target"/>
+
+  <xsl:choose>
+    <!-- modifiers -->
+    <xsl:when test="name(current())='type' and ../@mod">
+      <xsl:choose>
+        <xsl:when test="../@mod='ptr'">
+          <xsl:choose>
+            <!-- standard types -->
+            <!--xsl:when test=".='result'">??</xsl:when-->
+            <xsl:when test=".='boolean'">booleanPtr</xsl:when>
+            <xsl:when test=".='octet'">octetPtr</xsl:when>
+            <xsl:when test=".='short'">shortPtr</xsl:when>
+            <xsl:when test=".='unsigned short'">ushortPtr</xsl:when>
+            <xsl:when test=".='long'">longPtr</xsl:when>
+            <xsl:when test=".='long long'">llongPtr</xsl:when>
+            <xsl:when test=".='unsigned long'">ulongPtr</xsl:when>
+            <xsl:when test=".='unsigned long long'">ullongPtr</xsl:when>
+            <xsl:otherwise>
+              <xsl:message terminate="yes">
+                <xsl:value-of select="concat(../../../@name,'::',../../@name,'::',../@name,': ')"/>
+                <xsl:text>attribute 'mod=</xsl:text>
+                <xsl:value-of select="concat('&quot;',../@mod,'&quot;')"/>
+                <xsl:text>' cannot be used with type </xsl:text>
+                <xsl:value-of select="concat('&quot;',current(),'&quot;!')"/>
+              </xsl:message>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:when>
+        <xsl:when test="../@mod='string'">
+          <xsl:choose>
+            <!-- standard types -->
+            <!--xsl:when test=".='result'">??</xsl:when-->
+            <xsl:when test=".='uuid'">wstring</xsl:when>
+            <xsl:otherwise>
+              <xsl:message terminate="yes">
+                <xsl:value-of select="concat(../../../@name,'::',../../@name,'::',../@name,': ')"/>
+                <xsl:text>attribute 'mod=</xsl:text>
+                <xsl:value-of select="concat('&quot;',../@mod,'&quot;')"/>
+                <xsl:text>' cannot be used with type </xsl:text>
+                <xsl:value-of select="concat('&quot;',current(),'&quot;!')"/>
+              </xsl:message>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:when>
+        <xsl:otherwise>
+          <xsl:message terminate="yes">
+            <xsl:value-of select="concat(../../../@name,'::',../../@name,'::',../@name,': ')"/>
+            <xsl:value-of select="concat('value &quot;',../@mod,'&quot; ')"/>
+            <xsl:text>of attribute 'mod' is invalid!</xsl:text>
+          </xsl:message>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:when>
+    <!-- no modifiers -->
+    <xsl:otherwise>
+      <xsl:choose>
+        <!-- standard types -->
+        <xsl:when test=".='result'">nsresult</xsl:when>
+        <xsl:when test=".='boolean'">boolean</xsl:when>
+        <xsl:when test=".='octet'">octet</xsl:when>
+        <xsl:when test=".='short'">short</xsl:when>
+        <xsl:when test=".='unsigned short'">unsigned short</xsl:when>
+        <xsl:when test=".='long'">long</xsl:when>
+        <xsl:when test=".='long long'">long long</xsl:when>
+        <xsl:when test=".='unsigned long'">unsigned long</xsl:when>
+        <xsl:when test=".='unsigned long long'">unsigned long long</xsl:when>
+        <xsl:when test=".='char'">char</xsl:when>
+        <xsl:when test=".='wchar'">wchar</xsl:when>
+        <xsl:when test=".='string'">string</xsl:when>
+        <xsl:when test=".='wstring'">wstring</xsl:when>
+        <!-- UUID type -->
+        <xsl:when test=".='uuid'">
+          <xsl:choose>
+            <xsl:when test="name(..)='attribute'">
+              <xsl:choose>
+                <xsl:when test="../@readonly='yes'">
+                  <xsl:text>nsIDPtr</xsl:text>
+                </xsl:when>
+                <xsl:otherwise>
+                  <xsl:message terminate="yes">
+                    <xsl:value-of select="../@name"/>
+                    <xsl:text>: Non-readonly uuid attributes are not supported!</xsl:text>
+                  </xsl:message>
+                </xsl:otherwise>
+              </xsl:choose>
+            </xsl:when>
+            <xsl:when test="name(..)='param'">
+              <xsl:choose>
+                <xsl:when test="../@dir='in' and not(../@safearray='yes')">
+                  <xsl:text>nsIDRef</xsl:text>
+                </xsl:when>
+                <xsl:otherwise>
+                  <xsl:text>nsIDPtr</xsl:text>
+                </xsl:otherwise>
+              </xsl:choose>
+            </xsl:when>
+          </xsl:choose>
+        </xsl:when>
+        <!-- system interface types -->
+        <xsl:when test=".='$unknown'">nsISupports</xsl:when>
+        <xsl:otherwise>
+          <xsl:choose>
+            <!-- enum types -->
+            <xsl:when test="
+              (ancestor::library/application/enum[@name=current()]) or
+              (ancestor::library/application/if[@target=$self_target]/enum[@name=current()])
+            ">
+              <xsl:text>PRUint32</xsl:text>
+            </xsl:when>
+            <!-- custom interface types -->
+            <xsl:when test="
+              (ancestor::library/application/interface[@name=current()]) or
+              (ancestor::library/application/if[@target=$self_target]/interface[@name=current()])
+            ">
+              <xsl:value-of select="."/>
+            </xsl:when>
+            <!-- other types -->
+            <xsl:otherwise>
+              <xsl:message terminate="yes">
+                <xsl:text>Unknown parameter type: </xsl:text>
+                <xsl:value-of select="."/>
+              </xsl:message>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+<xsl:template match="attribute/@type | param/@type" mode="forwarder">
+
+  <xsl:variable name="self_target" select="current()/ancestor::if/@target"/>
+
+  <xsl:choose>
+    <!-- modifiers -->
+    <xsl:when test="name(current())='type' and ../@mod">
+      <xsl:choose>
+        <xsl:when test="../@mod='ptr'">
+          <xsl:choose>
+            <!-- standard types -->
+            <!--xsl:when test=".='result'">??</xsl:when-->
+            <xsl:when test=".='boolean'">PRBool *</xsl:when>
+            <xsl:when test=".='octet'">PRUint8 *</xsl:when>
+            <xsl:when test=".='short'">PRInt16 *</xsl:when>
+            <xsl:when test=".='unsigned short'">PRUint16 *</xsl:when>
+            <xsl:when test=".='long'">PRInt32 *</xsl:when>
+            <xsl:when test=".='long long'">PRInt64 *</xsl:when>
+            <xsl:when test=".='unsigned long'">PRUint32 *</xsl:when>
+            <xsl:when test=".='unsigned long long'">PRUint64 *</xsl:when>
+            <xsl:otherwise>
+              <xsl:message terminate="yes">
+                <xsl:value-of select="concat(../../../@name,'::',../../@name,'::',../@name,': ')"/>
+                <xsl:text>attribute 'mod=</xsl:text>
+                <xsl:value-of select="concat('&quot;',../@mod,'&quot;')"/>
+                <xsl:text>' cannot be used with type </xsl:text>
+                <xsl:value-of select="concat('&quot;',current(),'&quot;!')"/>
+              </xsl:message>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:when>
+        <xsl:when test="../@mod='string'">
+          <xsl:choose>
+            <!-- standard types -->
+            <!--xsl:when test=".='result'">??</xsl:when-->
+            <xsl:when test=".='uuid'">PRUnichar *</xsl:when>
+            <xsl:otherwise>
+              <xsl:message terminate="yes">
+                <xsl:value-of select="concat(../../../@name,'::',../../@name,'::',../@name,': ')"/>
+                <xsl:text>attribute 'mod=</xsl:text>
+                <xsl:value-of select="concat('&quot;',../@mod,'&quot;')"/>
+                <xsl:text>' cannot be used with type </xsl:text>
+                <xsl:value-of select="concat('&quot;',current(),'&quot;!')"/>
+              </xsl:message>
+            </xsl:otherwise>
+          </xsl:choose>
+        </xsl:when>
+      </xsl:choose>
+    </xsl:when>
+    <!-- no modifiers -->
+    <xsl:otherwise>
+      <xsl:choose>
+        <!-- standard types -->
+        <xsl:when test=".='result'">nsresult</xsl:when>
+        <xsl:when test=".='boolean'">PRBool</xsl:when>
+        <xsl:when test=".='octet'">PRUint8</xsl:when>
+        <xsl:when test=".='short'">PRInt16</xsl:when>
+        <xsl:when test=".='unsigned short'">PRUint16</xsl:when>
+        <xsl:when test=".='long'">PRInt32</xsl:when>
+        <xsl:when test=".='long long'">PRInt64</xsl:when>
+        <xsl:when test=".='unsigned long'">PRUint32</xsl:when>
+        <xsl:when test=".='unsigned long long'">PRUint64</xsl:when>
+        <xsl:when test=".='char'">char</xsl:when>
+        <xsl:when test=".='wchar'">PRUnichar</xsl:when>
+        <!-- string types -->
+        <xsl:when test=".='string'">char *</xsl:when>
+        <xsl:when test=".='wstring'">PRUnichar *</xsl:when>
+        <!-- UUID type -->
+        <xsl:when test=".='uuid'">
+          <xsl:choose>
+            <xsl:when test="name(..)='attribute'">
+              <xsl:choose>
+                <xsl:when test="../@readonly='yes'">
+                  <xsl:text>nsID *</xsl:text>
+                </xsl:when>
+              </xsl:choose>
+            </xsl:when>
+            <xsl:when test="name(..)='param'">
+              <xsl:choose>
+                <xsl:when test="../@dir='in' and not(../@safearray='yes')">
+                  <xsl:text>const nsID *</xsl:text>
+                </xsl:when>
+                <xsl:otherwise>
+                  <xsl:text>nsID *</xsl:text>
+                </xsl:otherwise>
+              </xsl:choose>
+            </xsl:when>
+          </xsl:choose>
+        </xsl:when>
+        <!-- system interface types -->
+        <xsl:when test=".='$unknown'">nsISupports *</xsl:when>
+        <xsl:otherwise>
+          <xsl:choose>
+            <!-- enum types -->
+            <xsl:when test="
+              (ancestor::library/application/enum[@name=current()]) or
+              (ancestor::library/application/if[@target=$self_target]/enum[@name=current()])
+            ">
+              <xsl:text>PRUint32</xsl:text>
+            </xsl:when>
+            <!-- custom interface types -->
+            <xsl:when test="
+              (ancestor::library/application/interface[@name=current()]) or
+              (ancestor::library/application/if[@target=$self_target]/interface[@name=current()])
+            ">
+              <xsl:value-of select="."/>
+              <xsl:text> *</xsl:text>
+            </xsl:when>
+            <!-- other types -->
+          </xsl:choose>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+
+<xsl:template match="application[@uuid='ec0e78e8-fa43-43e8-ac0a-02c784c4a4fa']//module/class" />
+
+<xsl:template match="application[@uuid='ec0e78e8-fa43-43e8-ac0a-02c784c4a4fa']/if//interface
+| application[@uuid='ec0e78e8-fa43-43e8-ac0a-02c784c4a4fa']//interface" />
+
+<xsl:template match="application[@uuid='ec0e78e8-fa43-43e8-ac0a-02c784c4a4fa']//interface" mode="forward" />
+
+
+</xsl:stylesheet>
diff --git a/src/VBox/Main/cbinding/makefile.tstCAPIGlue b/src/VBox/Main/cbinding/makefile.tstCAPIGlue
new file mode 100644
index 00000000..53975964
--- /dev/null
+++ b/src/VBox/Main/cbinding/makefile.tstCAPIGlue
@@ -0,0 +1,63 @@
+# $Id: makefile.tstCAPIGlue $
+## @file makefile.tstCAPIGlue
+# Makefile for sample program illustrating use of C binding for COM/XPCOM.
+#
+
+#
+# Copyright (C) 2009-2023 Oracle and/or its affiliates.
+#
+# Permission is hereby granted, free of charge, to any person
+# obtaining a copy of this software and associated documentation
+# files (the "Software"), to deal in the Software without
+# restriction, including without limitation the rights to use,
+# copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following
+# conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+# OTHER DEALINGS IN THE SOFTWARE.
+#
+
+PATH_SDK      = ../../..
+CAPI_INC      = -I$(PATH_SDK)/bindings/c/include
+ifdef ProgramFiles
+PLATFORM_INC  = -I$(PATH_SDK)/bindings/mscom/include
+PLATFORM_LIB  = $(PATH_SDK)/bindings/mscom/lib
+else
+PLATFORM_INC  = -I$(PATH_SDK)/bindings/xpcom/include
+PLATFORM_LIB  = $(PATH_SDK)/bindings/xpcom/lib
+endif
+GLUE_DIR      = $(PATH_SDK)/bindings/c/glue
+GLUE_INC      = -I$(GLUE_DIR)
+
+CC            = gcc
+CFLAGS        = -g -Wall
+
+.PHONY: all
+all: tstCAPIGlue
+
+.PHONY: clean
+clean:
+	rm -f tstCAPIGlue.o VBoxCAPIGlue.o VirtualBox_i.o tstCAPIGlue
+
+tstCAPIGlue: tstCAPIGlue.o VBoxCAPIGlue.o VirtualBox_i.o
+	$(CC) -o $@ $^ -ldl -lpthread
+
+tstCAPIGlue.o: tstCAPIGlue.c
+	$(CC) $(CFLAGS) $(CAPI_INC) $(PLATFORM_INC) $(GLUE_INC) -o $@ -c $<
+
+VBoxCAPIGlue.o: $(GLUE_DIR)/VBoxCAPIGlue.c
+	$(CC) $(CFLAGS) $(CAPI_INC) $(PLATFORM_INC) $(GLUE_INC) -o $@ -c $<
+
+VirtualBox_i.o: $(PLATFORM_LIB)/VirtualBox_i.c
+	$(CC) $(CFLAGS) $(CAPI_INC) $(PLATFORM_INC) $(GLUE_INC) -o $@ -c $<
diff --git a/src/VBox/Main/cbinding/tstCAPIGlue.c b/src/VBox/Main/cbinding/tstCAPIGlue.c
new file mode 100644
index 00000000..d78a8085
--- /dev/null
+++ b/src/VBox/Main/cbinding/tstCAPIGlue.c
@@ -0,0 +1,1145 @@
+/* $Id: tstCAPIGlue.c $ */
+/** @file tstCAPIGlue.c
+ * Demonstrator program to illustrate use of C bindings of Main API.
+ *
+ * It has sample code showing how to retrieve all available error information,
+ * and how to handle active (event delivery through callbacks) or passive
+ * (event delivery through a polling mechanism) event listeners.
+ */
+
+/*
+ * Copyright (C) 2009-2023 Oracle and/or its affiliates.
+ *
+ * This file is part of VirtualBox base platform packages, as
+ * available from https://www.virtualbox.org.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, in version 3 of the
+ * License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <https://www.gnu.org/licenses>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-only
+ */
+
+
+/** @todo
+ * Our appologies for the 256+ missing return code checks in this sample file.
+ *
+ * We strongly recomment users of the VBoxCAPI to check all return codes!
+ */
+
+
+/*********************************************************************************************************************************
+*   Header Files                                                                                                                 *
+*********************************************************************************************************************************/
+#include "VBoxCAPIGlue.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#ifndef WIN32
+# include <signal.h>
+# include <unistd.h>
+# include <sys/poll.h>
+#endif
+#ifdef IPRT_INCLUDED_cdefs_h
+# error "not supposed to involve any IPRT or VBox headers here."
+#endif
+
+/**
+ * Select between active event listener (defined) and passive event listener
+ * (undefined). The active event listener case needs much more code, and
+ * additionally requires a lot more platform dependent code.
+ */
+#undef USE_ACTIVE_EVENT_LISTENER
+
+
+/*********************************************************************************************************************************
+*   Global Variables                                                                                                             *
+*********************************************************************************************************************************/
+/** Set by Ctrl+C handler. */
+static volatile int g_fStop = 0;
+
+#ifdef USE_ACTIVE_EVENT_LISTENER
+# ifdef WIN32
+/** The COM type information for IEventListener, for implementing IDispatch. */
+static ITypeInfo *g_pTInfoIEventListener = NULL;
+# endif /* WIN32 */
+#endif /* USE_ACTIVE_EVENT_LISTENER */
+
+static const char *GetStateName(MachineState_T machineState)
+{
+    switch (machineState)
+    {
+        case MachineState_Null:                return "<null>";
+        case MachineState_PoweredOff:          return "PoweredOff";
+        case MachineState_Saved:               return "Saved";
+        case MachineState_Teleported:          return "Teleported";
+        case MachineState_Aborted:             return "Aborted";
+        case MachineState_AbortedSaved:        return "Aborted-Saved";
+        case MachineState_Running:             return "Running";
+        case MachineState_Paused:              return "Paused";
+        case MachineState_Stuck:               return "Stuck";
+        case MachineState_Teleporting:         return "Teleporting";
+        case MachineState_LiveSnapshotting:    return "LiveSnapshotting";
+        case MachineState_Starting:            return "Starting";
+        case MachineState_Stopping:            return "Stopping";
+        case MachineState_Saving:              return "Saving";
+        case MachineState_Restoring:           return "Restoring";
+        case MachineState_TeleportingPausedVM: return "TeleportingPausedVM";
+        case MachineState_TeleportingIn:       return "TeleportingIn";
+        case MachineState_DeletingSnapshotOnline: return "DeletingSnapshotOnline";
+        case MachineState_DeletingSnapshotPaused: return "DeletingSnapshotPaused";
+        case MachineState_RestoringSnapshot:   return "RestoringSnapshot";
+        case MachineState_DeletingSnapshot:    return "DeletingSnapshot";
+        case MachineState_SettingUp:           return "SettingUp";
+        default:                               return "no idea";
+    }
+}
+
+/**
+ * Ctrl+C handler, terminate event listener.
+ *
+ * Remember that most function calls are not allowed in this context (including
+ * printf!), so make sure that this does as little as possible.
+ *
+ * @param  iInfo    Platform dependent detail info (ignored).
+ */
+#ifdef WIN32
+static BOOL VBOX_WINAPI ctrlCHandler(DWORD iInfo)
+{
+    (void)iInfo;
+    g_fStop = 1;
+    return TRUE;
+}
+#else
+static void ctrlCHandler(int iInfo)
+{
+    (void)iInfo;
+    g_fStop = 1;
+}
+#endif
+
+/**
+ * Sample event processing function, dumping some event information.
+ * Shared between active and passive event demo, to highlight that this part
+ * is identical between the two.
+ */
+static HRESULT EventListenerDemoProcessEvent(IEvent *event)
+{
+    VBoxEventType_T evType;
+    HRESULT hrc;
+
+    if (!event)
+    {
+        printf("event null\n");
+        return S_OK;
+    }
+
+    evType = VBoxEventType_Invalid;
+    hrc = IEvent_get_Type(event, &evType);
+    if (FAILED(hrc))
+    {
+        printf("cannot get event type, hrc=%#x\n", (unsigned)hrc);
+        return S_OK;
+    }
+
+    switch (evType)
+    {
+        case VBoxEventType_OnMousePointerShapeChanged:
+            printf("OnMousePointerShapeChanged\n");
+            break;
+
+        case VBoxEventType_OnMouseCapabilityChanged:
+            printf("OnMouseCapabilityChanged\n");
+            break;
+
+        case VBoxEventType_OnKeyboardLedsChanged:
+            printf("OnMouseCapabilityChanged\n");
+            break;
+
+        case VBoxEventType_OnStateChanged:
+        {
+            IStateChangedEvent *ev = NULL;
+            enum MachineState state;
+            hrc = IEvent_QueryInterface(event, &IID_IStateChangedEvent, (void **)&ev);
+            if (FAILED(hrc))
+            {
+                printf("cannot get StateChangedEvent interface, hrc=%#x\n", (unsigned)hrc);
+                return S_OK;
+            }
+            if (!ev)
+            {
+                printf("StateChangedEvent reference null\n");
+                return S_OK;
+            }
+            hrc = IStateChangedEvent_get_State(ev, &state);
+            if (FAILED(hrc))
+                printf("warning: cannot get state, hrc=%#x\n", (unsigned)hrc);
+            IStateChangedEvent_Release(ev);
+            printf("OnStateChanged: %s\n", GetStateName(state));
+
+            fflush(stdout);
+            if (   state == MachineState_PoweredOff
+                || state == MachineState_Saved
+                || state == MachineState_Teleported
+                || state == MachineState_Aborted
+                || state == MachineState_AbortedSaved
+               )
+                g_fStop = 1;
+            break;
+        }
+
+        case VBoxEventType_OnAdditionsStateChanged:
+            printf("OnAdditionsStateChanged\n");
+            break;
+
+        case VBoxEventType_OnNetworkAdapterChanged:
+            printf("OnNetworkAdapterChanged\n");
+            break;
+
+        case VBoxEventType_OnSerialPortChanged:
+            printf("OnSerialPortChanged\n");
+            break;
+
+        case VBoxEventType_OnParallelPortChanged:
+            printf("OnParallelPortChanged\n");
+            break;
+
+        case VBoxEventType_OnStorageControllerChanged:
+            printf("OnStorageControllerChanged\n");
+            break;
+
+        case VBoxEventType_OnMediumChanged:
+            printf("OnMediumChanged\n");
+            break;
+
+        case VBoxEventType_OnVRDEServerChanged:
+            printf("OnVRDEServerChanged\n");
+            break;
+
+        case VBoxEventType_OnUSBControllerChanged:
+            printf("OnUSBControllerChanged\n");
+            break;
+
+        case VBoxEventType_OnUSBDeviceStateChanged:
+            printf("OnUSBDeviceStateChanged\n");
+            break;
+
+        case VBoxEventType_OnSharedFolderChanged:
+            printf("OnSharedFolderChanged\n");
+            break;
+
+        case VBoxEventType_OnRuntimeError:
+            printf("OnRuntimeError\n");
+            break;
+
+        case VBoxEventType_OnCanShowWindow:
+            printf("OnCanShowWindow\n");
+            break;
+        case VBoxEventType_OnShowWindow:
+            printf("OnShowWindow\n");
+            break;
+
+        default:
+            printf("unknown event: %d\n", evType);
+    }
+
+    return S_OK;
+}
+
+#ifdef USE_ACTIVE_EVENT_LISTENER
+
+struct IEventListenerDemo;
+typedef struct IEventListenerDemo IEventListenerDemo;
+
+typedef struct IEventListenerDemoVtbl
+{
+    HRESULT (*QueryInterface)(IEventListenerDemo *pThis, REFIID riid, void **ppvObject);
+    ULONG (*AddRef)(IEventListenerDemo *pThis);
+    ULONG (*Release)(IEventListenerDemo *pThis);
+#ifdef WIN32
+    HRESULT (*GetTypeInfoCount)(IEventListenerDemo *pThis, UINT *pctinfo);
+    HRESULT (*GetTypeInfo)(IEventListenerDemo *pThis, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo);
+    HRESULT (*GetIDsOfNames)(IEventListenerDemo *pThis, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId);
+    HRESULT (*Invoke)(IEventListenerDemo *pThis, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr);
+#endif
+    HRESULT (*HandleEvent)(IEventListenerDemo *pThis, IEvent *aEvent);
+} IEventListenerDemoVtbl;
+
+typedef struct IEventListenerDemo
+{
+    struct IEventListenerDemoVtbl *lpVtbl;
+
+    int cRef;
+
+#ifdef WIN32
+    /* Active event delivery needs a free threaded marshaler, as the default
+     * proxy marshaling cannot deal correctly with this case. */
+    IUnknown *pUnkMarshaler;
+#endif
+} IEventListenerDemo;
+
+/* Defines for easily calling IEventListenerDemo functions. */
+
+/* IUnknown functions. */
+#define IEventListenerDemo_QueryInterface(This,riid,ppvObject) \
+    ( (This)->lpVtbl->QueryInterface(This,riid,ppvObject) )
+
+#define IEventListenerDemo_AddRef(This) \
+    ( (This)->lpVtbl->AddRef(This) )
+
+#define IEventListenerDemo_Release(This) \
+    ( (This)->lpVtbl->Release(This) )
+
+#ifdef WIN32
+/* IDispatch functions. */
+#define IEventListenerDemo_GetTypeInfoCount(This,pctinfo) \
+    ( (This)->lpVtbl->GetTypeInfoCount(This,pctinfo) )
+
+#define IEventListenerDemo_GetTypeInfo(This,iTInfo,lcid,ppTInfo) \
+    ( (This)->lpVtbl->GetTypeInfo(This,iTInfo,lcid,ppTInfo) )
+
+#define IEventListenerDemo_GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) \
+    ( (This)->lpVtbl->GetIDsOfNames(This,riid,rgszNames,cNames,lcid,rgDispId) )
+
+#define IEventListenerDemo_Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) \
+    ( (This)->lpVtbl->Invoke(This,dispIdMember,riid,lcid,wFlags,pDispParams,pVarResult,pExcepInfo,puArgErr) )
+#endif
+
+/* IEventListener functions. */
+#define IEventListenerDemo_HandleEvent(This,aEvent) \
+    ( (This)->lpVtbl->HandleEvent(This,aEvent) )
+
+
+/**
+ * Event handler function, for active event processing.
+ */
+static HRESULT IEventListenerDemoImpl_HandleEvent(IEventListenerDemo *pThis, IEvent *event)
+{
+    return EventListenerDemoProcessEvent(event);
+}
+
+static HRESULT IEventListenerDemoImpl_QueryInterface(IEventListenerDemo *pThis, const IID *iid, void **resultp)
+{
+    /* match iid */
+    if (    !memcmp(iid, &IID_IEventListener, sizeof(IID))
+        ||  !memcmp(iid, &IID_IDispatch, sizeof(IID))
+        ||  !memcmp(iid, &IID_IUnknown, sizeof(IID)))
+    {
+        IEventListenerDemo_AddRef(pThis);
+        *resultp = pThis;
+        return S_OK;
+    }
+#ifdef WIN32
+    if (!memcmp(iid, &IID_IMarshal, sizeof(IID)))
+        return IUnknown_QueryInterface(pThis->pUnkMarshaler, iid, resultp);
+#endif
+
+    return E_NOINTERFACE;
+}
+
+static HRESULT IEventListenerDemoImpl_AddRef(IEventListenerDemo *pThis)
+{
+    return ++(pThis->cRef);
+}
+
+static HRESULT IEventListenerDemoImpl_Release(IEventListenerDemo *pThis)
+{
+    HRESULT c;
+
+    c = --(pThis->cRef);
+    if (!c)
+        free(pThis);
+    return c;
+}
+
+#ifdef WIN32
+static HRESULT IEventListenerDemoImpl_GetTypeInfoCount(IEventListenerDemo *pThis, UINT *pctinfo)
+{
+    if (!pctinfo)
+        return E_POINTER;
+    *pctinfo = 1;
+    return S_OK;
+}
+
+static HRESULT IEventListenerDemoImpl_GetTypeInfo(IEventListenerDemo *pThis, UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo)
+{
+    if (!ppTInfo)
+        return E_POINTER;
+    ITypeInfo_AddRef(g_pTInfoIEventListener);
+    *ppTInfo = g_pTInfoIEventListener;
+    return S_OK;
+}
+
+static HRESULT IEventListenerDemoImpl_GetIDsOfNames(IEventListenerDemo *pThis, REFIID riid, LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
+{
+    return ITypeInfo_GetIDsOfNames(g_pTInfoIEventListener, rgszNames, cNames, rgDispId);
+}
+
+static HRESULT IEventListenerDemoImpl_Invoke(IEventListenerDemo *pThis, DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
+{
+    return ITypeInfo_Invoke(g_pTInfoIEventListener, (IDispatch *)pThis, dispIdMember, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
+}
+
+static HRESULT LoadTypeInfo(REFIID riid, ITypeInfo **pTInfo)
+{
+    HRESULT hrc;
+    ITypeLib *pTypeLib;
+    hrc = LoadRegTypeLib(&LIBID_VirtualBox, 1 /* major */, 0 /* minor */, 0 /* lcid */, &pTypeLib);
+    if (FAILED(hrc))
+        return hrc;
+    hrc = ITypeLib_GetTypeInfoOfGuid(pTypeLib, riid, pTInfo);
+
+    /* No longer need access to the type lib, release it. */
+    ITypeLib_Release(pTypeLib);
+
+    return hrc;
+}
+#endif
+
+#ifdef __GNUC__
+typedef struct IEventListenerDemoVtblInt
+{
+    ptrdiff_t offset_to_top;
+    void *typeinfo;
+    IEventListenerDemoVtbl lpVtbl;
+} IEventListenerDemoVtblInt;
+
+static IEventListenerDemoVtblInt g_IEventListenerDemoVtblInt =
+{
+    0,      /* offset_to_top */
+    NULL,   /* typeinfo, not vital */
+    {
+        IEventListenerDemoImpl_QueryInterface,
+        IEventListenerDemoImpl_AddRef,
+        IEventListenerDemoImpl_Release,
+#ifdef WIN32
+        IEventListenerDemoImpl_GetTypeInfoCount,
+        IEventListenerDemoImpl_GetTypeInfo,
+        IEventListenerDemoImpl_GetIDsOfNames,
+        IEventListenerDemoImpl_Invoke,
+#endif
+        IEventListenerDemoImpl_HandleEvent
+    }
+};
+#elif defined(_MSC_VER)
+typedef struct IEventListenerDemoVtblInt
+{
+    IEventListenerDemoVtbl lpVtbl;
+} IEventListenerDemoVtblInt;
+
+static IEventListenerDemoVtblInt g_IEventListenerDemoVtblInt =
+{
+    {
+        IEventListenerDemoImpl_QueryInterface,
+        IEventListenerDemoImpl_AddRef,
+        IEventListenerDemoImpl_Release,
+#ifdef WIN32
+        IEventListenerDemoImpl_GetTypeInfoCount,
+        IEventListenerDemoImpl_GetTypeInfo,
+        IEventListenerDemoImpl_GetIDsOfNames,
+        IEventListenerDemoImpl_Invoke,
+#endif
+        IEventListenerDemoImpl_HandleEvent
+    }
+};
+#else
+# error Port me!
+#endif
+
+/**
+ * Register active event listener for the selected VM.
+ *
+ * @param   virtualBox ptr to IVirtualBox object
+ * @param   session    ptr to ISession object
+ */
+static void registerActiveEventListener(IVirtualBox *virtualBox, ISession *session)
+{
+    IConsole *console = NULL;
+    HRESULT hrc;
+
+    hrc = ISession_get_Console(session, &console);
+    if (SUCCEEDED(hrc) && console)
+    {
+        IEventSource *es = NULL;
+        hrc = IConsole_get_EventSource(console, &es);
+        if (SUCCEEDED(hrc) && es)
+        {
+            static const ULONG s_auInterestingEvents[] =
+            {
+                VBoxEventType_OnMousePointerShapeChanged,
+                VBoxEventType_OnMouseCapabilityChanged,
+                VBoxEventType_OnKeyboardLedsChanged,
+                VBoxEventType_OnStateChanged,
+                VBoxEventType_OnAdditionsStateChanged,
+                VBoxEventType_OnNetworkAdapterChanged,
+                VBoxEventType_OnSerialPortChanged,
+                VBoxEventType_OnParallelPortChanged,
+                VBoxEventType_OnStorageControllerChanged,
+                VBoxEventType_OnMediumChanged,
+                VBoxEventType_OnVRDEServerChanged,
+                VBoxEventType_OnUSBControllerChanged,
+                VBoxEventType_OnUSBDeviceStateChanged,
+                VBoxEventType_OnSharedFolderChanged,
+                VBoxEventType_OnRuntimeError,
+                VBoxEventType_OnCanShowWindow,
+                VBoxEventType_OnShowWindow
+            };
+            SAFEARRAY *interestingEventsSA = NULL;
+            IEventListenerDemo *consoleListener = NULL;
+
+            /* The VirtualBox API expects enum values as VT_I4, which in the
+             * future can be hopefully relaxed. */
+            interestingEventsSA = g_pVBoxFuncs->pfnSafeArrayCreateVector(VT_I4, 0,
+                                                                           sizeof(s_auInterestingEvents)
+                                                                         / sizeof(s_auInterestingEvents[0]));
+            g_pVBoxFuncs->pfnSafeArrayCopyInParamHelper(interestingEventsSA, &s_auInterestingEvents,
+                                                        sizeof(s_auInterestingEvents));
+
+            consoleListener = calloc(1, sizeof(IEventListenerDemo));
+            if (consoleListener)
+            {
+                consoleListener->lpVtbl = &(g_IEventListenerDemoVtblInt.lpVtbl);
+#ifdef WIN32
+                CoCreateFreeThreadedMarshaler((IUnknown *)consoleListener, &consoleListener->pUnkMarshaler);
+#endif
+                IEventListenerDemo_AddRef(consoleListener);
+
+                hrc = IEventSource_RegisterListener(es, (IEventListener *)consoleListener,
+                                                    ComSafeArrayAsInParam(interestingEventsSA),
+                                                    1 /* active */);
+                if (SUCCEEDED(hrc))
+                {
+                    /* Just wait here for events, no easy way to do this better
+                     * as there's not much to do after this completes. */
+                    printf("Entering event loop, PowerOff the machine to exit or press Ctrl-C to terminate\n");
+                    fflush(stdout);
+#ifdef WIN32
+                    SetConsoleCtrlHandler(ctrlCHandler, TRUE);
+#else
+                    signal(SIGINT, (void (*)(int))ctrlCHandler);
+#endif
+
+                    while (!g_fStop)
+                        g_pVBoxFuncs->pfnProcessEventQueue(250);
+
+#ifdef WIN32
+                    SetConsoleCtrlHandler(ctrlCHandler, FALSE);
+#else
+                    signal(SIGINT, SIG_DFL);
+#endif
+                }
+                else
+                    printf("Failed to register event listener.\n");
+                IEventSource_UnregisterListener(es, (IEventListener *)consoleListener);
+#ifdef WIN32
+                if (consoleListener->pUnkMarshaler)
+                    IUnknown_Release(consoleListener->pUnkMarshaler);
+#endif
+                IEventListenerDemo_Release(consoleListener);
+            }
+            else
+                printf("Failed while allocating memory for console event listener.\n");
+            g_pVBoxFuncs->pfnSafeArrayDestroy(interestingEventsSA);
+            IEventSource_Release(es);
+        }
+        else
+            printf("Failed to get the event source instance.\n");
+        IConsole_Release(console);
+    }
+}
+
+#else /* !USE_ACTIVE_EVENT_LISTENER */
+
+/**
+ * Register passive event listener for the selected VM.
+ *
+ * @param   virtualBox ptr to IVirtualBox object
+ * @param   session    ptr to ISession object
+ */
+static void registerPassiveEventListener(ISession *session)
+{
+    IConsole *console = NULL;
+    HRESULT hrc;
+
+    hrc = ISession_get_Console(session, &console);
+    if (SUCCEEDED(hrc) && console)
+    {
+        IEventSource *es = NULL;
+        hrc = IConsole_get_EventSource(console, &es);
+        if (SUCCEEDED(hrc) && es)
+        {
+            static const ULONG s_auInterestingEvents[] =
+            {
+                VBoxEventType_OnMousePointerShapeChanged,
+                VBoxEventType_OnMouseCapabilityChanged,
+                VBoxEventType_OnKeyboardLedsChanged,
+                VBoxEventType_OnStateChanged,
+                VBoxEventType_OnAdditionsStateChanged,
+                VBoxEventType_OnNetworkAdapterChanged,
+                VBoxEventType_OnSerialPortChanged,
+                VBoxEventType_OnParallelPortChanged,
+                VBoxEventType_OnStorageControllerChanged,
+                VBoxEventType_OnMediumChanged,
+                VBoxEventType_OnVRDEServerChanged,
+                VBoxEventType_OnUSBControllerChanged,
+                VBoxEventType_OnUSBDeviceStateChanged,
+                VBoxEventType_OnSharedFolderChanged,
+                VBoxEventType_OnRuntimeError,
+                VBoxEventType_OnCanShowWindow,
+                VBoxEventType_OnShowWindow
+            };
+            SAFEARRAY *interestingEventsSA = NULL;
+            IEventListener *consoleListener = NULL;
+
+            /* The VirtualBox API expects enum values as VT_I4, which in the
+             * future can be hopefully relaxed. */
+            interestingEventsSA = g_pVBoxFuncs->pfnSafeArrayCreateVector(VT_I4, 0,
+                                                                           sizeof(s_auInterestingEvents)
+                                                                         / sizeof(s_auInterestingEvents[0]));
+            g_pVBoxFuncs->pfnSafeArrayCopyInParamHelper(interestingEventsSA, &s_auInterestingEvents,
+                                                        sizeof(s_auInterestingEvents));
+
+            hrc = IEventSource_CreateListener(es, &consoleListener);
+            if (SUCCEEDED(hrc) && consoleListener)
+            {
+                hrc = IEventSource_RegisterListener(es, consoleListener,
+                                                    ComSafeArrayAsInParam(interestingEventsSA),
+                                                    0 /* passive */);
+                if (SUCCEEDED(hrc))
+                {
+                    /* Just wait here for events, no easy way to do this better
+                     * as there's not much to do after this completes. */
+                    printf("Entering event loop, PowerOff the machine to exit or press Ctrl-C to terminate\n");
+                    fflush(stdout);
+#ifdef WIN32
+                    SetConsoleCtrlHandler(ctrlCHandler, TRUE);
+#else
+                    signal(SIGINT, ctrlCHandler);
+#endif
+
+                    while (!g_fStop)
+                    {
+                        IEvent *ev = NULL;
+                        hrc = IEventSource_GetEvent(es, consoleListener, 250, &ev);
+                        if (FAILED(hrc))
+                        {
+                            printf("Failed getting event: %#x\n", (unsigned)hrc);
+                            g_fStop = 1;
+                            continue;
+                        }
+                        /* handle timeouts, resulting in NULL events */
+                        if (!ev)
+                            continue;
+                        hrc = EventListenerDemoProcessEvent(ev);
+                        if (FAILED(hrc))
+                        {
+                            printf("Failed processing event: %#x\n", (unsigned)hrc);
+                            g_fStop = 1;
+                            /* finish processing the event */
+                        }
+                        hrc = IEventSource_EventProcessed(es, consoleListener, ev);
+                        if (FAILED(hrc))
+                        {
+                            printf("Failed to mark event as processed: %#x\n", (unsigned)hrc);
+                            g_fStop = 1;
+                            /* continue with event release */
+                        }
+                        if (ev)
+                        {
+                            IEvent_Release(ev);
+                            ev = NULL;
+                        }
+                    }
+
+#ifdef WIN32
+                    SetConsoleCtrlHandler(ctrlCHandler, FALSE);
+#else
+                    signal(SIGINT, SIG_DFL);
+#endif
+                }
+                else
+                    printf("Failed to register event listener.\n");
+                IEventSource_UnregisterListener(es, (IEventListener *)consoleListener);
+                IEventListener_Release(consoleListener);
+            }
+            else
+                printf("Failed to create an event listener instance.\n");
+            g_pVBoxFuncs->pfnSafeArrayDestroy(interestingEventsSA);
+            IEventSource_Release(es);
+        }
+        else
+            printf("Failed to get the event source instance.\n");
+        IConsole_Release(console);
+    }
+}
+
+#endif /* !USE_ACTIVE_EVENT_LISTENER */
+
+/**
+ * Print detailed error information if available.
+ * @param   pszExecutable   string with the executable name
+ * @param   pszErrorMsg     string containing the code location specific error message
+ * @param   hrc             COM/XPCOM result code
+ */
+static void PrintErrorInfo(const char *pszExecutable, const char *pszErrorMsg, HRESULT hrc)
+{
+    IErrorInfo *ex;
+    HRESULT hrc2;
+    fprintf(stderr, "%s: %s (hrc=%#010x)\n", pszExecutable, pszErrorMsg, (unsigned)hrc);
+    hrc2 = g_pVBoxFuncs->pfnGetException(&ex);
+    if (SUCCEEDED(hrc2) && ex)
+    {
+        IVirtualBoxErrorInfo *ei;
+        hrc2 = IErrorInfo_QueryInterface(ex, &IID_IVirtualBoxErrorInfo, (void **)&ei);
+        if (SUCCEEDED(hrc2) && ei != NULL)
+        {
+            /* got extended error info, maybe multiple infos */
+            do
+            {
+                LONG resultCode = S_OK;
+                BSTR componentUtf16 = NULL;
+                char *component = NULL;
+                BSTR textUtf16 = NULL;
+                char *text = NULL;
+                IVirtualBoxErrorInfo *ei_next = NULL;
+                fprintf(stderr, "Extended error info (IVirtualBoxErrorInfo):\n");
+
+                IVirtualBoxErrorInfo_get_ResultCode(ei, &resultCode);
+                fprintf(stderr, "  resultCode=%#010x\n", (unsigned)resultCode);
+
+                IVirtualBoxErrorInfo_get_Component(ei, &componentUtf16);
+                g_pVBoxFuncs->pfnUtf16ToUtf8(componentUtf16, &component);
+                g_pVBoxFuncs->pfnComUnallocString(componentUtf16);
+                fprintf(stderr, "  component=%s\n", component);
+                g_pVBoxFuncs->pfnUtf8Free(component);
+
+                IVirtualBoxErrorInfo_get_Text(ei, &textUtf16);
+                g_pVBoxFuncs->pfnUtf16ToUtf8(textUtf16, &text);
+                g_pVBoxFuncs->pfnComUnallocString(textUtf16);
+                fprintf(stderr, "  text=%s\n", text);
+                g_pVBoxFuncs->pfnUtf8Free(text);
+
+                hrc2 = IVirtualBoxErrorInfo_get_Next(ei, &ei_next);
+                if (FAILED(hrc2))
+                    ei_next = NULL;
+                IVirtualBoxErrorInfo_Release(ei);
+                ei = ei_next;
+            } while (ei);
+        }
+
+        IErrorInfo_Release(ex);
+        g_pVBoxFuncs->pfnClearException();
+    }
+}
+
+/**
+ * Start a VM.
+ *
+ * @param   argv0       executable name
+ * @param   virtualBox  ptr to IVirtualBox object
+ * @param   session     ptr to ISession object
+ * @param   id          identifies the machine to start
+ */
+static void startVM(const char *argv0, IVirtualBox *virtualBox, ISession *session, BSTR id)
+{
+    HRESULT hrc;
+    IMachine  *machine    = NULL;
+    IProgress *progress   = NULL;
+    SAFEARRAY *env        = NULL;
+    BSTR sessionType;
+    SAFEARRAY *groupsSA = g_pVBoxFuncs->pfnSafeArrayOutParamAlloc();
+
+    hrc = IVirtualBox_FindMachine(virtualBox, id, &machine);
+    if (FAILED(hrc) || !machine)
+    {
+        PrintErrorInfo(argv0, "Error: Couldn't get the Machine reference", hrc);
+        return;
+    }
+
+    hrc = IMachine_get_Groups(machine, ComSafeArrayAsOutTypeParam(groupsSA, BSTR));
+    if (SUCCEEDED(hrc))
+    {
+        BSTR *groups = NULL;
+        ULONG cbGroups = 0;
+        ULONG i, cGroups;
+        g_pVBoxFuncs->pfnSafeArrayCopyOutParamHelper((void **)&groups, &cbGroups, VT_BSTR, groupsSA);
+        g_pVBoxFuncs->pfnSafeArrayDestroy(groupsSA);
+        cGroups = cbGroups / sizeof(groups[0]);
+        for (i = 0; i < cGroups; ++i)
+        {
+            /* Note that the use of %S might be tempting, but it is not
+             * available on all platforms, and even where it is usable it
+             * may depend on correct compiler options to make wchar_t a
+             * 16 bit number. So better play safe and use UTF-8. */
+            char *group;
+            g_pVBoxFuncs->pfnUtf16ToUtf8(groups[i], &group);
+            printf("Groups[%u]: %s\n", (unsigned)i, group);
+            g_pVBoxFuncs->pfnUtf8Free(group);
+        }
+        for (i = 0; i < cGroups; ++i)
+            g_pVBoxFuncs->pfnComUnallocString(groups[i]);
+        g_pVBoxFuncs->pfnArrayOutFree(groups);
+    }
+
+    g_pVBoxFuncs->pfnUtf8ToUtf16("gui", &sessionType);
+    hrc = IMachine_LaunchVMProcess(machine, session, sessionType, ComSafeArrayAsInParam(env), &progress);
+    g_pVBoxFuncs->pfnUtf16Free(sessionType);
+    if (SUCCEEDED(hrc))
+    {
+        BOOL completed;
+        LONG resultCode;
+
+        printf("Waiting for the remote session to open...\n");
+        IProgress_WaitForCompletion(progress, -1);
+
+        hrc = IProgress_get_Completed(progress, &completed);
+        if (FAILED(hrc))
+            fprintf(stderr, "Error: GetCompleted status failed\n");
+
+        IProgress_get_ResultCode(progress, &resultCode);
+        if (FAILED(resultCode))
+        {
+            IVirtualBoxErrorInfo *errorInfo;
+            BSTR textUtf16;
+            char *text;
+
+            IProgress_get_ErrorInfo(progress, &errorInfo);
+            IVirtualBoxErrorInfo_get_Text(errorInfo, &textUtf16);
+            g_pVBoxFuncs->pfnUtf16ToUtf8(textUtf16, &text);
+            printf("Error: %s\n", text);
+
+            g_pVBoxFuncs->pfnComUnallocString(textUtf16);
+            g_pVBoxFuncs->pfnUtf8Free(text);
+            IVirtualBoxErrorInfo_Release(errorInfo);
+        }
+        else
+        {
+            fprintf(stderr, "VM process has been successfully started\n");
+
+            /* Kick off the event listener demo part, which is quite separate.
+             * Ignore it if you need a more basic sample. */
+#ifdef USE_ACTIVE_EVENT_LISTENER
+            registerActiveEventListener(virtualBox, session);
+#else
+            registerPassiveEventListener(session);
+#endif
+        }
+        IProgress_Release(progress);
+    }
+    else
+        PrintErrorInfo(argv0, "Error: LaunchVMProcess failed", hrc);
+
+    /* It's important to always release resources. */
+    IMachine_Release(machine);
+}
+
+/**
+ * List the registered VMs.
+ *
+ * @param   argv0       executable name
+ * @param   virtualBox  ptr to IVirtualBox object
+ * @param   session     ptr to ISession object
+ */
+static void listVMs(const char *argv0, IVirtualBox *virtualBox, ISession *session)
+{
+    HRESULT hrc;
+    SAFEARRAY *machinesSA = g_pVBoxFuncs->pfnSafeArrayOutParamAlloc();
+    IMachine **machines = NULL;
+    ULONG machineCnt = 0;
+    ULONG i;
+    unsigned start_id;
+
+    /*
+     * Get the list of all registered VMs.
+     */
+    hrc = IVirtualBox_get_Machines(virtualBox, ComSafeArrayAsOutIfaceParam(machinesSA, IMachine *));
+    if (FAILED(hrc))
+    {
+        PrintErrorInfo(argv0, "could not get list of machines", hrc);
+        return;
+    }
+
+    /*
+     * Extract interface pointers from machinesSA, and update the reference
+     * counter of each object, as destroying machinesSA would call Release.
+     */
+    g_pVBoxFuncs->pfnSafeArrayCopyOutIfaceParamHelper((IUnknown ***)&machines, &machineCnt, machinesSA);
+    g_pVBoxFuncs->pfnSafeArrayDestroy(machinesSA);
+
+    if (!machineCnt)
+    {
+        g_pVBoxFuncs->pfnArrayOutFree(machines);
+        printf("\tNo VMs\n");
+        return;
+    }
+
+    printf("VM List:\n\n");
+
+    /*
+     * Iterate through the collection.
+     */
+    for (i = 0; i < machineCnt; ++i)
+    {
+        IMachine *machine      = machines[i];
+        BOOL      isAccessible = FALSE;
+
+        printf("\tMachine #%u\n", (unsigned)i);
+
+        if (!machine)
+        {
+            printf("\t(skipped, NULL)\n");
+            continue;
+        }
+
+        IMachine_get_Accessible(machine, &isAccessible);
+
+        if (isAccessible)
+        {
+            BSTR machineNameUtf16;
+            char *machineName;
+
+            IMachine_get_Name(machine, &machineNameUtf16);
+            g_pVBoxFuncs->pfnUtf16ToUtf8(machineNameUtf16,&machineName);
+            g_pVBoxFuncs->pfnComUnallocString(machineNameUtf16);
+            printf("\tName:        %s\n", machineName);
+            g_pVBoxFuncs->pfnUtf8Free(machineName);
+        }
+        else
+            printf("\tName:        <inaccessible>\n");
+
+        {
+            BSTR uuidUtf16;
+            char      *uuidUtf8;
+
+            IMachine_get_Id(machine, &uuidUtf16);
+            g_pVBoxFuncs->pfnUtf16ToUtf8(uuidUtf16, &uuidUtf8);
+            g_pVBoxFuncs->pfnComUnallocString(uuidUtf16);
+            printf("\tUUID:        %s\n", uuidUtf8);
+            g_pVBoxFuncs->pfnUtf8Free(uuidUtf8);
+        }
+
+        if (isAccessible)
+        {
+            {
+                BSTR      configFileUtf16;
+                char      *configFileUtf8;
+
+                IMachine_get_SettingsFilePath(machine, &configFileUtf16);
+                g_pVBoxFuncs->pfnUtf16ToUtf8(configFileUtf16, &configFileUtf8);
+                g_pVBoxFuncs->pfnComUnallocString(configFileUtf16);
+                printf("\tConfig file: %s\n", configFileUtf8);
+                g_pVBoxFuncs->pfnUtf8Free(configFileUtf8);
+            }
+
+            {
+                ULONG memorySize;
+
+                IMachine_get_MemorySize(machine, &memorySize);
+                printf("\tMemory size: %uMB\n", (unsigned)memorySize);
+            }
+
+            {
+                BSTR typeId;
+                BSTR osNameUtf16;
+                char *osName;
+                IGuestOSType *osType = NULL;
+
+                IMachine_get_OSTypeId(machine, &typeId);
+                IVirtualBox_GetGuestOSType(virtualBox, typeId, &osType);
+                g_pVBoxFuncs->pfnComUnallocString(typeId);
+                IGuestOSType_get_Description(osType, &osNameUtf16);
+                g_pVBoxFuncs->pfnUtf16ToUtf8(osNameUtf16,&osName);
+                g_pVBoxFuncs->pfnComUnallocString(osNameUtf16);
+                printf("\tGuest OS:    %s\n\n", osName);
+                g_pVBoxFuncs->pfnUtf8Free(osName);
+
+                IGuestOSType_Release(osType);
+            }
+        }
+    }
+
+    /*
+     * Let the user chose a machine to start.
+     */
+    printf("Type Machine# to start (0 - %u) or 'quit' to do nothing: ",
+           (unsigned)(machineCnt - 1));
+    fflush(stdout);
+
+    if (scanf("%u", &start_id) == 1 && start_id < machineCnt)
+    {
+        IMachine *machine = machines[start_id];
+
+        if (machine)
+        {
+            BSTR uuidUtf16 = NULL;
+
+            IMachine_get_Id(machine, &uuidUtf16);
+            startVM(argv0, virtualBox, session, uuidUtf16);
+            g_pVBoxFuncs->pfnComUnallocString(uuidUtf16);
+        }
+    }
+
+    /*
+     * Don't forget to release the objects in the array.
+     */
+    for (i = 0; i < machineCnt; ++i)
+    {
+        IMachine *machine = machines[i];
+
+        if (machine)
+            IMachine_Release(machine);
+    }
+    g_pVBoxFuncs->pfnArrayOutFree(machines);
+}
+
+/* Main - Start the ball rolling. */
+
+int main(int argc, char **argv)
+{
+    IVirtualBoxClient *vboxclient = NULL;
+    IVirtualBox *vbox            = NULL;
+    ISession   *session          = NULL;
+    ULONG       revision         = 0;
+    BSTR        versionUtf16     = NULL;
+    BSTR        homefolderUtf16  = NULL;
+    HRESULT     hrc;     /* Result code of various function (method) calls. */
+    (void)argc;
+
+    printf("Starting main()\n");
+
+    if (VBoxCGlueInit())
+    {
+        fprintf(stderr, "%s: FATAL: VBoxCGlueInit failed: %s\n",
+                argv[0], g_szVBoxErrMsg);
+        return EXIT_FAILURE;
+    }
+
+    {
+        unsigned ver = g_pVBoxFuncs->pfnGetVersion();
+        printf("VirtualBox version: %u.%u.%u\n", ver / 1000000, ver / 1000 % 1000, ver % 1000);
+        ver = g_pVBoxFuncs->pfnGetAPIVersion();
+        printf("VirtualBox API version: %u.%u\n", ver / 1000, ver % 1000);
+    }
+
+    g_pVBoxFuncs->pfnClientInitialize(NULL, &vboxclient);
+    if (!vboxclient)
+    {
+        fprintf(stderr, "%s: FATAL: could not get VirtualBoxClient reference\n", argv[0]);
+        return EXIT_FAILURE;
+    }
+
+    printf("----------------------------------------------------\n");
+
+    hrc = IVirtualBoxClient_get_VirtualBox(vboxclient, &vbox);
+    if (FAILED(hrc) || !vbox)
+    {
+        PrintErrorInfo(argv[0], "FATAL: could not get VirtualBox reference", hrc);
+        return EXIT_FAILURE;
+    }
+    hrc = IVirtualBoxClient_get_Session(vboxclient, &session);
+    if (FAILED(hrc) || !session)
+    {
+        PrintErrorInfo(argv[0], "FATAL: could not get Session reference", hrc);
+        return EXIT_FAILURE;
+    }
+
+#ifdef USE_ACTIVE_EVENT_LISTENER
+# ifdef WIN32
+    hrc = LoadTypeInfo(&IID_IEventListener, &g_pTInfoIEventListener);
+    if (FAILED(hrc) || !g_pTInfoIEventListener)
+    {
+        PrintErrorInfo(argv[0], "FATAL: could not get type information for IEventListener", hrc);
+        return EXIT_FAILURE;
+    }
+# endif /* WIN32 */
+#endif /* USE_ACTIVE_EVENT_LISTENER */
+
+    /*
+     * Now ask for revision, version and home folder information of
+     * this vbox. Were not using fancy macros here so it
+     * remains easy to see how we access C++'s vtable.
+     */
+
+    /* 1. Revision */
+    hrc = IVirtualBox_get_Revision(vbox, &revision);
+    if (SUCCEEDED(hrc))
+        printf("\tRevision: %u\n", (unsigned)revision);
+    else
+        PrintErrorInfo(argv[0], "GetRevision() failed", hrc);
+
+    /* 2. Version */
+    hrc = IVirtualBox_get_Version(vbox, &versionUtf16);
+    if (SUCCEEDED(hrc))
+    {
+        char *version = NULL;
+        g_pVBoxFuncs->pfnUtf16ToUtf8(versionUtf16, &version);
+        printf("\tVersion: %s\n", version);
+        g_pVBoxFuncs->pfnUtf8Free(version);
+        g_pVBoxFuncs->pfnComUnallocString(versionUtf16);
+    }
+    else
+        PrintErrorInfo(argv[0], "GetVersion() failed", hrc);
+
+    /* 3. Home Folder */
+    hrc = IVirtualBox_get_HomeFolder(vbox, &homefolderUtf16);
+    if (SUCCEEDED(hrc))
+    {
+        char *homefolder = NULL;
+        g_pVBoxFuncs->pfnUtf16ToUtf8(homefolderUtf16, &homefolder);
+        printf("\tHomeFolder: %s\n", homefolder);
+        g_pVBoxFuncs->pfnUtf8Free(homefolder);
+        g_pVBoxFuncs->pfnComUnallocString(homefolderUtf16);
+    }
+    else
+        PrintErrorInfo(argv[0], "GetHomeFolder() failed", hrc);
+
+    listVMs(argv[0], vbox, session);
+    ISession_UnlockMachine(session);
+
+    printf("----------------------------------------------------\n");
+
+    /*
+     * Do as mom told us: always clean up after yourself.
+     */
+#ifdef USE_ACTIVE_EVENT_LISTENER
+# ifdef WIN32
+    if (g_pTInfoIEventListener)
+    {
+        ITypeInfo_Release(g_pTInfoIEventListener);
+        g_pTInfoIEventListener = NULL;
+    }
+# endif /* WIN32 */
+#endif /* USE_ACTIVE_EVENT_LISTENER */
+
+    if (session)
+    {
+        ISession_Release(session);
+        session = NULL;
+    }
+    if (vbox)
+    {
+        IVirtualBox_Release(vbox);
+        vbox = NULL;
+    }
+    if (vboxclient)
+    {
+        IVirtualBoxClient_Release(vboxclient);
+        vboxclient = NULL;
+    }
+
+    g_pVBoxFuncs->pfnClientUninitialize();
+    VBoxCGlueTerm();
+    printf("Finished main()\n");
+
+    return 0;
+}
+/* vim: set ts=4 sw=4 et: */