Changeset 50183 in vbox for trunk

Timestamp:

Jan 23, 2014 3:58:21 PM (11 years ago)

Author:

vboxsync

Message:

Main/cbinding: bring the C binding to a new functionality level, making them handle both COM and XPCOM based platforms, plus some xsl cleanup to eliminate the $dispatch case which was unused for many years (and will not be used again)

Location:

trunk/src/VBox

Files:

• Installer/win/VirtualBox.wxs (modified) (1 diff)
• Main/cbinding/Makefile.kmk (modified) (5 diffs)
• Main/cbinding/VBoxCAPI.cpp (moved) (moved from trunk/src/VBox/Main/cbinding/VBoxXPCOMC.cpp ) (19 diffs)
• Main/cbinding/VBoxCAPIGlue.c (moved) (moved from trunk/src/VBox/Main/cbinding/VBoxXPCOMCGlue.c ) (12 diffs)
• Main/cbinding/VBoxCAPIGlue.h.in (moved) (moved from trunk/src/VBox/Main/cbinding/VBoxXPCOMCGlue.h.in ) (3 diffs)
• Main/cbinding/capiidl.xsl (moved) (moved from trunk/src/VBox/Main/cbinding/xpcidl.xsl ) (38 diffs)
• Main/cbinding/makefile.tstCAPIGlue (moved) (moved from trunk/src/VBox/Main/cbinding/makefile.tstXPCOMCGlue ) (3 diffs)
• Main/cbinding/tstCAPIGlue.c (moved) (moved from trunk/src/VBox/Main/cbinding/tstXPCOMCGlue.c ) (33 diffs)
• Main/glue/glue-java.xsl (modified) (3 diffs)
• Main/idl/apiwrap-server.xsl (modified) (6 diffs)
• Main/idl/midl.xsl (modified) (2 diffs)
• Main/idl/xpidl.xsl (modified) (1 diff)
• Main/webservice/websrv-php.xsl (modified) (3 diffs)
• Main/webservice/websrv-python.xsl (modified) (4 diffs)

trunk/src/VBox/Installer/win/VirtualBox.wxs

@@ -660 +660 @@
 <?endif?>
 
+                    <!-- C API (glue) binding -->
+                    <Component Id="cp_VBoxCAPI" Guid="097F7F53-7111-467F-8E0C-257D9926FDA0">
+                        <File Id="file_VBoxCAPI.dll" Name="VBoxCAPI.dll"
+                              Source="$(env.PATH_OUT)\bin\VBoxCAPI.dll" />
+                    </Component>
+
 <?if $(env.VBOX_WITH_PYTHON) = "yes" ?>
                     <Component Id="cp_VBoxPythonBinding" Guid="293D7E11-78DA-4C31-AEED-AE2FE42F6881">

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

@@ -5 +5 @@
 
 #
-# Copyright (C) 2009-2013 Oracle Corporation
+# Copyright (C) 2009-2014 Oracle Corporation
 #
 # This file is part of VirtualBox Open Source Edition (OSE), as
@@ -20 +20 @@
 
 
-if defined(VBOX_WITH_XPCOM) || defined(VBOX_ONLY_SDK)
 #
 # The samples
 #
-INSTALLS += XpComCSamples
-XpComCSamples_MODE = a+r,u+rw
-XpComCSamples_INST = \
-        $(INST_SDK)bindings/xpcom/cbinding/samples/
-XpComCSamples_SOURCES = \
-        tstXPCOMCGlue.c \
-        makefile.tstXPCOMCGlue=>Makefile
+INSTALLS += CAPISamples
+CAPISamples_MODE = a+r,u+rw
+CAPISamples_INST = \
+        $(INST_SDK)bindings/c/samples/
+CAPISamples_SOURCES = \
+        tstCAPIGlue.c \
+        makefile.tstCAPIGlue=>Makefile
 
-INSTALLS += XpComCGlue
-XpComCGlue_MODE = a+r,u+rw
-XpComCGlue_INST = \
-        $(INST_SDK)bindings/xpcom/cbinding/
-XpComCGlue_SOURCES = \
-        VBoxXPCOMCGlue.c \
-        $(XpComCHeaders_0_OUTDIR)/VBoxXPCOMCGlue.h
+INSTALLS += CAPIGlue
+CAPIGlue_MODE = a+r,u+rw
+CAPIGlue_INST = \
+        $(INST_SDK)bindings/c/glue/
+CAPIGlue_SOURCES = \
+        VBoxCAPIGlue.c \
+        $(CAPIHeaders_0_OUTDIR)/VBoxCAPIGlue.h
 
-INSTALLS += XpComCHeaders
-XpComCHeaders_MODE = a+r,u+rw
-XpComCHeaders_INST = $(INST_SDK)bindings/xpcom/include/
-XpComCHeaders_SOURCES = \
+INSTALLS += CAPIHeaders
+CAPIHeaders_MODE = a+r,u+rw
+CAPIHeaders_INST = $(INST_SDK)bindings/c/include/
+CAPIHeaders_SOURCES = \
         VBoxCAPI_v2_2.h \
         VBoxCAPI_v3_0.h \
@@ -51 +50 @@
         VBoxCAPI_v4_1.h \
         VBoxCAPI_v4_2.h \
-        $(XpComCHeaders_0_OUTDIR)/VBoxCAPI.h=>VBoxCAPI_v$(VBOX_API_VERSION).h
+        $(CAPIHeaders_0_OUTDIR)/VBoxCAPI.h=>VBoxCAPI_v$(VBOX_API_VERSION).h
 
-$$(XpComCHeaders_0_OUTDIR)/VBoxXPCOMCGlue.h: \
-                $(PATH_SUB_CURRENT)/VBoxXPCOMCGlue.h.in \
+$$(CAPIHeaders_0_OUTDIR)/VBoxCAPIGlue.h: \
+                $(PATH_SUB_CURRENT)/VBoxCAPIGlue.h.in \
                 $(MAKEFILE_CURRENT) \
                 | $$(dir $$@)
@@ -62 +61 @@
                 <  $< >  $@
 
-$$(XpComCHeaders_0_OUTDIR)/VBoxCAPI.h: \
-                $(PATH_SUB_CURRENT)/xpcidl.xsl \
+$$(CAPIHeaders_0_OUTDIR)/VBoxCAPI.h: \
+                $(PATH_SUB_CURRENT)/capiidl.xsl \
                 $(VBOX_XIDL_FILE) \
                 | $$(dir $$@)
-        $(call MSG_TOOL,xsltproc,XpComCHeaders,$<,$@)
+        $(call MSG_TOOL,xsltproc,CAPIHeaders,$<,$@)
         $(QUIET)$(VBOX_XSLTPROC) -o $@ $^
 
-endif # VBOX_WITH_XPCOM || SDK
-if !defined(VBOX_ONLY_SDK) && defined(VBOX_WITH_XPCOM)
+if !defined(VBOX_ONLY_SDK)
 
  #
- # The C utility DLL
+ # The C API binding utility DLL
  #
+ DLLS += VBoxCAPI
+ VBoxCAPI_TEMPLATE = VBOXMAINCLIENTDLL
  ifdef VBOX_WITH_XPCOM
- DLLS += VBoxXPCOMC
- VBoxXPCOMC_TEMPLATE = VBOXMAINDLL
- VBoxXPCOMC_DEFS = IN_VBOXXPCOMC
- VBoxXPCOMC_SOURCES = \
-        VBoxXPCOMC.cpp
- VBoxXPCOMC_INCS = \
-        $(XpComCHeaders_0_OUTDIR)
- VBoxXPCOMC_INTERMEDIATES = \
-        $(XpComCHeaders_0_OUTDIR)/VBoxCAPI.h
+  # 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_INCS = \
+        $(CAPIHeaders_0_OUTDIR)
+ VBoxCAPI_INTERMEDIATES = \
+        $(CAPIHeaders_0_OUTDIR)/VBoxCAPI.h
 
  #
  # The C glue library.
  #
- LIBRARIES += VBoxXPCOMCGlue
- VBoxXPCOMCGlue_TEMPLATE = VBOXMAINEXE
- VBoxXPCOMCGlue_DEFS = IN_VBOXXPCOMC
- VBoxXPCOMCGlue_SOURCES = \
-        VBoxXPCOMCGlue.c
- VBoxXPCOMCGlue_INCS = \
-        $(VBOX_PATH_SDK)/bindings/xpcom/cbinding
- VBoxXPCOMCGlue_INTERMEDIATES = \
-        $(VBOX_PATH_SDK)/bindings/xpcom/cbinding/VBoxXPCOMCGlue.h \
-        $(VBOX_PATH_SDK)/bindings/xpcom/include/VBoxCAPI_v$(VBOX_API_VERSION).h
+ 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"
@@ -106 +114 @@
   # C testcase using the dynamic glue.
   #
-  PROGRAMS += tstXPCOMCGlue
-  tstXPCOMCGlue_TEMPLATE = VBOXR3TSTEXE
-  tstXPCOMCGlue_INCS = \
-        $(VBOX_PATH_SDK)/bindings/xpcom/include \
-        $(VBOX_PATH_SDK)/bindings/xpcom/cbinding
-  tstXPCOMCGlue_INTERMEDIATES = \
-        $(VBOX_PATH_SDK)/bindings/xpcom/cbinding/VBoxXPCOMCGlue.h \
-        $(VBOX_PATH_SDK)/bindings/xpcom/include/VBoxCAPI_v$(VBOX_API_VERSION).h
-  tstXPCOMCGlue_SOURCES = \
-        tstXPCOMCGlue.c
-  tstXPCOMCGlue_LIBS = \
-        $(VBoxXPCOMCGlue_1_TARGET)
+  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
+  tstCAPIGlue_SOURCES = \
+        tstCAPIGlue.c
+  tstCAPIGlue_LIBS = \
+        $(VBoxCAPIGlue_1_TARGET)
  endif
 

trunk/src/VBox/Main/cbinding/VBoxCAPI.cpp

@@ -1 +1 @@
 /* $Id$ */
-/** @file VBoxXPCOMC.cpp
- * Utility functions to use with the C binding for XPCOM.
+/** @file VBoxCAPI.cpp
+ * Utility functions to use with the C API binding.
  */
 
 /*
- * Copyright (C) 2009-2013 Oracle Corporation
+ * Copyright (C) 2009-2014 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -17 +17 @@
 
 #define LOG_GROUP LOG_GROUP_MAIN
-#include <nsMemory.h>
-#include <nsIServiceManager.h>
-#include <nsEventQueueUtils.h>
-#include <nsIExceptionService.h>
-
+
+#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/initterm.h>
 #include <iprt/string.h>
+#include <iprt/uuid.h>
 #include <iprt/env.h>
+#include <iprt/mem.h>
 #include <VBox/log.h>
-
-#include "VBoxCAPI.h"
+#include <VBox/version.h>
+
 #include "VBox/com/com.h"
-#include "VBox/version.h"
+#include "VBox/com/NativeEventQueue.h"
 
 using namespace std;
 
-/* The following 3 object references should be eliminated once the legacy
- * way to initialize the XPCOM C bindings is removed. */
+/* 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;
-static nsIComponentManager *g_Manager           = 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);
@@ -44 +56 @@
 
 static int
-VBoxUtf16ToUtf8(const PRUnichar *pwszString, char **ppszString)
-{
+VBoxUtf16ToUtf8(CBSTR pwszString, char **ppszString)
+{
+    if (!pwszString)
+    {
+        *ppszString = NULL;
+        return VINF_SUCCESS;
+    }
     return RTUtf16ToUtf8(pwszString, ppszString);
 }
 
 static int
-VBoxUtf8ToUtf16(const char *pszString, PRUnichar **ppwszString)
-{
+VBoxUtf8ToUtf16(const char *pszString, BSTR *ppwszString)
+{
+    if (!pszString)
+    {
+        *ppwszString = NULL;
+        return VINF_SUCCESS;
+    }
+#ifdef VBOX_WITH_XPCOM
     return RTStrToUtf16(pszString, ppwszString);
+#else /* !VBOX_WITH_XPCOM */
+    PRTUTF16 pwsz;
+    int vrc = RTStrToUtf16(pszString, &pwsz);
+    *ppwszString = ::SysAllocString(pwsz);
+    RTUtf16Free(pwsz);
+    return vrc;
+#endif /* !VBOX_WITH_XPCOM */
 }
 
 static void
-VBoxUtf16Free(PRUnichar *pwszString)
-{
+VBoxUtf16Free(BSTR pwszString)
+{
+#ifdef VBOX_WITH_XPCOM
     RTUtf16Free(pwszString);
+#else /* !VBOX_WITH_XPCOM */
+    ::SysFreeString(pwszString);
+#endif /* !VBOX_WITH_XPCOM */
 }
 
@@ -68 +102 @@
 
 static void
-VBoxComUnallocMem(void *ptr)
-{
-    if (ptr)
-        nsMemory::Free(ptr);
+VBoxComUnallocString(BSTR pwsz)
+{
+    if (pwsz)
+    {
+#ifdef VBOX_WITH_XPCOM
+        nsMemory::Free(pwsz);
+#else /* !VBOX_WITH_XPCOM */
+        ::SysFreeString(pwsz);
+#endif /* !VBOX_WITH_XPCOM */
+    }
+}
+
+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 */
+    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 rc = SafeArrayAccessData(psa, &pData);
+    if (FAILED(rc))
+        return rc;
+#endif /* !VBOX_WITH_XPCOM */
+    memcpy(pData, pv, cb);
+#ifndef VBOX_WITH_XPCOM
+    SafeArrayUnaccessData(psa);
+#endif /* !VBOX_WITH_XPCOM */
+    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)
+        return E_INVALIDARG;
+#ifndef VBOX_WITH_XPCOM
+    if (psa->cDims != 1)
+        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 rc = SafeArrayAccessData(psa, &pData);
+    if (FAILED(rc))
+        return rc;
+    cElements = psa->rgsabound[0].cElements;
+#endif /* !VBOX_WITH_XPCOM */
+    size_t cbTotal = cbElement * cElements;
+    void *pv = malloc(cbTotal);
+    if (pv)
+    {
+        memcpy(pv, pData, cbTotal);
+        *ppv = pv;
+        if (pcb)
+            *pcb = (ULONG)cbTotal;
+    }
+#ifndef VBOX_WITH_XPCOM
+    SafeArrayUnaccessData(psa);
+#endif /* !VBOX_WITH_XPCOM */
+    return S_OK;
+}
+
+static HRESULT
+VBoxSafeArrayCopyOutIfaceParamHelper(IUnknown ***ppaObj, ULONG *pcObj, SAFEARRAY *psa)
+{
+    ULONG mypcb;
+    HRESULT rc = VBoxSafeArrayCopyOutParamHelper((void **)ppaObj, &mypcb, VT_UNKNOWN, psa);
+    if (FAILED(rc))
+        return rc;
+    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;
 }
 
@@ -78 +293 @@
                   const char *pszSessionIID, ISession **ppSession)
 {
-    nsresult rc;
-    nsID virtualBoxIID;
-    nsID sessionIID;
+    int vrc;
+    IID virtualBoxIID;
+    IID sessionIID;
 
     *ppSession    = NULL;
     *ppVirtualBox = NULL;
 
-    /* convert the string representation of UUID to nsIID type */
-    if (!(virtualBoxIID.Parse(pszVirtualBoxIID) && sessionIID.Parse(pszSessionIID)))
-        return;
-
-    rc = com::Initialize();
-    if (NS_FAILED(rc))
-    {
-        Log(("Cbinding: XPCOM could not be initialized! rc=%Rhrc\n", rc));
+    /* 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 rc = com::Initialize();
+    if (FAILED(rc))
+    {
+        Log(("Cbinding: COM/XPCOM could not be initialized! rc=%Rhrc\n", rc));
         VBoxComUninitialize();
         return;
     }
 
-    rc = NS_GetComponentManager(&g_Manager);
-    if (NS_FAILED(rc))
+#ifdef VBOX_WITH_XPCOM
+    rc = NS_GetMainEventQ(&g_EventQueue);
+    if (FAILED(rc))
+    {
+        Log(("Cbinding: Could not get XPCOM event queue! rc=%Rhrc\n", rc));
+        VBoxComUninitialize();
+        return;
+    }
+#endif /* VBOX_WITH_XPCOM */
+
+#ifdef VBOX_WITH_XPCOM
+    nsIComponentManager *pManager;
+    rc = NS_GetComponentManager(&pManager);
+    if (FAILED(rc))
     {
         Log(("Cbinding: Could not get component manager! rc=%Rhrc\n", rc));
@@ -105 +346 @@
     }
 
+    rc = pManager->CreateInstanceByContractID(NS_VIRTUALBOX_CONTRACTID,
+                                              nsnull,
+                                              virtualBoxIID,
+                                              (void **)&g_VirtualBox);
+#else /* !VBOX_WITH_XPCOM */
+    rc = CoCreateInstance(CLSID_VirtualBox, NULL, CLSCTX_LOCAL_SERVER, virtualBoxIID, (void **)&g_VirtualBox);
+#endif /* !VBOX_WITH_XPCOM */
+    if (FAILED(rc))
+    {
+        Log(("Cbinding: Could not instantiate VirtualBox object! rc=%Rhrc\n",rc));
+#ifdef VBOX_WITH_XPCOM
+        pManager->Release();
+        pManager = NULL;
+#endif /* VBOX_WITH_XPCOM */
+        VBoxComUninitialize();
+        return;
+    }
+
+    Log(("Cbinding: IVirtualBox object created.\n"));
+
+#ifdef VBOX_WITH_XPCOM
+    rc = pManager->CreateInstanceByContractID(NS_SESSION_CONTRACTID,
+                                              nsnull,
+                                              sessionIID,
+                                              (void **)&g_Session);
+#else /* !VBOX_WITH_XPCOM */
+    rc = CoCreateInstance(CLSID_Session, NULL, CLSCTX_INPROC_SERVER, sessionIID, (void **)&g_Session);
+#endif /* !VBOX_WITH_XPCOM */
+    if (FAILED(rc))
+    {
+        Log(("Cbinding: Could not instantiate Session object! rc=%Rhrc\n",rc));
+#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 rc;
+
+    *ppException = NULL;
+
+#ifdef VBOX_WITH_XPCOM
+    nsIServiceManager *mgr = NULL;
+    rc = NS_GetServiceManager(&mgr);
+    if (FAILED(rc) || !mgr)
+        return rc;
+
+    IID esid = NS_IEXCEPTIONSERVICE_IID;
+    nsIExceptionService *es = NULL;
+    rc = mgr->GetServiceByContractID(NS_EXCEPTIONSERVICE_CONTRACTID, esid, (void **)&es);
+    if (FAILED(rc) || !es)
+    {
+        mgr->Release();
+        return rc;
+    }
+
+    nsIExceptionManager *em;
+    rc = es->GetCurrentExceptionManager(&em);
+    if (FAILED(rc) || !em)
+    {
+        es->Release();
+        mgr->Release();
+        return rc;
+    }
+
+    nsIException *ex;
+    rc = em->GetCurrentException(&ex);
+    if (FAILED(rc))
+    {
+        em->Release();
+        es->Release();
+        mgr->Release();
+        return rc;
+    }
+
+    *ppException = ex;
+    em->Release();
+    es->Release();
+    mgr->Release();
+#else /* !VBOX_WITH_XPCOM */
+    IErrorInfo *ex;
+    rc = ::GetErrorInfo(0, &ex);
+    if (FAILED(rc))
+        return rc;
+
+    *ppException = ex;
+#endif /* !VBOX_WITH_XPCOM */
+
+    return rc;
+}
+
+static HRESULT
+VBoxClearException(void)
+{
+    HRESULT rc;
+
+#ifdef VBOX_WITH_XPCOM
+    nsIServiceManager *mgr = NULL;
+    rc = NS_GetServiceManager(&mgr);
+    if (FAILED(rc) || !mgr)
+        return rc;
+
+    IID esid = NS_IEXCEPTIONSERVICE_IID;
+    nsIExceptionService *es = NULL;
+    rc = mgr->GetServiceByContractID(NS_EXCEPTIONSERVICE_CONTRACTID, esid, (void **)&es);
+    if (FAILED(rc) || !es)
+    {
+        mgr->Release();
+        return rc;
+    }
+
+    nsIExceptionManager *em;
+    rc = es->GetCurrentExceptionManager(&em);
+    if (FAILED(rc) || !em)
+    {
+        es->Release();
+        mgr->Release();
+        return rc;
+    }
+
+    rc = em->SetCurrentException(NULL);
+    em->Release();
+    es->Release();
+    mgr->Release();
+#else /* !VBOX_WITH_XPCOM */
+    rc = ::SetErrorInfo(0, NULL);
+#endif /* !VBOX_WITH_XPCOM */
+
+    return rc;
+}
+
+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 rc = com::Initialize();
+    if (FAILED(rc))
+    {
+        Log(("Cbinding: COM/XPCOM could not be initialized! rc=%Rhrc\n", rc));
+        VBoxClientUninitialize();
+        return rc;
+    }
+
+#ifdef VBOX_WITH_XPCOM
     rc = NS_GetMainEventQ(&g_EventQueue);
     if (NS_FAILED(rc))
     {
-        Log(("Cbinding: Could not get xpcom event queue! rc=%Rhrc\n", rc));
-        VBoxComUninitialize();
-        return;
-    }
-
-    rc = g_Manager->CreateInstanceByContractID(NS_VIRTUALBOX_CONTRACTID,
-                                               nsnull,
-                                               virtualBoxIID,
-                                               (void **)&g_VirtualBox);
-    if (NS_FAILED(rc))
-    {
-        Log(("Cbinding: Could not instantiate VirtualBox object! rc=%Rhrc\n",rc));
-        VBoxComUninitialize();
-        return;
-    }
-
-    Log(("Cbinding: IVirtualBox object created.\n"));
-
-    rc = g_Manager->CreateInstanceByContractID(NS_SESSION_CONTRACTID,
-                                               nsnull,
-                                               sessionIID,
-                                               (void **)&g_Session);
-    if (NS_FAILED(rc))
-    {
-        Log(("Cbinding: Could not instantiate Session object! rc=%Rhrc\n",rc));
-        VBoxComUninitialize();
-        return;
-    }
-
-    Log(("Cbinding: ISession object created.\n"));
-
-    *ppSession = g_Session;
-    *ppVirtualBox = g_VirtualBox;
-}
-
-static void
-VBoxComInitializeV1(IVirtualBox **ppVirtualBox, ISession **ppSession)
-{
-    VBoxComInitialize(IVIRTUALBOX_IID_STR, ppVirtualBox,
-                      ISESSION_IID_STR, ppSession);
-}
-
-static void
-VBoxComUninitialize(void)
-{
-    if (g_Session)
-    {
-        NS_RELEASE(g_Session);
-        g_Session = NULL;
-    }
-    if (g_VirtualBox)
-    {
-        NS_RELEASE(g_VirtualBox);
-        g_VirtualBox = NULL;
-    }
-    if (g_EventQueue)
-    {
-        NS_RELEASE(g_EventQueue);
-        g_EventQueue = NULL;
-    }
-    if (g_Manager)
-    {
-        NS_RELEASE(g_Manager);
-        g_Manager = NULL;
-    }
-    com::Shutdown();
-    Log(("Cbinding: Cleaned up the created objects.\n"));
-}
-
-static void
-VBoxGetEventQueue(nsIEventQueue **ppEventQueue)
-{
-    *ppEventQueue = g_EventQueue;
-}
-
-static nsresult
-VBoxGetException(nsIException **ppException)
-{
-    nsresult rc;
-
-    *ppException = NULL;
-    nsIServiceManager *mgr = NULL;
-    rc = NS_GetServiceManager(&mgr);
-    if (NS_FAILED(rc) || !mgr)
-        return rc;
-
-    nsIID esid = NS_IEXCEPTIONSERVICE_IID;
-    nsIExceptionService *es = NULL;
-    rc = mgr->GetServiceByContractID(NS_EXCEPTIONSERVICE_CONTRACTID, esid, (void **)&es);
-    if (NS_FAILED(rc) || !es)
-    {
-        NS_RELEASE(mgr);
-        return rc;
-    }
-
-    nsIExceptionManager *em;
-    rc = es->GetCurrentExceptionManager(&em);
-    if (NS_FAILED(rc) || !em)
-    {
-        NS_RELEASE(es);
-        NS_RELEASE(mgr);
-        return rc;
-    }
-
-    nsIException *ex;
-    rc = em->GetCurrentException(&ex);
-    if (NS_FAILED(rc))
-    {
-        NS_RELEASE(em);
-        NS_RELEASE(es);
-        NS_RELEASE(mgr);
-        return rc;
-    }
-
-    *ppException = ex;
-    NS_RELEASE(em);
-    NS_RELEASE(es);
-    NS_RELEASE(mgr);
-    return rc;
-}
-
-static nsresult
-VBoxClearException(void)
-{
-    nsresult rc;
-
-    nsIServiceManager *mgr = NULL;
-    rc = NS_GetServiceManager(&mgr);
-    if (NS_FAILED(rc) || !mgr)
-        return rc;
-
-    nsIID esid = NS_IEXCEPTIONSERVICE_IID;
-    nsIExceptionService *es = NULL;
-    rc = mgr->GetServiceByContractID(NS_EXCEPTIONSERVICE_CONTRACTID, esid, (void **)&es);
-    if (NS_FAILED(rc) || !es)
-    {
-        NS_RELEASE(mgr);
-        return rc;
-    }
-
-    nsIExceptionManager *em;
-    rc = es->GetCurrentExceptionManager(&em);
-    if (NS_FAILED(rc) || !em)
-    {
-        NS_RELEASE(es);
-        NS_RELEASE(mgr);
-        return rc;
-    }
-
-    rc = em->SetCurrentException(NULL);
-    NS_RELEASE(em);
-    NS_RELEASE(es);
-    NS_RELEASE(mgr);
-    return rc;
-}
-
-static nsresult
-VBoxClientInitialize(const char *pszVirtualBoxClientIID, IVirtualBoxClient **ppVirtualBoxClient)
-{
-    nsresult rc;
-    nsID virtualBoxClientIID;
-    nsID sessionIID;
-
-    *ppVirtualBoxClient = NULL;
-
-    /* convert the string representation of UUID to nsIID type */
-    if (!virtualBoxClientIID.Parse(pszVirtualBoxClientIID))
-        return NS_ERROR_INVALID_ARG;
-
-    rc = com::Initialize();
-    if (NS_FAILED(rc))
-    {
-        Log(("Cbinding: XPCOM could not be initialized! rc=%Rhrc\n", rc));
+        Log(("Cbinding: Could not get XPCOM event queue! rc=%Rhrc\n", rc));
         VBoxClientUninitialize();
         return rc;
     }
-
+#endif /* VBOX_WITH_XPCOM */
+
+#ifdef VBOX_WITH_XPCOM
     nsIComponentManager *pManager;
     rc = NS_GetComponentManager(&pManager);
-    if (NS_FAILED(rc))
+    if (FAILED(rc))
     {
         Log(("Cbinding: Could not get component manager! rc=%Rhrc\n", rc));
-        VBoxClientUninitialize();
-        return rc;
-    }
-
-    rc = NS_GetMainEventQ(&g_EventQueue);
-    if (NS_FAILED(rc))
-    {
-        Log(("Cbinding: Could not get xpcom event queue! rc=%Rhrc\n", rc));
         VBoxClientUninitialize();
         return rc;
@@ -306 +613 @@
                                               virtualBoxClientIID,
                                               (void **)ppVirtualBoxClient);
-    if (NS_FAILED(rc))
+#else /* !VBOX_WITH_XPCOM */
+    rc = CoCreateInstance(CLSID_VirtualBoxClient, NULL, CLSCTX_INPROC_SERVER, virtualBoxClientIID, (void **)ppVirtualBoxClient);
+#endif /* !VBOX_WITH_XPCOM */
+    if (FAILED(rc))
     {
         Log(("Cbinding: Could not instantiate VirtualBoxClient object! rc=%Rhrc\n",rc));
+#ifdef VBOX_WITH_XPCOM
+        pManager->Release();
+        pManager = NULL;
+#endif /* VBOX_WITH_XPCOM */
         VBoxClientUninitialize();
         return rc;
     }
 
-    NS_RELEASE(pManager);
+#ifdef VBOX_WITH_XPCOM
+    pManager->Release();
     pManager = NULL;
+#endif /* VBOX_WITH_XPCOM */
 
     Log(("Cbinding: IVirtualBoxClient object created.\n"));
 
-    return NS_OK;
+    return S_OK;
+}
+
+static HRESULT
+VBoxClientThreadInitialize(void)
+{
+    return com::Initialize();
+}
+
+static HRESULT
+VBoxClientThreadUninitialize(void)
+{
+    return com::Shutdown();
 }
 
@@ -324 +652 @@
 VBoxClientUninitialize(void)
 {
+#ifdef VBOX_WITH_XPCOM
     if (g_EventQueue)
     {
@@ -329 +658 @@
         g_EventQueue = NULL;
     }
+#endif /* VBOX_WITH_XPCOM */
     com::Shutdown();
     Log(("Cbinding: Cleaned up the created objects.\n"));
@@ -345 +675 @@
 }
 
-VBOXXPCOMC_DECL(PCVBOXXPCOM)
-VBoxGetXPCOMCFunctions(unsigned uVersion)
-{
+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 VBOXXPCOMC s_Functions =
-    {
-        sizeof(VBOXXPCOMC),
-        VBOX_XPCOMC_VERSION,
+    static const VBOXCAPI s_Functions =
+    {
+        sizeof(VBOXCAPI),
+        VBOX_CAPI_VERSION,
 
         VBoxVersion,
@@ -360 +695 @@
 
         VBoxClientInitialize,
+        VBoxClientThreadInitialize,
+        VBoxClientThreadUninitialize,
         VBoxClientUninitialize,
 
@@ -365 +702 @@
         VBoxComUninitialize,
 
-        VBoxComUnallocMem,
+        VBoxComUnallocString,
 
         VBoxUtf16ToUtf8,
@@ -372 +709 @@
         VBoxUtf16Free,
 
+        VBoxSafeArrayCreateVector,
+        VBoxSafeArrayOutParamAlloc,
+        VBoxSafeArrayCopyInParamHelper,
+        VBoxSafeArrayCopyOutParamHelper,
+        VBoxSafeArrayCopyOutIfaceParamHelper,
+        VBoxSafeArrayDestroy,
+
+#ifdef VBOX_WITH_XPCOM
         VBoxGetEventQueue,
+#endif /* VBOX_WITH_XPCOM */
         VBoxGetException,
         VBoxClearException,
-
-        VBOX_XPCOMC_VERSION
+        VBoxProcessEventQueue,
+        VBoxInterruptEventQueueProcessing,
+
+        VBOX_CAPI_VERSION
     };
 
-    if ((uVersion & 0xffff0000U) == (VBOX_XPCOMC_VERSION & 0xffff0000U))
+    if ((uVersion & 0xffff0000U) == (VBOX_CAPI_VERSION & 0xffff0000U))
         return &s_Functions;
 
     /*
-     * Legacy interface version 2.0.
+     * Legacy interface version 3.0.
      */
-    static const struct VBOXXPCOMCV2
+    static const struct VBOXCAPIV3
     {
         /** The size of the structure. */
@@ -394 +742 @@
         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,
@@ -402 +756 @@
 
         void  (*pfnComUnallocMem)(void *pv);
-        void  (*pfnUtf16Free)(PRUnichar *pwszString);
+
+        int   (*pfnUtf16ToUtf8)(CBSTR pwszString, char **ppszString);
+        int   (*pfnUtf8ToUtf16)(const char *pszString, BSTR *ppwszString);
         void  (*pfnUtf8Free)(char *pszString);
-
-        int   (*pfnUtf16ToUtf8)(const PRUnichar *pwszString, char **ppszString);
-        int   (*pfnUtf8ToUtf16)(const char *pszString, PRUnichar **ppwszString);
-
+        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_v2_0 =
-    {
-        sizeof(s_Functions_v2_0),
-        0x00020000U,
+    } s_Functions_v3_0 =
+    {
+        sizeof(s_Functions_v3_0),
+        0x00030000U,
 
         VBoxVersion,
+        VBoxAPIVersion,
+
+        VBoxClientInitialize,
+        VBoxClientUninitialize,
 
         VBoxComInitialize,
@@ -423 +785 @@
 
         VBoxComUnallocMem,
-        VBoxUtf16Free,
-        VBoxUtf8Free,
 
         VBoxUtf16ToUtf8,
         VBoxUtf8ToUtf16,
-
+        VBoxUtf8Free,
+        VBoxUtf16Free,
+
+#ifdef VBOX_WITH_XPCOM
         VBoxGetEventQueue,
-
-        0x00020000U
+#endif /* VBOX_WITH_XPCOM */
+        VBoxGetException,
+        VBoxClearException,
+
+        0x00030000U
     };
 
-    if ((uVersion & 0xffff0000U) == 0x00020000U)
-        return (PCVBOXXPCOM)&s_Functions_v2_0;
+    if ((uVersion & 0xffff0000U) == 0x00030000U)
+        return (PCVBOXCAPI)&s_Functions_v3_0;
 
     /*
-     * Legacy interface version 1.0.
+     * Legacy interface version 2.0.
      */
-    static const struct VBOXXPCOMCV1
+    static const struct VBOXCAPIV2
     {
         /** The size of the structure. */
@@ -449 +815 @@
         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)(PRUnichar *pwszString);
+        void  (*pfnUtf16Free)(BSTR pwszString);
         void  (*pfnUtf8Free)(char *pszString);
 
-        int   (*pfnUtf16ToUtf8)(const PRUnichar *pwszString, char **ppszString);
-        int   (*pfnUtf8ToUtf16)(const char *pszString, PRUnichar **ppwszString);
+        int   (*pfnUtf16ToUtf8)(CBSTR pwszString, char **ppszString);
+        int   (*pfnUtf8ToUtf16)(const char *pszString, BSTR *ppwszString);
 
         /** Tail version, same as uVersion. */
@@ -482 +907 @@
 
     if ((uVersion & 0xffff0000U) == 0x00010000U)
-        return (PCVBOXXPCOM)&s_Functions_v1_0;
+        return (PCVBOXCAPI)&s_Functions_v1_0;
 
     /*
@@ -490 +915 @@
 }
 
+#ifdef VBOX_WITH_XPCOM
+VBOXCAPI_DECL(PCVBOXCAPI)
+VBoxGetXPCOMCFunctions(unsigned uVersion)
+{
+    return VBoxGetCAPIFunctions(uVersion);
+}
+#endif /* VBOX_WITH_XPCOM */
 /* vim: set ts=4 sw=4 et: */

trunk/src/VBox/Main/cbinding/VBoxCAPIGlue.c

@@ -1 +1 @@
 /* $Revision$ */
 /** @file
- * Glue code for dynamically linking to VBoxXPCOMC.
+ * Glue code for dynamically linking to VBoxCAPI.
  */
 
 /*
- * Copyright (C) 2008-2013 Oracle Corporation
+ * Copyright (C) 2008-2014 Oracle Corporation
  *
  * Permission is hereby granted, free of charge, to any person
@@ -32 +32 @@
 *   Header Files                                                               *
 *******************************************************************************/
+#include "VBoxCAPIGlue.h"
+
 #include <stdio.h>
 #include <string.h>
@@ -37 +39 @@
 #include <stdarg.h>
 #include <stdint.h>
-#include <dlfcn.h>
-#include <pthread.h>
-
-#include "VBoxXPCOMCGlue.h"
+#ifndef WIN32
+# include <dlfcn.h>
+# include <pthread.h>
+#else /* WIN32 */
+# include <Windows.h>
+#endif /* WIN32 */
 
 
@@ -47 +51 @@
 *******************************************************************************/
 #if defined(__linux__) || defined(__linux_gnu__) || defined(__sun__) || defined(__FreeBSD__)
-# define DYNLIB_NAME    "VBoxXPCOMC.so"
+# define DYNLIB_NAME        "VBoxXPCOMC.so"
 #elif defined(__APPLE__)
-# define DYNLIB_NAME    "VBoxXPCOMC.dylib"
-#elif defined(_MSC_VER) || defined(__OS2__)
-# define DYNLIB_NAME    "VBoxXPCOMC.dll"
+# define DYNLIB_NAME        "VBoxXPCOMC.dylib"
+#elif defined(__OS2__)
+# define DYNLIB_NAME        "VBoxXPCOMC.dll"
+#elif defined(WIN32)
+# define DYNLIB_NAME        "VBoxCAPI.dll"
+# undef DYNLIB_LEGACY_NAME
 #else
 # error "Port me"
@@ -60 +67 @@
 *   Global Variables                                                           *
 *******************************************************************************/
-/** The dlopen handle for VBoxXPCOMC. */
-void *g_hVBoxXPCOMC = NULL;
+/** 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 VBoxXPCOMC function table. */
-PCVBOXXPCOM g_pVBoxFuncs = NULL;
-/** Pointer to VBoxGetXPCOMCFunctions for the loaded VBoxXPCOMC so/dylib/dll. */
-PFNVBOXGETXPCOMCFUNCTIONS g_pfnGetFunctions = NULL;
+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.
- * In this case this is for helping gdb as it gets hideously
- * confused if the application doesn't drag in pthreads.
- */
-PFNDUMMY g_apfnVBoxXPCOMCGlue[] =
-{
-    (PFNDUMMY)pthread_create
+ * 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
 };
 
@@ -103 +116 @@
 
 /**
- * Try load VBoxXPCOMC.so/dylib/dll from the specified location and resolve all
- * the symbols we need.
+ * 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 director where to try load VBoxXPCOMC from. Can
- *                          be NULL.
+ * @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 tryLoadOne(const char *pszHome, int fSetAppHome)
+static int tryLoadLibrary(const char *pszHome, int fSetAppHome)
 {
     size_t      cchHome = pszHome ? strlen(pszHome) : 0;
     size_t      cbBufNeeded;
     char        szName[4096];
-    int         rc = -1;
 
     /*
@@ -143 +155 @@
     if (fSetAppHome)
     {
+#ifndef WIN32
         if (pszHome)
             setenv("VBOX_APP_HOME", pszHome, 1 /* always override */);
         else
             unsetenv("VBOX_APP_HOME");
-    }
-    g_hVBoxXPCOMC = dlopen(szName, RTLD_NOW | RTLD_LOCAL);
-    if (g_hVBoxXPCOMC)
-    {
-        PFNVBOXGETXPCOMCFUNCTIONS pfnGetFunctions;
-        pfnGetFunctions = (PFNVBOXGETXPCOMCFUNCTIONS)(uintptr_t)
-            dlsym(g_hVBoxXPCOMC, VBOX_GET_XPCOMC_FUNCTIONS_SYMBOL_NAME);
+#endif /* !WIN32 */
+    }
+
+#ifndef WIN32
+    g_hVBoxCAPI = dlopen(szName, RTLD_NOW | RTLD_LOCAL);
+    if (g_hVBoxCAPI)
+    {
+        PFNVBOXGETCAPIFUNCTIONS pfnGetFunctions;
+        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 */
         if (pfnGetFunctions)
         {
-            g_pVBoxFuncs = pfnGetFunctions(VBOX_XPCOMC_VERSION);
+            g_pVBoxFuncs = pfnGetFunctions(VBOX_CAPI_VERSION);
             if (g_pVBoxFuncs)
             {
@@ -165 +186 @@
             /* bail out */
             setErrMsg(1, "%.80s: pfnGetFunctions(%#x) failed",
-                      szName, VBOX_XPCOMC_VERSION);
+                      szName, VBOX_CAPI_VERSION);
         }
         else
             setErrMsg(1, "dlsym(%.80s/%.32s): %.128s",
-                      szName, VBOX_GET_XPCOMC_FUNCTIONS_SYMBOL_NAME, dlerror());
-        dlclose(g_hVBoxXPCOMC);
-        g_hVBoxXPCOMC = NULL;
+                      szName, VBOX_GET_CAPI_FUNCTIONS_SYMBOL_NAME, dlerror());
+        dlclose(g_hVBoxCAPI);
+        g_hVBoxCAPI = NULL;
     }
     else
         setErrMsg(0, "dlopen(%.80s): %.160s", szName, dlerror());
-    return rc;
+#else /* !WIN32 */
+    g_hVBoxCAPI = LoadLibraryExA(szName, NULL /* hFile */, 0 /* dwFlags */);
+    if (g_hVBoxCAPI)
+    {
+        PFNVBOXGETCAPIFUNCTIONS pfnGetFunctions;
+        pfnGetFunctions = (PFNVBOXGETCAPIFUNCTIONS)
+            GetProcAddress(g_hVBoxCAPI, VBOX_GET_CAPI_FUNCTIONS_SYMBOL_NAME);
+        if (pfnGetFunctions)
+        {
+            g_pVBoxFuncs = pfnGetFunctions(VBOX_CAPI_VERSION);
+            if (g_pVBoxFuncs)
+            {
+                g_pfnGetFunctions = pfnGetFunctions;
+                return 0;
+            }
+
+            /* bail out */
+            setErrMsg(1, "%.80s: pfnGetFunctions(%#x) failed",
+                      szName, VBOX_CAPI_VERSION);
+        }
+        else
+            setErrMsg(1, "GetProcAddress(%.80s/%.32s): %d",
+                      szName, VBOX_GET_CAPI_FUNCTIONS_SYMBOL_NAME, GetLastError());
+        FreeLibrary(g_hVBoxCAPI);
+        g_hVBoxCAPI = NULL;
+    }
+    else
+        setErrMsg(0, "LoadLibraryEx(%.80s): %d", szName, GetLastError());
+#endif /* !WIN32 */
+
+    return -1;
 }
 
 
 /**
- * Tries to locate and load VBoxXPCOMC.so/dylib/dll, resolving all the related
+ * Tries to locate and load VBoxCAPI.so/dylib/dll, resolving all the related
  * function pointers.
  *
@@ -186 +237 @@
  *
  * @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 VBoxXPCOMC
+ *          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.
@@ -192 +243 @@
 int VBoxCGlueInit(void)
 {
+    const char *pszHome;
+
+    memset(g_szVBoxErrMsg, 0, sizeof(g_szVBoxErrMsg));
+
     /*
      * If the user specifies the location, try only that.
      */
-    const char *pszHome = getenv("VBOX_APP_HOME");
+    pszHome = getenv("VBOX_APP_HOME");
     if (pszHome)
-        return tryLoadOne(pszHome, 0);
+        return tryLoadLibrary(pszHome, 0);
 
     /*
      * Try the known standard locations.
      */
-    g_szVBoxErrMsg[0] = '\0';
 #if defined(__gnu__linux__) || defined(__linux__)
-    if (tryLoadOne("/opt/VirtualBox", 1) == 0)
-        return 0;
-    if (tryLoadOne("/usr/lib/virtualbox", 1) == 0)
+    if (tryLoadLibrary("/opt/VirtualBox", 1) == 0)
+        return 0;
+    if (tryLoadLibrary("/usr/lib/virtualbox", 1) == 0)
         return 0;
 #elif defined(__sun__)
-    if (tryLoadOne("/opt/VirtualBox/amd64", 1) == 0)
-        return 0;
-    if (tryLoadOne("/opt/VirtualBox/i386", 1) == 0)
+    if (tryLoadLibrary("/opt/VirtualBox/amd64", 1) == 0)
+        return 0;
+    if (tryLoadLibrary("/opt/VirtualBox/i386", 1) == 0)
         return 0;
 #elif defined(__APPLE__)
-    if (tryLoadOne("/Application/VirtualBox.app/Contents/MacOS", 1) == 0)
+    if (tryLoadLibrary("/Application/VirtualBox.app/Contents/MacOS", 1) == 0)
         return 0;
 #elif defined(__FreeBSD__)
-    if (tryLoadOne("/usr/local/lib/virtualbox", 1) == 0)
+    if (tryLoadLibrary("/usr/local/lib/virtualbox", 1) == 0)
         return 0;
 #elif defined(__OS2__)
-    if (tryLoadOne("C:/Apps/VirtualBox", 1) == 0)
+    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
@@ -229 +301 @@
      * Finally try the dynamic linker search path.
      */
-    if (tryLoadOne(NULL, 1) == 0)
+    if (tryLoadLibrary(NULL, 1) == 0)
         return 0;
 
@@ -242 +314 @@
 void VBoxCGlueTerm(void)
 {
-    if (g_hVBoxXPCOMC)
+    if (g_hVBoxCAPI)
     {
 #if 0 /* VBoxRT.so doesn't like being reloaded. See @bugref{3725}. */
-        dlclose(g_hVBoxXPCOMC);
+#ifndef WIN32
+        dlclose(g_hVBoxCAPI);
+#else
+        FreeLibrary(g_hVBoxCAPI);
 #endif
-        g_hVBoxXPCOMC = NULL;
+#endif
+        g_hVBoxCAPI = NULL;
     }
     g_pVBoxFuncs = NULL;

trunk/src/VBox/Main/cbinding/VBoxCAPIGlue.h.in

@@ -1 +1 @@
 /* $Revision$ */
-/** @file VBoxXPCOMCGlue.h
- * Glue for dynamically linking with VBoxXPCOMC.
+/** @file VBoxCAPIGlue.h
+ * Glue for dynamically linking with VBoxCAPI.
  */
 
 /*
- * Copyright (C) 2008-2012 Oracle Corporation
+ * Copyright (C) 2008-2014 Oracle Corporation
  *
  * Permission is hereby granted, free of charge, to any person
@@ -29 +29 @@
  */
 
-#ifndef ___VBoxXPCOMC_cglue_h
-#define ___VBoxXPCOMC_cglue_h
+#ifndef ___VBoxCAPIGlue_h
+#define ___VBoxCAPIGlue_h
 
+#undef VBOX_WITH_GLUE
+#define VBOX_WITH_GLUE
 #include "VBoxCAPI_v@[email protected]"
 
@@ -38 +40 @@
 #endif
 
-/** The dlopen handle for VBoxXPCOMC. */
-extern void *g_hVBoxXPCOMC;
+/** 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 VBoxXPCOMC function table. */
-extern PCVBOXXPCOM g_pVBoxFuncs;
-/** Pointer to VBoxGetXPCOMCFunctions for the loaded VBoxXPCOMC so/dylib/dll. */
-extern PFNVBOXGETXPCOMCFUNCTIONS g_pfnGetFunctions;
+/** Pointer to the VBOXCAPI function table. */
+extern PCVBOXCAPI g_pVBoxFuncs;
+/** Pointer to VBoxGetCAPIFunctions for the loaded VBoxCAPI so/dylib/dll. */
+extern PFNVBOXGETCAPIFUNCTIONS g_pfnGetFunctions;
 
 

trunk/src/VBox/Main/cbinding/capiidl.xsl

@@ -3 +3 @@
 
 <!--
- *  A template to generate a XPCOM IDL compatible interface definition file
- *  from the generic interface definition expressed in XML.
-
-    Copyright (C) 2008-2013 Oracle Corporation
+ *  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-2014 Oracle Corporation
 
     This file is part of VirtualBox Open Source Edition (OSE), as
@@ -100 +102 @@
 -->
 <xsl:template match="/idl">
-  <xsl:text>
-/*
+  <xsl:text>/*
  *  DO NOT EDIT! This is a generated file.
  *
- *  XPCOM IDL (XPIDL) definition for VirtualBox Main API (COM interfaces)
- *  generated from XIDL (XML interface definition).
+ *  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/idl/xpcidl.xsl
+ *  Generator : src/VBox/Main/cbinding/capiidl.xsl
  *
  *  This file contains portions from the following Mozilla XPCOM files:
@@ -121 +124 @@
 
 /*
- * Copyright (C) 2008-2012 Oracle Corporation
+ * Copyright (C) 2008-2014 Oracle Corporation
  *
  * This file is part of a free software library; you can redistribute
@@ -140 +143 @@
  */
 
-#ifndef ___VirtualBox_CXPCOM_h
-#define ___VirtualBox_CXPCOM_h
+#ifndef ___VirtualBox_CAPI_h
+#define ___VirtualBox_CAPI_h
+
+#ifdef _WIN32
+# undef COBJMACROS
+# define COBJMACROS
+# include "Windows.h"
+#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
-# include "VirtualBox_XPCOM.h"
-#else /* !__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"
+
+typedef const BSTR CBSTR;
+
+#define ComSafeArrayAsInParam(f) (f)
+#define ComSafeArrayAsOutParam(f) (&amp;(f))
+#define ComSafeArrayAsOutIfaceParam(f) (&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)
@@ -361 +419 @@
 typedef PRUint16 PRUnichar;
 #endif
+typedef PRUnichar *BSTR;
+typedef const PRUnichar *CBSTR;
 #endif
 
@@ -721 +781 @@
 #define NS_ERROR_FACTORY_EXISTS            (NS_ERROR_BASE + 0x100)
 
-
 /**
  * An "interface id" which can be used to uniquely identify a given
@@ -729 +788 @@
 
 struct nsID {
-  PRUint32 m0;
-  PRUint16 m1;
-  PRUint16 m2;
-  PRUint8 m3[8];
+    PRUint32 m0;
+    PRUint16 m1;
+    PRUint16 m2;
+    PRUint8 m3[8];
 };
 
 typedef struct nsID nsID;
 typedef nsID nsIID;
+typedef nsID nsCID;
+
+#endif /* __cplusplus */
+
+
+/* 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)->c), ((f)->pv)
+#define ComSafeArrayAsOutParam(f) (&amp;((f)->c)), (&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
+
+#ifndef __cplusplus
 
 struct nsISupports;   /* forward declaration */
@@ -745 +878 @@
 typedef struct nsIException nsIException;   /* forward declaration */
 
-/**
- * IID for the nsISupports interface
- * {00000000-0000-0000-c000-000000000046}
- *
- * To maintain binary compatibility with COM's IUnknown, we define the IID
- * of nsISupports to be the same as that of COM's IUnknown.
- */
-#define NS_ISUPPORTS_IID                                                      \
-  { 0x00000000, 0x0000, 0x0000,                                               \
-    {0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46} }
+/* 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} }
 
 /**
@@ -764 +893 @@
  * IUnknown.
  */
+#if defined(XP_WIN) &amp;&amp; PR_BYTES_PER_LONG == 4
+typedef unsigned long nsrefcnt;
+#else
+typedef PRUint32 nsrefcnt;
+#endif
 
 /**
@@ -771 +905 @@
  * modelled after the win32 IUnknown API.
  */
-struct nsISupports_vtbl {
-
-  /**
-   * @name Methods
-   */
-
-  /**
-   * A run time mechanism for interface discovery.
-   * @param aIID         [in]  A requested interface IID
-   * @param aInstancePtr [out] A pointer to an interface pointer to
-   *                           receive the result.
-   * @return            NS_OK if the interface is supported by the associated
-   *                          instance, NS_NOINTERFACE if it is not.
-   * NS_ERROR_INVALID_POINTER if aInstancePtr is NULL.
-   */
-  nsresult (*QueryInterface)(nsISupports *pThis, const nsID *iid, void **resultp);
-  /**
-   * Increases the reference count for this interface.
-   * The associated instance will not be deleted unless
-   * the reference count is returned to zero.
-   *
-   * @return The resulting reference count.
-   */
-  nsresult (*AddRef)(nsISupports *pThis);
-
-  /**
-   * Decreases the reference count for this interface.
-   * Generally, if the reference count returns to zero,
-   * the associated instance is deleted.
-   *
-   * @return The resulting reference count.
-   */
-  nsresult (*Release)(nsISupports *pThis);
-
+#ifndef VBOX_WITH_GLUE
+struct nsISupports_vtbl
+{
+    nsresult (*QueryInterface)(nsISupports *pThis, const nsID *iid, void **resultp);
+    nsrefcnt (*AddRef)(nsISupports *pThis);
+    nsrefcnt (*Release)(nsISupports *pThis);
 };
-
-struct nsISupports {
+#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 */
+
+struct nsISupports
+{
+#ifndef VBOX_WITH_GLUE
     struct nsISupports_vtbl *vtbl;
+#else /* !VBOX_WITH_GLUE */
+    struct nsISupportsVtbl *lpVtbl;
+#endif /* !VBOX_WITH_GLUE */
 };
 
@@ -815 +943 @@
 
 #define NS_IEXCEPTION_IID \
-  {0xf3a8d3b4, 0xc424, 0x4edc, \
-    { 0x8b, 0xf6, 0x89, 0x74, 0xc9, 0x83, 0xba, 0x78 }}
-
-struct nsIException_vtbl {
-
-  /* Methods from the Class nsISupports */
-  struct nsISupports_vtbl nsisupports;
-
-  /* readonly attribute string message; */
-  nsresult (*GetMessage)(nsIException *pThis, PRUnichar * *aMessage);
-
-  /* readonly attribute nsresult (*result; */
-  nsresult (*GetResult)(nsIException *pThis, nsresult *aResult);
-
-  /* readonly attribute string name; */
-  nsresult (*GetName)(nsIException *pThis, PRUnichar * *aName);
-
-  /* readonly attribute string filename; */
-  nsresult (*GetFilename)(nsIException *pThis, PRUnichar * *aFilename);
-
-  /* readonly attribute PRUint32 lineNumber; */
-  nsresult (*GetLineNumber)(nsIException *pThis, PRUint32 *aLineNumber);
-
-  /* readonly attribute PRUint32 columnNumber; */
-  nsresult (*GetColumnNumber)(nsIException *pThis, PRUint32 *aColumnNumber);
-
-  /* readonly attribute nsIStackFrame location; */
-  nsresult (*GetLocation)(nsIException *pThis, nsIStackFrame * *aLocation);
-
-  /* readonly attribute nsIException inner; */
-  nsresult (*GetInner)(nsIException *pThis, nsIException * *aInner);
-
-  /* readonly attribute nsISupports data; */
-  nsresult (*GetData)(nsIException *pThis, nsISupports * *aData);
-
-  /* string toString (); */
-  nsresult (*ToString)(nsIException *pThis, PRUnichar **_retval);
+    {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);
 };
-
-struct nsIException {
+#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 */
+
+struct nsIException
+{
+#ifndef VBOX_WITH_GLUE
     struct nsIException_vtbl *vtbl;
+#else /* !VBOX_WITH_GLUE */
+    struct nsIExceptionVtbl *lpVtbl;
+#endif /* !VBOX_WITH_GLUE */
 };
 
@@ -862 +1036 @@
 
 #define NS_ISTACKFRAME_IID \
-  {0x91d82105, 0x7c62, 0x4f8b, \
-    { 0x97, 0x79, 0x15, 0x42, 0x77, 0xc0, 0xee, 0x90 }}
-
-struct nsIStackFrame_vtbl {
-
-  /* Methods from the Class nsISupports */
-  struct nsISupports_vtbl nsisupports;
-
-  /* readonly attribute PRUint32 language; */
-  nsresult (*GetLanguage)(nsIStackFrame *pThis, PRUint32 *aLanguage);
-
-  /* readonly attribute string languageName; */
-  nsresult (*GetLanguageName)(nsIStackFrame *pThis, PRUnichar * *aLanguageName);
-
-  /* readonly attribute string filename; */
-  nsresult (*GetFilename)(nsIStackFrame *pThis, PRUnichar * *aFilename);
-
-  /* readonly attribute string name; */
-  nsresult (*GetName)(nsIStackFrame *pThis, PRUnichar * *aName);
-
-  /* readonly attribute PRInt32 lineNumber; */
-  nsresult (*GetLineNumber)(nsIStackFrame *pThis, PRInt32 *aLineNumber);
-
-  /* readonly attribute string sourceLine; */
-  nsresult (*GetSourceLine)(nsIStackFrame *pThis, PRUnichar * *aSourceLine);
-
-  /* readonly attribute nsIStackFrame caller; */
-  nsresult (*GetCaller)(nsIStackFrame *pThis, nsIStackFrame * *aCaller);
-
-  /* string toString (); */
-  nsresult (*ToString)(nsIStackFrame *pThis, PRUnichar **_retval);
+    {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);
 };
-
-struct nsIStackFrame {
+#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 */
+
+struct nsIStackFrame
+{
+#ifndef VBOX_WITH_GLUE
     struct nsIStackFrame_vtbl *vtbl;
+#else /* !VBOX_WITH_GLUE */
+    struct nsIStackFrameVtbl *lpVtbl;
+#endif /* !VBOX_WITH_GLUE */
 };
 
@@ -903 +1103 @@
 
 #define NS_IEVENTTARGET_IID \
-  {0xea99ad5b, 0xcc67, 0x4efb, \
-    { 0x97, 0xc9, 0x2e, 0xf6, 0x20, 0xa5, 0x9f, 0x2a }}
+    {0xea99ad5b, 0xcc67, 0x4efb, \
+      { 0x97, 0xc9, 0x2e, 0xf6, 0x20, 0xa5, 0x9f, 0x2a }}
 
 struct nsIEventTarget;
 typedef struct nsIEventTarget nsIEventTarget;
 
-struct nsIEventTarget_vtbl {
-
+#ifndef VBOX_WITH_GLUE
+struct nsIEventTarget_vtbl
+{
     struct nsISupports_vtbl nsisupports;
 
     nsresult (*PostEvent)(nsIEventTarget *pThis, PLEvent * aEvent);
-
     nsresult (*IsOnCurrentThread)(nsIEventTarget *pThis, PRBool *_retval);
-
 };
-
-struct nsIEventTarget {
+#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 */
+
+struct nsIEventTarget
+{
+#ifndef VBOX_WITH_GLUE
     struct nsIEventTarget_vtbl *vtbl;
+#else /* !VBOX_WITH_GLUE */
+    struct nsIEventTargetVtbl *lpVtbl;
+#endif /* !VBOX_WITH_GLUE */
 };
 
@@ -933 +1153 @@
 typedef struct nsIEventQueue nsIEventQueue;
 
-struct nsIEventQueue_vtbl {
-
+#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);
-
 };
-
-struct nsIEventQueue {
+#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 */
+
+struct nsIEventQueue
+{
+#ifndef VBOX_WITH_GLUE
     struct nsIEventQueue_vtbl *vtbl;
+#else /* !VBOX_WITH_GLUE */
+    struct nsIEventQueueVtbl *lpVtbl;
+#endif /* !VBOX_WITH_GLUE */
 };
 
 </xsl:text>
  <xsl:apply-templates/>
-<xsl:text>
-#endif /* !__cplusplus */
-
-#ifdef IN_VBOXXPCOMC
-# define VBOXXPCOMC_DECL(type)  PR_EXPORT(type)
-#else
-# define VBOXXPCOMC_DECL(type)  PR_IMPORT(type)
-#endif
+ <xsl:text>
+
+#endif /* __cplusplus */
+
+#endif /* !WIN32 */
 
 #ifdef __cplusplus
-extern "C" {
-#endif
+extern "C"
+{
+#endif /* __cplusplus */
 
 
 /**
  * Function table for dynamic linking.
- * Use VBoxGetFunctions() to obtain the pointer to it.
+ * Use VBoxGetCAPIFunctions() to obtain the pointer to it.
  */
-typedef struct VBOXXPCOMC
+typedef struct VBOXCAPI
 {
     /** The size of the structure. */
@@ -1032 +1291 @@
      * @param pszVirtualBoxClientIID    pass IVIRTUALBOXCLIENT_IID_STR
      * @param ppVirtualBoxClient        output parameter for VirtualBoxClient
-     *              reference, handled as usual with XPCOM.
-     * @returns XPCOM error code
+     *              reference, handled as usual with COM/XPCOM.
+     * @returns COM/XPCOM error code
      */
-    nsresult (*pfnClientInitialize)(const char *pszVirtualBoxClientIID,
-                                    IVirtualBoxClient **ppVirtualBoxClient);
+    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.
@@ -1077 +1354 @@
 
     /**
-     * Free memory managed by XPCOM.
-     *
-     * @param pv        pointer to memory block to be freed
+     * Free string managed by COM/XPCOM.
+     *
+     * @param pwsz          pointer to string to be freed
      */
-    void  (*pfnComUnallocMem)(void *pv);
+    void  (*pfnComUnallocString)(BSTR pwsz);
+#ifndef WIN32
+    /** Legacy function, was always for freeing strings only. */
+#define pfnComUnallocMem(pv) pfnComUnallocString((BSTR)(pv))
+#endif /* !WIN32 */
 
     /**
@@ -1090 +1371 @@
      * @returns IPRT status code
      */
-    int   (*pfnUtf16ToUtf8)(const PRUnichar *pwszString, char **ppszString);
+    int   (*pfnUtf16ToUtf8)(CBSTR pwszString, char **ppszString);
     /**
      * Convert string from UTF-8 encoding to UTF-16 encoding.
@@ -1098 +1379 @@
      * @returns IPRT status code
      */
-    int   (*pfnUtf8ToUtf16)(const char *pszString, PRUnichar **ppwszString);
+    int   (*pfnUtf8ToUtf16)(const char *pszString, BSTR *ppwszString);
     /**
      * Free memory returned by pfnUtf16ToUtf8. Do not use for anything else.
@@ -1110 +1391 @@
      * @param pwszString    string to be freed.
      */
-    void  (*pfnUtf16Free)(PRUnichar *pwszString);
+    void  (*pfnUtf16Free)(BSTR pwszString);
 
     /**
-     * Get main XPCOM event queue.
+     * 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 free().
+     * @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 free(). 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 for getting the data
+     * @returns COM/XPCOM error code
+     */
+    HRESULT (*pfnSafeArrayDestroy)(SAFEARRAY *psa);
+
+#ifndef WIN32
+    /**
+     * Get XPCOM event queue. Deprecated!
      *
      * @param ppEventQueue      output parameter for nsIEventQueue reference,
@@ -1119 +1461 @@
      */
     void  (*pfnGetEventQueue)(nsIEventQueue **ppEventQueue);
+#endif /* !WIN32 */
 
     /**
-     * Get current XPCOM exception.
-     *
-     * @param ppException       output parameter for nsIException reference,
+     * 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 XPCOM call.
-     * @returns XPCOM error code
+     *              a previous COM/XPCOM call.
+     * @returns COM/XPCOM error code
      */
-    nsresult (*pfnGetException)(nsIException **ppException);
+    HRESULT (*pfnGetException)(IErrorInfo **ppException);
     /**
-     * Clears current XPCOM exception.
-     *
-     * @returns XPCOM error code
+     * Clears current COM/XPCOM exception.
+     *
+     * @returns COM/XPCOM error code
      */
-    nsresult (*pfnClearException)(void);
+    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);
 
     /** Tail version, same as uVersion. */
     unsigned uEndVersion;
-} VBOXXPCOMC;
-/** Pointer to a const VBoxXPCOMC function table. */
-typedef VBOXXPCOMC const *PCVBOXXPCOM;
+} 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 */
 
 /** The current interface version.
- * For use with VBoxGetXPCOMCFunctions and to be found in
- * VBOXXPCOMC::uVersion. */
-#define VBOX_XPCOMC_VERSION     0x00030000U
-
-VBOXXPCOMC_DECL(PCVBOXXPCOM) VBoxGetXPCOMCFunctions(unsigned uVersion);
-/** Typedef for VBoxGetXPCOMCFunctions. */
-typedef PCVBOXXPCOM (*PFNVBOXGETXPCOMCFUNCTIONS)(unsigned uVersion);
-
-/** The symbol name of VBoxGetXPCOMCFunctions. */
-#if defined(__OS2__)
-# define VBOX_GET_XPCOMC_FUNCTIONS_SYMBOL_NAME   "_VBoxGetXPCOMCFunctions"
-#else
-# define VBOX_GET_XPCOMC_FUNCTIONS_SYMBOL_NAME   "VBoxGetXPCOMCFunctions"
-#endif
+ * For use with VBoxGetCAPIFunctions and to be found in VBOXCAPI::uVersion. */
+#define VBOX_CAPI_VERSION 0x00040000U
+
+#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
-
-#endif /* !___VirtualBox_CXPCOM_h */
+#endif /* __cplusplus */
+
+#endif /* !___VirtualBox_CAPI_h */
 </xsl:text>
 </xsl:template>
@@ -1169 +1579 @@
 <!--
  *  ignore all |if|s except those for XPIDL target
+-->
 <xsl:template match="if">
   <xsl:if test="@target='xpidl'">
@@ -1185 +1596 @@
 </xsl:template>
 
--->
-
-<!--
- *  cpp_quote
-<xsl:template match="cpp">
-  <xsl:if test="text()">
-    <xsl:text>%{C++</xsl:text>
-    <xsl:value-of select="text()"/>
-    <xsl:text>&#x0A;%}&#x0A;&#x0A;</xsl:text>
-  </xsl:if>
-  <xsl:if test="not(text()) and @line">
-    <xsl:text>%{C++&#x0A;</xsl:text>
-    <xsl:value-of select="@line"/>
-    <xsl:text>&#x0A;%}&#x0A;&#x0A;</xsl:text>
-  </xsl:if>
-</xsl:template>
--->
-
-
-<!--
- *  #if statement (@if attribute)
- *  @note
- *      xpidl doesn't support any preprocessor defines other than #include
- *      (it just ignores them), so the generated IDL will most likely be
- *      invalid. So for now we forbid using @if attributes
--->
-<xsl:template match="@if" mode="begin">
-  <xsl:message terminate="yes">
-    @if attributes are not currently allowed because xpidl lacks
-    support for #ifdef and stuff.
-  </xsl:message>
-  <xsl:text>#if </xsl:text>
-  <xsl:value-of select="."/>
-  <xsl:text>&#x0A;</xsl:text>
-</xsl:template>
-<xsl:template match="@if" mode="end">
-  <xsl:text>#endif&#x0A;</xsl:text>
-</xsl:template>
-
 
 <!--
@@ -1236 +1608 @@
   <xsl:text>&#x0A;&#x0A;</xsl:text>
   <!-- forward declarations -->
-  <xsl:apply-templates select="if | interface" mode="forward"/>
+  <xsl:apply-templates select="interface | if/interface" mode="forward"/>
   <xsl:text>&#x0A;</xsl:text>
   <!-- typedef'ing the struct declarations -->
-  <xsl:apply-templates select="if | interface" mode="typedef"/>
+  <xsl:apply-templates select="interface | if/interface" mode="typedef"/>
   <xsl:text>&#x0A;</xsl:text>
   <!-- all enums go first -->
@@ -1263 +1635 @@
 -->
 <xsl:template match="interface" mode="forward">
-  <xsl:text>struct </xsl:text>
-  <xsl:value-of select="@name"/>
-  <xsl:text>;&#x0A;</xsl:text>
+  <xsl:if test="not(@internal='yes')">
+    <xsl:text>struct </xsl:text>
+    <xsl:value-of select="@name"/>
+    <xsl:text>;&#x0A;</xsl:text>
+  </xsl:if>
 </xsl:template>
 
@@ -1273 +1647 @@
 -->
 <xsl:template match="interface" mode="typedef">
-  <xsl:text>typedef struct </xsl:text>
-  <xsl:value-of select="@name"/>
-  <xsl:text> </xsl:text>
-  <xsl:value-of select="@name"/>
-  <xsl:text>;&#x0A;</xsl:text>
+  <xsl:if test="not(@internal='yes')">
+    <xsl:text>typedef struct </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="//interface[@name=$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="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="//interface[@name=$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>
+  <!-- methods -->
+  <xsl:apply-templates select="method | if/method">
+    <xsl:with-param name="iface" select="$iface"/>
+  </xsl:apply-templates>
 </xsl:template>
 
@@ -1285 +1842 @@
 -->
 <xsl:template match="interface">
-  <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="uppercase">
-    <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="uppercase">
-    <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>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='$dispatched'">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="lowercase">
-        <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"/>
-  <!-- methods -->
-  <xsl:apply-templates select="method"/>
-  <!-- 'if' enclosed elements, unsorted -->
-  <xsl:apply-templates select="if"/>
-  <!-- -->
-  <xsl:text>};</xsl:text>
-  <xsl:text>&#x0A;&#x0A;</xsl:text>
-  <xsl:text>struct </xsl:text>
-  <xsl:value-of select="@name"/>
-  <xsl:text>&#x0A;{&#x0A;    struct </xsl:text>
-  <xsl:value-of select="@name"/>
-  <xsl:text>_vtbl *vtbl;&#x0A;};&#x0A;</xsl:text>
-  <xsl:text>/* End of struct </xsl:text>
-  <xsl:value-of select="@name"/>
-  <xsl:text> Declaration */&#x0A;&#x0A;&#x0A;</xsl:text>
+  <xsl:if test="not(@internal='yes')">
+    <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="uppercase">
+      <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="uppercase">
+      <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="lowercase">
+          <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"/>
+    <!-- methods -->
+    <xsl:apply-templates select="method | if/method"/>
+    <!-- -->
+    <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>struct </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>    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;&#x0A;</xsl:text>
+  </xsl:if>
 </xsl:template>
 
@@ -1354 +1936 @@
  *  attributes
 -->
-<xsl:template match="interface//attribute">
-  <xsl:apply-templates select="@if" mode="begin"/>
-  <xsl:if test="@mod='ptr'">
-    <!-- attributes using native types must be non-scriptable
-    <xsl:text>    [noscript]&#x0A;</xsl:text>-->
-  </xsl:if>
+<xsl:template match="attribute">
+  <xsl:param name="iface" select="ancestor::interface/@name"/>
+
   <xsl:choose>
     <!-- safearray pseudo attribute -->
@@ -1369 +1948 @@
       </xsl:call-template>
       <xsl:text>)(</xsl:text>
-      <xsl:value-of select="../@name" />
+      <xsl:value-of select="$iface" />
       <xsl:text> *pThis, </xsl:text>
       <!-- array size -->
@@ -1387 +1966 @@
         </xsl:call-template>
         <xsl:text>)(</xsl:text>
-        <xsl:value-of select="../@name" />
+        <xsl:value-of select="$iface" />
         <xsl:text> *pThis, </xsl:text>
         <!-- array size -->
@@ -1409 +1988 @@
         </xsl:call-template>
         <xsl:text>)(</xsl:text>
-        <xsl:value-of select="../@name" />
+        <xsl:value-of select="$iface" />
         <xsl:text> *pThis, </xsl:text>
         <xsl:apply-templates select="@type" mode="forwarder"/>
@@ -1425 +2004 @@
           </xsl:call-template>
           <xsl:text>)(</xsl:text>
-          <xsl:value-of select="../@name" />
+          <xsl:value-of select="$iface" />
           <xsl:text> *pThis, </xsl:text>
           <xsl:apply-templates select="@type" mode="forwarder"/>
@@ -1436 +2015 @@
           </xsl:call-template>
           <xsl:text>)(</xsl:text>
-          <xsl:value-of select="../@name" />
+          <xsl:value-of select="$iface" />
           <xsl:text> *pThis, </xsl:text>
           <xsl:apply-templates select="@type" mode="forwarder"/>
@@ -1446 +2025 @@
     </xsl:otherwise>
   </xsl:choose>
-  <xsl:apply-templates select="@if" mode="end"/>
   <xsl:text>&#x0A;</xsl:text>
 </xsl:template>
 
-<xsl:template match="interface//attribute" mode="forwarder">
-
-  <xsl:variable name="parent" select="ancestor::interface"/>
-
-  <xsl:apply-templates select="@if" mode="begin"/>
-
-  <!-- getter: COM_FORWARD_Interface_GETTER_Name_TO(smth) -->
-  <xsl:text>#define COM_FORWARD_</xsl:text>
-  <xsl:value-of select="$parent/@name"/>
-  <xsl:text>_GETTER_</xsl:text>
+<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>_TO(smth) NS_IMETHOD Get</xsl:text>
+  <xsl:text>(p, a</xsl:text>
   <xsl:call-template name="capitalize">
     <xsl:with-param name="str" select="@name"/>
   </xsl:call-template>
-  <xsl:text> (</xsl:text>
-  <xsl:if test="@safearray='yes'">
-    <xsl:text>PRUint32 * a</xsl:text>
+  <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, '_set_')"/>
     <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="@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:text>) { return smth Get</xsl:text>
-  <xsl:call-template name="capitalize">
-    <xsl:with-param name="str" select="@name"/>
-  </xsl:call-template>
-  <xsl:text> (</xsl:text>
-  <xsl:if test="@safearray='yes'">
-    <xsl:text>a</xsl:text>
+    <xsl:text>(p, 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:text>a</xsl:text>
-  <xsl:call-template name="capitalize">
-    <xsl:with-param name="str" select="@name"/>
-  </xsl:call-template>
-  <xsl:text>); }&#x0A;</xsl:text>
-  <!-- getter: COM_FORWARD_Interface_GETTER_Name_TO_OBJ(obj) -->
-  <xsl:text>#define COM_FORWARD_</xsl:text>
-  <xsl:value-of select="$parent/@name"/>
-  <xsl:text>_GETTER_</xsl:text>
-  <xsl:call-template name="capitalize">
-    <xsl:with-param name="str" select="@name"/>
-  </xsl:call-template>
-  <xsl:text>_TO_OBJ(obj) COM_FORWARD_</xsl:text>
-  <xsl:value-of select="$parent/@name"/>
-  <xsl:text>_GETTER_</xsl:text>
-  <xsl:call-template name="capitalize">
-    <xsl:with-param name="str" select="@name"/>
-  </xsl:call-template>
-  <xsl:text>_TO ((obj)->)&#x0A;</xsl:text>
-  <!-- getter: COM_FORWARD_Interface_GETTER_Name_TO_BASE(base) -->
-  <xsl:text>#define COM_FORWARD_</xsl:text>
-  <xsl:value-of select="$parent/@name"/>
-  <xsl:text>_GETTER_</xsl:text>
-  <xsl:call-template name="capitalize">
-    <xsl:with-param name="str" select="@name"/>
-  </xsl:call-template>
-  <xsl:text>_TO_BASE(base) COM_FORWARD_</xsl:text>
-  <xsl:value-of select="$parent/@name"/>
-  <xsl:text>_GETTER_</xsl:text>
-  <xsl:call-template name="capitalize">
-    <xsl:with-param name="str" select="@name"/>
-  </xsl:call-template>
-  <xsl:text>_TO (base::)&#x0A;</xsl:text>
-  <!-- -->
-  <xsl:if test="not(@readonly='yes')">
-    <!-- setter: COM_FORWARD_Interface_SETTER_Name_TO(smth) -->
-    <xsl:text>#define COM_FORWARD_</xsl:text>
-    <xsl:value-of select="$parent/@name"/>
-    <xsl:text>_SETTER_</xsl:text>
+    <xsl:text>) ((p)->lpVtbl->Set</xsl:text>
     <xsl:call-template name="capitalize">
       <xsl:with-param name="str" select="@name"/>
     </xsl:call-template>
-    <xsl:text>_TO(smth) NS_IMETHOD Set</xsl:text>
+    <xsl:text>(p, a</xsl:text>
     <xsl:call-template name="capitalize">
       <xsl:with-param name="str" select="@name"/>
     </xsl:call-template>
-    <xsl:text> (</xsl:text>
-    <xsl:if test="@safearray='yes'">
-      <xsl:text>PRUint32 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:if test="not(@safearray='yes') and (@type='string' or @type='wstring')">
-      <xsl:text>const </xsl:text>
-    </xsl:if>
-    <xsl:apply-templates select="@type" mode="forwarder"/>
-    <xsl:if test="@safearray='yes'">
-      <xsl:text> *</xsl:text>
-    </xsl:if>
-    <xsl:text> a</xsl:text>
+    <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>) { return smth Set</xsl:text>
+    <xsl:text>(p, a</xsl:text>
     <xsl:call-template name="capitalize">
       <xsl:with-param name="str" select="@name"/>
     </xsl:call-template>
-    <xsl:text> (a</xsl:text>
+    <xsl:text>) ((p)->lpVtbl->Set</xsl:text>
     <xsl:call-template name="capitalize">
       <xsl:with-param name="str" select="@name"/>
     </xsl:call-template>
-    <xsl:text>); }&#x0A;</xsl:text>
-    <!-- setter: COM_FORWARD_Interface_SETTER_Name_TO_OBJ(obj) -->
-    <xsl:text>#define COM_FORWARD_</xsl:text>
-    <xsl:value-of select="$parent/@name"/>
-    <xsl:text>_SETTER_</xsl:text>
+    <xsl:text>(p, a</xsl:text>
     <xsl:call-template name="capitalize">
       <xsl:with-param name="str" select="@name"/>
     </xsl:call-template>
-    <xsl:text>_TO_OBJ(obj) COM_FORWARD_</xsl:text>
-    <xsl:value-of select="$parent/@name"/>
-    <xsl:text>_SETTER_</xsl:text>
-    <xsl:call-template name="capitalize">
-      <xsl:with-param name="str" select="@name"/>
-    </xsl:call-template>
-    <xsl:text>_TO ((obj)->)&#x0A;</xsl:text>
-    <!-- setter: COM_FORWARD_Interface_SETTER_Name_TO_BASE(base) -->
-    <xsl:text>#define COM_FORWARD_</xsl:text>
-    <xsl:value-of select="$parent/@name"/>
-    <xsl:text>_SETTER_</xsl:text>
-    <xsl:call-template name="capitalize">
-      <xsl:with-param name="str" select="@name"/>
-    </xsl:call-template>
-    <xsl:text>_TO_BASE(base) COM_FORWARD_</xsl:text>
-    <xsl:value-of select="$parent/@name"/>
-    <xsl:text>_SETTER_</xsl:text>
-    <xsl:call-template name="capitalize">
-      <xsl:with-param name="str" select="@name"/>
-    </xsl:call-template>
-    <xsl:text>_TO (base::)&#x0A;</xsl:text>
+    <xsl:text>))&#x0A;</xsl:text>
+
   </xsl:if>
-
-  <xsl:apply-templates select="@if" mode="end"/>
-
 </xsl:template>
-
 
 <!--
  *  methods
 -->
-<xsl:template match="interface//method">
-  <xsl:apply-templates select="@if" mode="begin"/>
+<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
@@ -1620 +2132 @@
     <xsl:text>)(&#x0A;</xsl:text>
     <xsl:text>        </xsl:text>
-    <xsl:value-of select="../@name" />
+    <xsl:value-of select="$iface" />
     <xsl:text> *pThis,&#x0A;</xsl:text>
     <xsl:for-each select="param [position() != last()]">
@@ -1633 +2145 @@
   <xsl:if test="not(param)">
     <xsl:text>)(</xsl:text>
-    <xsl:value-of select="../@name" />
+    <xsl:value-of select="$iface" />
     <xsl:text> *pThis );&#x0A;</xsl:text>
   </xsl:if>
-  <xsl:apply-templates select="@if" mode="end"/>
   <xsl:text>&#x0A;</xsl:text>
 </xsl:template>
 
-<xsl:template match="interface//method" mode="forwarder">
-
-  <xsl:variable name="parent" select="ancestor::interface"/>
-
-  <xsl:apply-templates select="@if" mode="begin"/>
-
-  <xsl:text>#define COM_FORWARD_</xsl:text>
-  <xsl:value-of select="$parent/@name"/>
-  <xsl:text>_</xsl:text>
+<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>_TO(smth) NS_IMETHOD </xsl:text>
+  <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:choose>
-    <xsl:when test="param">
-      <xsl:text> (</xsl:text>
-      <xsl:for-each select="param [position() != last()]">
-        <xsl:apply-templates select="." mode="forwarder"/>
-        <xsl:text>, </xsl:text>
-      </xsl:for-each>
-      <xsl:apply-templates select="param [last()]" mode="forwarder"/>
-      <xsl:text>) { return smth </xsl:text>
-      <xsl:call-template name="capitalize">
-        <xsl:with-param name="str" select="@name"/>
-      </xsl:call-template>
-      <xsl:text> (</xsl:text>
-      <xsl:for-each select="param [position() != last()]">
-        <xsl:if test="@safearray='yes'">
-          <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:text>a</xsl:text>
-        <xsl:call-template name="capitalize">
-          <xsl:with-param name="str" select="@name"/>
-        </xsl:call-template>
-        <xsl:text>, </xsl:text>
-      </xsl:for-each>
-      <xsl:if test="param [last()]/@safearray='yes'">
-        <xsl:text>a</xsl:text>
-        <xsl:call-template name="capitalize">
-          <xsl:with-param name="str" select="param [last()]/@name"/>
-        </xsl:call-template>
-        <xsl:text>Size, </xsl:text>
-      </xsl:if>
-      <xsl:text>a</xsl:text>
-      <xsl:call-template name="capitalize">
-        <xsl:with-param name="str" select="param [last()]/@name"/>
-      </xsl:call-template>
-      <xsl:text>); }</xsl:text>
-    </xsl:when>
-    <xsl:otherwise test="not(param)">
-      <xsl:text>() { return smth </xsl:text>
-      <xsl:call-template name="capitalize">
-        <xsl:with-param name="str" select="@name"/>
-      </xsl:call-template>
-      <xsl:text>(); }</xsl:text>
-    </xsl:otherwise>
-  </xsl:choose>
-  <xsl:text>&#x0A;</xsl:text>
-  <!-- COM_FORWARD_Interface_Method_TO_OBJ(obj) -->
-  <xsl:text>#define COM_FORWARD_</xsl:text>
-  <xsl:value-of select="$parent/@name"/>
-  <xsl:text>_</xsl:text>
-  <xsl:call-template name="capitalize">
-    <xsl:with-param name="str" select="@name"/>
-  </xsl:call-template>
-  <xsl:text>_TO_OBJ(obj) COM_FORWARD_</xsl:text>
-  <xsl:value-of select="$parent/@name"/>
-  <xsl:text>_</xsl:text>
-  <xsl:call-template name="capitalize">
-    <xsl:with-param name="str" select="@name"/>
-  </xsl:call-template>
-  <xsl:text>_TO ((obj)->)&#x0A;</xsl:text>
-  <!-- COM_FORWARD_Interface_Method_TO_BASE(base) -->
-  <xsl:text>#define COM_FORWARD_</xsl:text>
-  <xsl:value-of select="$parent/@name"/>
-  <xsl:text>_</xsl:text>
-  <xsl:call-template name="capitalize">
-    <xsl:with-param name="str" select="@name"/>
-  </xsl:call-template>
-  <xsl:text>_TO_BASE(base) COM_FORWARD_</xsl:text>
-  <xsl:value-of select="$parent/@name"/>
-  <xsl:text>_</xsl:text>
-  <xsl:call-template name="capitalize">
-    <xsl:with-param name="str" select="@name"/>
-  </xsl:call-template>
-  <xsl:text>_TO (base::)&#x0A;</xsl:text>
-
-  <xsl:apply-templates select="@if" mode="end"/>
-
+  <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>
 
@@ -1782 +2224 @@
   <xsl:text>;1&quot;&#x0A;</xsl:text>
   <!-- CLSID_xxx declarations for XPCOM, for compatibility with Win32 -->
-  <xsl:text>/* for compatibility with Win32 */&#x0A;</xsl:text>
-  <xsl:text>#define CLSID_</xsl:text>
+  <xsl:text>/* COM compatibility */&#x0A;</xsl:text>
+  <xsl:text>VBOX_EXTERN_CONST(nsCID, CLSID_</xsl:text>
   <xsl:value-of select="@name"/>
-  <xsl:text> (nsCID) NS_</xsl:text>
-  <xsl:call-template name="uppercase">
-    <xsl:with-param name="str" select="@name"/>
-  </xsl:call-template>
-  <xsl:text>_CID&#x0A;</xsl:text>
+  <xsl:text>);&#x0A;</xsl:text>
   <xsl:text>&#x0A;&#x0A;</xsl:text>
 </xsl:template>
@@ -1800 +2238 @@
   <xsl:text>/* Start of enum </xsl:text>
   <xsl:value-of select="@name"/>
-  <xsl:text> Declaration */&#x0A;</xsl:text>
+  <xsl:text> declaration */&#x0A;</xsl:text>
   <xsl:text>#define </xsl:text>
   <xsl:call-template name="uppercase">
@@ -1842 +2280 @@
   <xsl:text>/* End of enum </xsl:text>
   <xsl:value-of select="@name"/>
-  <xsl:text> Declaration */&#x0A;&#x0A;&#x0A;</xsl:text>
+  <xsl:text> declaration */
+#define </xsl:text>
+  <xsl:value-of select="concat(@name, '_T PRUint32&#x0A;&#x0A;&#x0A;')"/>
 </xsl:template>
 

trunk/src/VBox/Main/cbinding/makefile.tstCAPIGlue

@@ -1 +1 @@
 # $Revision$
-## @file makefile.tstXPCOMCGlue
-# Makefile for sample program illustrating use of C binding for XPCOM.
+## @file makefile.tstCAPIGlue
+# Makefile for sample program illustrating use of C binding for COM/XPCOM.
 #
 
 #
-# Copyright (C) 2009-2013 Oracle Corporation
+# Copyright (C) 2009-2014 Oracle Corporation
 #
 # This file is part of VirtualBox Open Source Edition (OSE), as
@@ -16 +16 @@
 #
 
-INCS_XPCOM    = -I../../include
-GLUE_DIR      = ..
-GLUE_INC      = -I..
+PATH_SDK      = ../../..
+CAPI_INC      = -I$(PATH_SDK)/bindings/c/include
+ifeq ($(BUILD_PLATFORM),win)
+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
@@ -24 +32 @@
 
 .PHONY: all
-all: tstXPCOMCGlue
+all: tstCAPIGlue
 
 .PHONY: clean
 clean:
-        rm -f tstXPCOMCGlue.o tstXPCOMCGlue VBoxXPCOMCGlue.o
+        rm -f tstCAPIGlue.o VBoxCAPIGlue.o VirtualBox_i.o tstCAPIGlue
 
-tstXPCOMCGlue: tstXPCOMCGlue.o VBoxXPCOMCGlue.o
+tstCAPIGlue: tstCAPIGlue.o VBoxCAPIGlue.o VirtualBox_i.o
         $(CC) -o $@ $^ -ldl -lpthread
 
-tstXPCOMCGlue.o: tstXPCOMCGlue.c
-        $(CC) $(CFLAGS) $(INCS_XPCOM) $(GLUE_INC) -o $@ -c $<
+tstCAPIGlue.o: tstCAPIGlue.c
+        $(CC) $(CFLAGS) $(CAPI_INC) $(PLATFORM_INC) $(GLUE_INC) -o $@ -c $<
 
-VBoxXPCOMCGlue.o: $(GLUE_DIR)/VBoxXPCOMCGlue.c
-        $(CC) $(CFLAGS) $(INCS_XPCOM) $(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 $<

trunk/src/VBox/Main/cbinding/tstCAPIGlue.c

@@ -1 +1 @@
 /* $Revision$ */
-/** @file tstXPCOMCGlue.c
- * Demonstrator program to illustrate use of C bindings of Main API, including
- * how to retrieve all available error information.
+/** @file tstCAPIGlue.c
+ * Demonstrator program to illustrate use of C bindings of Main API.
  *
- * This includes code which shows how to handle active event listeners
- * (event delivery through callbacks), which is not so frequently seen in
- * other samples which mostly use passive event listeners.
- *
- * Linux only at the moment due to shared library magic in the Makefile.
+ * 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-2013 Oracle Corporation
+ * Copyright (C) 2009-2014 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -26 +23 @@
 *   Header Files                                                               *
 *******************************************************************************/
-#include "VBoxXPCOMCGlue.h"
+#include "VBoxCAPIGlue.h"
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
-#include <unistd.h>
-#include <signal.h>
-#include <sys/poll.h>
+#ifndef WIN32
+# include <signal.h>
+# include <unistd.h>
+# include <sys/poll.h>
+#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 signal handler. */
+/** Set by Ctrl+C handler. */
 static volatile int g_fStop = 0;
 
-static const char *GetStateName(PRUint32 machineState)
+#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)
@@ -70 +84 @@
 }
 
-struct IEventListenerDemo_vtbl
-{
-    struct IEventListener_vtbl ieventlistener;
-};
-
-typedef struct IEventListenerDemo
-{
-    struct IEventListenerDemo_vtbl *vtbl;
-
-    int refcount;
-} IEventListenerDemo;
-
 /**
- * Event handler function
+ * 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).
  */
-static nsresult IEventListenerDemo_HandleEvent(IEventListener *pThis, IEvent *event)
-{
-    enum VBoxEventType evType;
-    nsresult rc;
+static BOOL ctrlCHandler(DWORD iInfo)
+{
+    (void)iInfo;
+    g_fStop = 1;
+    return TRUE;
+}
+
+/**
+ * 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 rc;
 
     if (!event)
     {
         printf("event null\n");
-        return NS_OK;
+        return S_OK;
     }
 
     evType = VBoxEventType_Invalid;
-    rc = event->vtbl->GetType(event, &evType);
-    if (NS_FAILED(rc))
+    rc = IEvent_get_Type(event, &evType);
+    if (FAILED(rc))
     {
         printf("cannot get event type, rc=%#x\n", rc);
-        return NS_OK;
+        return S_OK;
     }
 
@@ -120 +139 @@
         case VBoxEventType_OnStateChanged:
         {
-            static const nsID istateChangedEventUUID = ISTATECHANGEDEVENT_IID;
             IStateChangedEvent *ev = NULL;
             enum MachineState state;
-            rc = event->vtbl->nsisupports.QueryInterface((nsISupports *)event, &istateChangedEventUUID, (void **)&ev);
-            if (NS_FAILED(rc))
+            rc = IEvent_QueryInterface(event, &IID_IStateChangedEvent, (void **)&ev);
+            if (FAILED(rc))
             {
                 printf("cannot get StateChangedEvent interface, rc=%#x\n", rc);
-                return NS_OK;
+                return S_OK;
             }
             if (!ev)
             {
                 printf("StateChangedEvent reference null\n");
-                return NS_OK;
+                return S_OK;
             }
-            rc = ev->vtbl->GetState(ev, &state);
-            if (NS_FAILED(rc))
+            rc = IStateChangedEvent_get_State(ev, &state);
+            if (FAILED(rc))
                 printf("warning: cannot get state, rc=%#x\n", rc);
-            ev->vtbl->ievent.nsisupports.Release((nsISupports *)ev);
+            IStateChangedEvent_Release(ev);
             printf("OnStateChanged: %s\n", GetStateName(state));
 
@@ -205 +223 @@
     }
 
-    return NS_OK;
-}
-
-static nsresult IEventListenerDemo_QueryInterface(nsISupports *pThis, const nsID *iid, void **resultp)
-{
-    static const nsID ieventListenerUUID = IEVENTLISTENER_IID;
-    static const nsID isupportIID = NS_ISUPPORTS_IID;
-
+    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, &ieventListenerUUID, sizeof(nsID)) == 0
-        ||  memcmp(iid, &isupportIID, sizeof(nsID)) == 0)
-    {
-        pThis->vtbl->AddRef(pThis);
+    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 NS_OK;
-    }
-
-    return NS_NOINTERFACE;
-}
-
-static nsresult IEventListenerDemo_AddRef(nsISupports *pThis)
-{
-    return ++(((IEventListenerDemo *)pThis)->refcount);
-}
-
-static nsresult IEventListenerDemo_Release(nsISupports *pThis)
-{
-    nsresult c;
-
-    c = --(((IEventListenerDemo *)pThis)->refcount);
-    if (c == 0)
+        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;
 }
 
-struct IEventListenerDemo_vtbl_int_gcc
+#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 rc;
+    ITypeLib *pTypeLib;
+    rc = LoadRegTypeLib(&LIBID_VirtualBox, 1 /* major */, 0 /* minor */, 0 /* lcid */, &pTypeLib);
+    if (FAILED(rc))
+        return rc;
+    rc = ITypeLib_GetTypeInfoOfGuid(pTypeLib, riid, pTInfo);
+
+    /* No longer need access to the type lib, release it. */
+    ITypeLib_Release(pTypeLib);
+
+    return rc;
+}
+#endif
+
+#ifdef __GNUC__
+typedef struct IEventListenerDemoVtblInt
 {
     ptrdiff_t offset_to_top;
     void *typeinfo;
-    struct IEventListenerDemo_vtbl vtbl;
-};
-
-static struct IEventListenerDemo_vtbl_int_gcc g_IEventListenerDemo_vtbl_int_gcc =
+    IEventListenerDemoVtbl lpVtbl;
+} IEventListenerDemoVtblInt;
+
+static IEventListenerDemoVtblInt g_IEventListenerDemoVtblInt =
 {
     0,      /* offset_to_top */
     NULL,   /* typeinfo, not vital */
     {
-        {
-            {
-                IEventListenerDemo_QueryInterface,
-                IEventListenerDemo_AddRef,
-                IEventListenerDemo_Release
-            },
-            IEventListenerDemo_HandleEvent
-        }
+        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
 
 /**
- * Signal handler, terminate event listener.
- *
- * @param  iSig     The signal number (ignored).
- */
-static void sigIntHandler(int iSig)
-{
-    (void)iSig;
-    g_fStop = 1;
-}
-
-/**
- * Register event listener for the selected VM.
+ * Register active event listener for the selected VM.
  *
  * @param   virtualBox ptr to IVirtualBox object
  * @param   session    ptr to ISession object
  * @param   id         identifies the machine to start
- * @param   queue      handle to the event queue
  */
-static void registerEventListener(IVirtualBox *virtualBox, ISession *session, PRUnichar *machineId, nsIEventQueue *queue)
+static void registerActiveEventListener(IVirtualBox *virtualBox, ISession *session, BSTR machineId)
 {
     IConsole *console = NULL;
-    nsresult rc;
-
-    rc = session->vtbl->GetConsole(session, &console);
-    if ((NS_SUCCEEDED(rc)) && console)
+    HRESULT rc;
+
+    rc = ISession_get_Console(session, &console);
+    if ((SUCCEEDED(rc)) && console)
     {
         IEventSource *es = NULL;
-        rc = console->vtbl->GetEventSource(console, &es);
-        if (NS_SUCCEEDED(rc) && es)
-        {
-            PRUint32 interestingEvents[] =
+        rc = IConsole_get_EventSource(console, &es);
+        if (SUCCEEDED(rc) && es)
+        {
+            static const ULONG interestingEvents[] =
                 {
                     VBoxEventType_OnMousePointerShapeChanged,
@@ -314 +465 @@
                     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(interestingEvents) / sizeof(interestingEvents[0]));
+            g_pVBoxFuncs->pfnSafeArrayCopyInParamHelper(interestingEventsSA, &interestingEvents, sizeof(interestingEvents));
+
             consoleListener = calloc(1, sizeof(IEventListenerDemo));
             if (consoleListener)
             {
-                consoleListener->vtbl = &(g_IEventListenerDemo_vtbl_int_gcc.vtbl);
-                consoleListener->vtbl->ieventlistener.nsisupports.AddRef((nsISupports *)consoleListener);
-
-                rc = es->vtbl->RegisterListener(es, (IEventListener *)consoleListener,
-                                                sizeof(interestingEvents) / sizeof(interestingEvents[0]),
-                                                interestingEvents, 1 /* active */);
-                if (NS_SUCCEEDED(rc))
+                consoleListener->lpVtbl = &(g_IEventListenerDemoVtblInt.lpVtbl);
+#ifdef WIN32
+                CoCreateFreeThreadedMarshaler((IUnknown *)consoleListener, &consoleListener->pUnkMarshaler);
+#endif
+                IEventListenerDemo_AddRef(consoleListener);
+
+                rc = IEventSource_RegisterListener(es, (IEventListener *)consoleListener,
+                                                   ComSafeArrayAsInParam(interestingEventsSA),
+                                                   1 /* active */);
+                if (SUCCEEDED(rc))
                 {
                     /* Just wait here for events, no easy way to do this better
                      * as there's not much to do after this completes. */
-                    PRInt32 fd;
-                    int ret;
                     printf("Entering event loop, PowerOff the machine to exit or press Ctrl-C to terminate\n");
                     fflush(stdout);
-                    signal(SIGINT, sigIntHandler);
-
-                    fd = queue->vtbl->GetEventQueueSelectFD(queue);
-                    if (fd >= 0)
+#ifdef WIN32
+                    SetConsoleCtrlHandler(ctrlCHandler, TRUE);
+#else
+                    signal(SIGINT, (void (*)(int))ctrlCHandler);
+#endif
+
+                    while (!g_fStop)
                     {
-                        while (!g_fStop)
-                        {
-                            struct pollfd pfd;
-
-                            pfd.fd = fd;
-                            pfd.events = POLLIN | POLLERR | POLLHUP;
-                            pfd.revents = 0;
-
-                            ret = poll(&pfd, 1, 250);
-
-                            if (ret <= 0)
-                                continue;
-
-                            if (pfd.revents & POLLHUP)
-                                g_fStop = 1;
-
-                            queue->vtbl->ProcessPendingEvents(queue);
-                        }
+                        g_pVBoxFuncs->pfnProcessEventQueue(250);
                     }
-                    else
-                    {
-                        while (!g_fStop)
-                        {
-                            PLEvent *pEvent = NULL;
-                            rc = queue->vtbl->WaitForEvent(queue, &pEvent);
-                            if (NS_SUCCEEDED(rc))
-                                queue->vtbl->HandleEvent(queue, pEvent);
-                        }
-                    }
+
+#ifdef WIN32
+                    SetConsoleCtrlHandler(ctrlCHandler, FALSE);
+#else
                     signal(SIGINT, SIG_DFL);
+#endif
                 }
-                es->vtbl->UnregisterListener(es, (IEventListener *)consoleListener);
-                consoleListener->vtbl->ieventlistener.nsisupports.Release((nsISupports *)consoleListener);
+                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
@@ -375 +523 @@
                 printf("Failed while allocating memory for console event listener.\n");
             }
-            es->vtbl->nsisupports.Release((nsISupports *)es);
-        }
-        console->vtbl->nsisupports.Release((nsISupports *)console);
-    }
-}
+            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
+ * @param   id         identifies the machine to start
+ */
+static void registerPassiveEventListener(IVirtualBox *virtualBox, ISession *session, BSTR machineId)
+{
+    IConsole *console = NULL;
+    HRESULT rc;
+
+    rc = ISession_get_Console(session, &console);
+    if ((SUCCEEDED(rc)) && console)
+    {
+        IEventSource *es = NULL;
+        rc = IConsole_get_EventSource(console, &es);
+        if (SUCCEEDED(rc) && es)
+        {
+            static const ULONG interestingEvents[] =
+                {
+                    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(interestingEvents) / sizeof(interestingEvents[0]));
+            g_pVBoxFuncs->pfnSafeArrayCopyInParamHelper(interestingEventsSA, &interestingEvents, sizeof(interestingEvents));
+
+            rc = IEventSource_CreateListener(es, &consoleListener);
+            if (SUCCEEDED(rc) && consoleListener)
+            {
+                rc = IEventSource_RegisterListener(es, consoleListener,
+                                                   ComSafeArrayAsInParam(interestingEventsSA),
+                                                   0 /* passive */);
+                if (SUCCEEDED(rc))
+                {
+                    /* 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)
+                    {
+                        IEvent *ev = NULL;
+                        rc = IEventSource_GetEvent(es, consoleListener, 250, &ev);
+                        if (FAILED(rc))
+                        {
+                            printf("Failed getting event: %#x\n", rc);
+                            g_fStop = 1;
+                            continue;
+                        }
+                        /* handle timeouts, resulting in NULL events */
+                        if (!ev)
+                            continue;
+                        rc = EventListenerDemoProcessEvent(ev);
+                        if (FAILED(rc))
+                        {
+                            printf("Failed processing event: %#x\n", rc);
+                            g_fStop = 1;
+                            /* finish processing the event */
+                        }
+                        rc = IEventSource_EventProcessed(es, consoleListener, ev);
+                        if (FAILED(rc))
+                        {
+                            printf("Failed to mark event as processed: %#x\n", rc);
+                            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 */
 
 /**
@@ -385 +669 @@
  * @param   pszExecutable   string with the executable name
  * @param   pszErrorMsg     string containing the code location specific error message
- * @param   rc              XPCOM result code
+ * @param   rc              COM/XPCOM result code
  */
-static void PrintErrorInfo(const char *pszExecutable, const char *pszErrorMsg, nsresult rc)
-{
-    nsIException *ex;
-    nsresult rc2 = NS_OK;
+static void PrintErrorInfo(const char *pszExecutable, const char *pszErrorMsg, HRESULT rc)
+{
+    IErrorInfo *ex;
+    HRESULT rc2 = S_OK;
     fprintf(stderr, "%s: %s (rc=%#010x)\n", pszExecutable, pszErrorMsg, (unsigned)rc);
     rc2 = g_pVBoxFuncs->pfnGetException(&ex);
-    if (NS_SUCCEEDED(rc2))
-    {
-        static const nsID vbei = IVIRTUALBOXERRORINFO_IID;
+    if (SUCCEEDED(rc2))
+    {
         IVirtualBoxErrorInfo *ei;
-        rc2 = ex->vtbl->nsisupports.QueryInterface((nsISupports *)ex, &vbei, (void **)&ei);
-        if (NS_FAILED(rc2))
+        rc2 = IErrorInfo_QueryInterface(ex, &IID_IVirtualBoxErrorInfo, (void **)&ei);
+        if (FAILED(rc2))
             ei = NULL;
         if (ei)
@@ -405 +688 @@
             do
             {
-                PRInt32 resultCode = NS_OK;
-                PRUnichar *componentUtf16 = NULL;
+                LONG resultCode = S_OK;
+                BSTR componentUtf16 = NULL;
                 char *component = NULL;
-                PRUnichar *textUtf16 = NULL;
+                BSTR textUtf16 = NULL;
                 char *text = NULL;
                 IVirtualBoxErrorInfo *ei_next = NULL;
                 fprintf(stderr, "Extended error info (IVirtualBoxErrorInfo):\n");
 
-                ei->vtbl->GetResultCode(ei, &resultCode);
+                IVirtualBoxErrorInfo_get_ResultCode(ei, &resultCode);
                 fprintf(stderr, "  resultCode=%#010x\n", (unsigned)resultCode);
 
-                ei->vtbl->GetComponent(ei, &componentUtf16);
+                IVirtualBoxErrorInfo_get_Component(ei, &componentUtf16);
                 g_pVBoxFuncs->pfnUtf16ToUtf8(componentUtf16, &component);
-                g_pVBoxFuncs->pfnComUnallocMem(componentUtf16);
+                g_pVBoxFuncs->pfnComUnallocString(componentUtf16);
                 fprintf(stderr, "  component=%s\n", component);
                 g_pVBoxFuncs->pfnUtf8Free(component);
 
-                ei->vtbl->GetText(ei, &textUtf16);
+                IVirtualBoxErrorInfo_get_Text(ei, &textUtf16);
                 g_pVBoxFuncs->pfnUtf16ToUtf8(textUtf16, &text);
-                g_pVBoxFuncs->pfnComUnallocMem(textUtf16);
+                g_pVBoxFuncs->pfnComUnallocString(textUtf16);
                 fprintf(stderr, "  text=%s\n", text);
                 g_pVBoxFuncs->pfnUtf8Free(text);
 
-                rc2 = ei->vtbl->GetNext(ei, &ei_next);
-                if (NS_FAILED(rc2))
+                rc2 = IVirtualBoxErrorInfo_get_Next(ei, &ei_next);
+                if (FAILED(rc2))
                     ei_next = NULL;
-                ei->vtbl->nsiexception.nsisupports.Release((nsISupports *)ei);
+                IVirtualBoxErrorInfo_Release(ei);
                 ei = ei_next;
             }
             while (ei);
         }
-        else
-        {
-            /* got basic error info */
-            nsresult resultCode = NS_OK;
-            PRUnichar *messageUtf16 = NULL;
-            char *message = NULL;
-            fprintf(stderr, "Basic error info (nsIException):\n");
-
-            ex->vtbl->GetResult(ex, &resultCode);
-            fprintf(stderr, "  resultCode=%#010x\n", resultCode);
-
-            ex->vtbl->GetMessage(ex, &messageUtf16);
-            g_pVBoxFuncs->pfnUtf16ToUtf8(messageUtf16, &message);
-            g_pVBoxFuncs->pfnComUnallocMem(messageUtf16);
-            fprintf(stderr, "  message=%s\n", message);
-            g_pVBoxFuncs->pfnUtf8Free(message);
-        }
-
-        ex->vtbl->nsisupports.Release((nsISupports *)ex);
+
+        IErrorInfo_Release(ex);
         g_pVBoxFuncs->pfnClearException();
     }
@@ -466 +732 @@
  * @param   session     ptr to ISession object
  * @param   id          identifies the machine to start
- * @param   queue       ptr to event queue
  */
-static void startVM(const char *argv0, IVirtualBox *virtualBox, ISession *session, PRUnichar *id, nsIEventQueue *queue)
-{
-    nsresult rc;
+static void startVM(const char *argv0, IVirtualBox *virtualBox, ISession *session, BSTR id)
+{
+    HRESULT rc;
     IMachine  *machine    = NULL;
     IProgress *progress   = NULL;
-    PRUnichar *env        = NULL;
-    PRUnichar *sessionType;
-
-    rc = virtualBox->vtbl->FindMachine(virtualBox, id, &machine);
-    if (NS_FAILED(rc) || !machine)
+    BSTR env              = NULL;
+    BSTR sessionType;
+
+    rc = IVirtualBox_FindMachine(virtualBox, id, &machine);
+    if (FAILED(rc) || !machine)
     {
         PrintErrorInfo(argv0, "Error: Couldn't get the Machine reference", rc);
@@ -484 +749 @@
 
     g_pVBoxFuncs->pfnUtf8ToUtf16("gui", &sessionType);
-    rc = machine->vtbl->LaunchVMProcess(machine,
-        session,
-        sessionType,
-        env,
-        &progress
-    );
+    rc = IMachine_LaunchVMProcess(machine, session, sessionType, env, &progress);
     g_pVBoxFuncs->pfnUtf16Free(sessionType);
-    if (NS_SUCCEEDED(rc))
-    {
-        PRBool completed;
-        PRInt32 resultCode;
+    if (SUCCEEDED(rc))
+    {
+        BOOL completed;
+        LONG resultCode;
 
         printf("Waiting for the remote session to open...\n");
-        progress->vtbl->WaitForCompletion(progress, -1);
-
-        rc = progress->vtbl->GetCompleted(progress, &completed);
-        if (NS_FAILED(rc))
+        IProgress_WaitForCompletion(progress, -1);
+
+        rc = IProgress_get_Completed(progress, &completed);
+        if (FAILED(rc))
             fprintf(stderr, "Error: GetCompleted status failed\n");
 
-        progress->vtbl->GetResultCode(progress, &resultCode);
-        if (NS_FAILED(resultCode))
+        IProgress_get_ResultCode(progress, &resultCode);
+        if (FAILED(resultCode))
         {
             IVirtualBoxErrorInfo *errorInfo;
-            PRUnichar *textUtf16;
+            BSTR textUtf16;
             char *text;
 
-            progress->vtbl->GetErrorInfo(progress, &errorInfo);
-            errorInfo->vtbl->GetText(errorInfo, &textUtf16);
+            IProgress_get_ErrorInfo(progress, &errorInfo);
+            IVirtualBoxErrorInfo_get_Text(errorInfo, &textUtf16);
             g_pVBoxFuncs->pfnUtf16ToUtf8(textUtf16, &text);
             printf("Error: %s\n", text);
 
-            g_pVBoxFuncs->pfnComUnallocMem(textUtf16);
+            g_pVBoxFuncs->pfnComUnallocString(textUtf16);
             g_pVBoxFuncs->pfnUtf8Free(text);
+            IVirtualBoxErrorInfo_Release(errorInfo);
         }
         else
@@ -524 +785 @@
             /* Kick off the event listener demo part, which is quite separate.
              * Ignore it if you need a more basic sample. */
-            registerEventListener(virtualBox, session, id, queue);
-        }
-        progress->vtbl->nsisupports.Release((nsISupports *)progress);
+#ifdef USE_ACTIVE_EVENT_LISTENER
+            registerActiveEventListener(virtualBox, session, id);
+#else /* !USE_ACTIVE_EVENT_LISTENER */
+            registerPassiveEventListener(virtualBox, session, id);
+#endif /* !USE_ACTIVE_EVENT_LISTENER */
+        }
+        IProgress_Release(progress);
     }
     else
@@ -532 +797 @@
 
     /* It's important to always release resources. */
-    machine->vtbl->nsisupports.Release((nsISupports *)machine);
+    IMachine_Release(machine);
 }
 
@@ -541 +806 @@
  * @param   virtualBox  ptr to IVirtualBox object
  * @param   session     ptr to ISession object
- * @param   queue       ptr to event queue
  */
-static void listVMs(const char *argv0, IVirtualBox *virtualBox, ISession *session, nsIEventQueue *queue)
-{
-    nsresult rc;
+static void listVMs(const char *argv0, IVirtualBox *virtualBox, ISession *session)
+{
+    HRESULT rc;
+    SAFEARRAY *machinesSA = g_pVBoxFuncs->pfnSafeArrayOutParamAlloc();
     IMachine **machines = NULL;
-    PRUint32 machineCnt = 0;
-    PRUint32 i;
+    ULONG machineCnt = 0;
+    ULONG i;
     unsigned start_id;
 
@@ -554 +819 @@
      * Get the list of all registered VMs.
      */
-
-    rc = virtualBox->vtbl->GetMachines(virtualBox, &machineCnt, &machines);
-    if (NS_FAILED(rc))
+    rc = IVirtualBox_get_Machines(virtualBox, ComSafeArrayAsOutIfaceParam(machinesSA, IMachine *));
+    if (FAILED(rc))
     {
         PrintErrorInfo(argv0, "could not get list of machines", rc);
@@ -562 +826 @@
     }
 
-    if (machineCnt == 0)
+    /*
+     * 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)
     {
         printf("\tNo VMs\n");
@@ -577 +848 @@
     {
         IMachine *machine      = machines[i];
-        PRBool    isAccessible = PR_FALSE;
+        BOOL      isAccessible = FALSE;
 
         printf("\tMachine #%u\n", (unsigned)i);
@@ -587 +858 @@
         }
 
-        machine->vtbl->GetAccessible(machine, &isAccessible);
+        IMachine_get_Accessible(machine, &isAccessible);
 
         if (isAccessible)
         {
-            PRUnichar *machineNameUtf16;
+            BSTR machineNameUtf16;
             char *machineName;
 
-            machine->vtbl->GetName(machine, &machineNameUtf16);
+            IMachine_get_Name(machine, &machineNameUtf16);
             g_pVBoxFuncs->pfnUtf16ToUtf8(machineNameUtf16,&machineName);
-            g_pVBoxFuncs->pfnComUnallocMem(machineNameUtf16);
+            g_pVBoxFuncs->pfnComUnallocString(machineNameUtf16);
             printf("\tName:        %s\n", machineName);
             g_pVBoxFuncs->pfnUtf8Free(machineName);
@@ -606 +877 @@
 
         {
-            PRUnichar *uuidUtf16;
+            BSTR uuidUtf16;
             char      *uuidUtf8;
 
-            machine->vtbl->GetId(machine, &uuidUtf16);
+            IMachine_get_Id(machine, &uuidUtf16);
             g_pVBoxFuncs->pfnUtf16ToUtf8(uuidUtf16, &uuidUtf8);
-            g_pVBoxFuncs->pfnComUnallocMem(uuidUtf16);
+            g_pVBoxFuncs->pfnComUnallocString(uuidUtf16);
             printf("\tUUID:        %s\n", uuidUtf8);
             g_pVBoxFuncs->pfnUtf8Free(uuidUtf8);
@@ -619 +890 @@
         {
             {
-                PRUnichar *configFileUtf16;
+                BSTR      configFileUtf16;
                 char      *configFileUtf8;
 
-                machine->vtbl->GetSettingsFilePath(machine, &configFileUtf16);
+                IMachine_get_SettingsFilePath(machine, &configFileUtf16);
                 g_pVBoxFuncs->pfnUtf16ToUtf8(configFileUtf16, &configFileUtf8);
-                g_pVBoxFuncs->pfnComUnallocMem(configFileUtf16);
+                g_pVBoxFuncs->pfnComUnallocString(configFileUtf16);
                 printf("\tConfig file: %s\n", configFileUtf8);
                 g_pVBoxFuncs->pfnUtf8Free(configFileUtf8);
@@ -630 +901 @@
 
             {
-                PRUint32 memorySize;
-
-                machine->vtbl->GetMemorySize(machine, &memorySize);
+                ULONG memorySize;
+
+                IMachine_get_MemorySize(machine, &memorySize);
                 printf("\tMemory size: %uMB\n", memorySize);
             }
 
             {
-                PRUnichar *typeId;
-                PRUnichar *osNameUtf16;
+                BSTR typeId;
+                BSTR osNameUtf16;
                 char *osName;
                 IGuestOSType *osType = NULL;
 
-                machine->vtbl->GetOSTypeId(machine, &typeId);
-                virtualBox->vtbl->GetGuestOSType(virtualBox, typeId, &osType);
-                g_pVBoxFuncs->pfnComUnallocMem(typeId);
-                osType->vtbl->GetDescription(osType, &osNameUtf16);
+                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->pfnComUnallocMem(osNameUtf16);
+                g_pVBoxFuncs->pfnComUnallocString(osNameUtf16);
                 printf("\tGuest OS:    %s\n\n", osName);
                 g_pVBoxFuncs->pfnUtf8Free(osName);
 
-                osType->vtbl->nsisupports.Release((nsISupports *)osType);
+                IGuestOSType_Release(osType);
             }
         }
@@ -670 +941 @@
         if (machine)
         {
-            PRUnichar *uuidUtf16 = NULL;
-
-            machine->vtbl->GetId(machine, &uuidUtf16);
-            startVM(argv0, virtualBox, session, uuidUtf16, queue);
-            g_pVBoxFuncs->pfnComUnallocMem(uuidUtf16);
+            BSTR uuidUtf16 = NULL;
+
+            IMachine_get_Id(machine, &uuidUtf16);
+            startVM(argv0, virtualBox, session, uuidUtf16);
+            g_pVBoxFuncs->pfnComUnallocString(uuidUtf16);
         }
     }
@@ -688 +959 @@
         if (machine)
         {
-            machine->vtbl->nsisupports.Release((nsISupports *)machine);
+            IMachine_Release(machine);
         }
     }
     if (machines)
-        g_pVBoxFuncs->pfnComUnallocMem(machines);
+        free(machines);
 }
 
@@ -702 +973 @@
     IVirtualBox *vbox            = NULL;
     ISession   *session          = NULL;
-    nsIEventQueue *queue         = NULL;
-    PRUint32    revision         = 0;
-    PRUnichar  *versionUtf16     = NULL;
-    PRUnichar  *homefolderUtf16  = NULL;
-    nsresult    rc;     /* Result code of various function (method) calls. */
+    ULONG       revision         = 0;
+    BSTR        versionUtf16     = NULL;
+    BSTR        homefolderUtf16  = NULL;
+    HRESULT    rc;     /* Result code of various function (method) calls. */
 
     printf("Starting main()\n");
@@ -724 +994 @@
     }
 
-    g_pVBoxFuncs->pfnClientInitialize(IVIRTUALBOXCLIENT_IID_STR, &vboxclient);
-    if (vboxclient == NULL)
+    g_pVBoxFuncs->pfnClientInitialize(NULL, &vboxclient);
+    if (!vboxclient)
     {
         fprintf(stderr, "%s: FATAL: could not get VirtualBoxClient reference\n", argv[0]);
@@ -733 +1003 @@
     printf("----------------------------------------------------\n");
 
-    rc = vboxclient->vtbl->GetVirtualBox(vboxclient, &vbox);
-    if (NS_FAILED(rc) || !vbox)
+    rc = IVirtualBoxClient_get_VirtualBox(vboxclient, &vbox);
+    if (FAILED(rc) || !vbox)
     {
         PrintErrorInfo(argv[0], "FATAL: could not get VirtualBox reference", rc);
         return EXIT_FAILURE;
     }
-    rc = vboxclient->vtbl->GetSession(vboxclient, &session);
-    if (NS_FAILED(rc) || !session)
+    rc = IVirtualBoxClient_get_Session(vboxclient, &session);
+    if (FAILED(rc) || !session)
     {
         PrintErrorInfo(argv[0], "FATAL: could not get Session reference", rc);
@@ -746 +1016 @@
     }
 
-    g_pVBoxFuncs->pfnGetEventQueue(&queue);
+#ifdef USE_ACTIVE_EVENT_LISTENER
+# ifdef WIN32
+    rc = LoadTypeInfo(&IID_IEventListener, &g_pTInfoIEventListener);
+    if (FAILED(rc) || !g_pTInfoIEventListener)
+    {
+        PrintErrorInfo(argv[0], "FATAL: could not get type information for IEventListener", rc);
+        return EXIT_FAILURE;
+    }
+# endif /* WIN32 */
+#endif /* USE_ACTIVE_EVENT_LISTENER */
 
     /*
@@ -756 +1035 @@
     /* 1. Revision */
 
-    rc = vbox->vtbl->GetRevision(vbox, &revision);
-    if (NS_SUCCEEDED(rc))
+    rc = IVirtualBox_get_Revision(vbox, &revision);
+    if (SUCCEEDED(rc))
         printf("\tRevision: %u\n", revision);
     else
@@ -764 +1043 @@
     /* 2. Version */
 
-    rc = vbox->vtbl->GetVersion(vbox, &versionUtf16);
-    if (NS_SUCCEEDED(rc))
+    rc = IVirtualBox_get_Version(vbox, &versionUtf16);
+    if (SUCCEEDED(rc))
     {
         char *version = NULL;
@@ -771 +1050 @@
         printf("\tVersion: %s\n", version);
         g_pVBoxFuncs->pfnUtf8Free(version);
-        g_pVBoxFuncs->pfnComUnallocMem(versionUtf16);
+        g_pVBoxFuncs->pfnComUnallocString(versionUtf16);
     }
     else
@@ -778 +1057 @@
     /* 3. Home Folder */
 
-    rc = vbox->vtbl->GetHomeFolder(vbox, &homefolderUtf16);
-    if (NS_SUCCEEDED(rc))
+    rc = IVirtualBox_get_HomeFolder(vbox, &homefolderUtf16);
+    if (SUCCEEDED(rc))
     {
         char *homefolder = NULL;
@@ -785 +1064 @@
         printf("\tHomeFolder: %s\n", homefolder);
         g_pVBoxFuncs->pfnUtf8Free(homefolder);
-        g_pVBoxFuncs->pfnComUnallocMem(homefolderUtf16);
+        g_pVBoxFuncs->pfnComUnallocString(homefolderUtf16);
     }
     else
         PrintErrorInfo(argv[0], "GetHomeFolder() failed", rc);
 
-    listVMs(argv[0], vbox, session, queue);
-    session->vtbl->UnlockMachine(session);
+    listVMs(argv[0], vbox, session);
+    ISession_UnlockMachine(session);
 
     printf("----------------------------------------------------\n");
@@ -799 +1078 @@
      */
 
+#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)
     {
-        session->vtbl->nsisupports.Release((nsISupports *)session);
+        ISession_Release(session);
         session = NULL;
     }
     if (vbox)
     {
-        vbox->vtbl->nsisupports.Release((nsISupports *)vbox);
+        IVirtualBox_Release(vbox);
         vbox = NULL;
     }
     if (vboxclient)
     {
-        vboxclient->vtbl->nsisupports.Release((nsISupports *)vboxclient);
+        IVirtualBoxClient_Release(vboxclient);
         vboxclient = NULL;
     }
+
     g_pVBoxFuncs->pfnClientUninitialize();
     VBoxCGlueTerm();

trunk/src/VBox/Main/glue/glue-java.xsl

@@ -11 +11 @@
         VirtualBox.xidl.
 
-    Copyright (C) 2010-2013 Oracle Corporation
+    Copyright (C) 2010-2014 Oracle Corporation
 
     This file is part of VirtualBox Open Source Edition (OSE), as
@@ -47 +47 @@
   <xsl:param name="name" />
   <xsl:text>/*
- * Copyright (C) 2010-2013 Oracle Corporation
+ * Copyright (C) 2010-2014 Oracle Corporation
  *
  * This file is part of the VirtualBox SDK, as available from
@@ -2487 +2487 @@
         <xsl:variable name="extends" select="//interface[@name=$ifname]/@extends" />
         <xsl:choose>
-          <xsl:when test="($extends = '$unknown') or ($extends = '$dispatched') or ($extends = '$errorinfo')">
+          <xsl:when test="($extends = '$unknown') or ($extends = '$errorinfo')">
             <xsl:value-of select="concat('public class ', $ifname, ' extends IUnknown&#10;')" />
             <xsl:text>{&#10;&#10;</xsl:text>

trunk/src/VBox/Main/idl/apiwrap-server.xsl

@@ -6 +6 @@
         VirtualBox.xidl.
 
-     Copyright (C) 2010-2013 Oracle Corporation
+     Copyright (C) 2010-2014 Oracle Corporation
 
      This file is part of VirtualBox Open Source Edition (OSE), as
@@ -78 +78 @@
 
 /**
- * Copyright (C) 2011-2013 Oracle Corporation
+ * Copyright (C) 2010-2014 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -98 +98 @@
     <!-- now recurse to emit all base interfaces -->
     <xsl:variable name="extends" select="$iface/@extends"/>
-    <xsl:if test="$extends and not($extends='$unknown') and not($extends='$dispatched') and not($extends='$errorinfo')">
+    <xsl:if test="$extends and not($extends='$unknown') and not($extends='$errorinfo')">
         <xsl:call-template name="emitCOMInterfaces">
             <xsl:with-param name="iface" select="//interface[@name=$extends]"/>
@@ -165 +165 @@
 
     <xsl:choose>
-        <xsl:when test="$extends and not($extends='$unknown') and not($extends='$dispatched') and not($extends='$errorinfo')">
+        <xsl:when test="$extends and not($extends='$unknown') and not($extends='$errorinfo')">
             <xsl:variable name="newextends" select="//interface[@name=$extends]/@extends"/>
             <xsl:variable name="newiflist" select="concat($interfacelist, ', ', $extends)"/>
@@ -876 +876 @@
     <!-- first recurse to emit all base interfaces -->
     <xsl:variable name="extends" select="$iface/@extends"/>
-    <xsl:if test="$extends and not($extends='$unknown') and not($extends='$dispatched') and not($extends='$errorinfo')">
+    <xsl:if test="$extends and not($extends='$unknown') and not($extends='$errorinfo')">
         <xsl:call-template name="emitAttributes">
             <xsl:with-param name="iface" select="//interface[@name=$extends]"/>
@@ -1131 +1131 @@
     <!-- first recurse to emit all base interfaces -->
     <xsl:variable name="extends" select="$iface/@extends"/>
-    <xsl:if test="$extends and not($extends='$unknown') and not($extends='$dispatched') and not($extends='$errorinfo')">
+    <xsl:if test="$extends and not($extends='$unknown') and not($extends='$errorinfo')">
         <xsl:call-template name="emitMethods">
             <xsl:with-param name="iface" select="//interface[@name=$extends]"/>

trunk/src/VBox/Main/idl/midl.xsl

@@ -6 +6 @@
  *  from the generic interface definition expressed in XML.
 
-    Copyright (C) 2006-2012 Oracle Corporation
+    Copyright (C) 2006-2014 Oracle Corporation
 
     This file is part of VirtualBox Open Source Edition (OSE), as
@@ -243 +243 @@
   <xsl:choose>
     <xsl:when test="@extends='$unknown'">IDispatch</xsl:when>
-    <xsl:when test="@extends='$dispatched'">IDispatch</xsl:when>
     <xsl:when test="@extends='$errorinfo'">IErrorInfo</xsl:when>
     <xsl:otherwise><xsl:value-of select="@extends"/></xsl:otherwise>

trunk/src/VBox/Main/idl/xpidl.xsl

@@ -244 +244 @@
   <xsl:choose>
       <xsl:when test="@extends='$unknown'">nsISupports</xsl:when>
-      <xsl:when test="@extends='$dispatched'">nsISupports</xsl:when>
       <xsl:when test="@extends='$errorinfo'">nsIException</xsl:when>
       <xsl:otherwise><xsl:value-of select="@extends"/></xsl:otherwise>

trunk/src/VBox/Main/webservice/websrv-php.xsl

@@ -12 +12 @@
      Contributed by James Lucas (mjlucas at eng.uts.edu.au).
 
-    Copyright (C) 2008-2013 Oracle Corporation
+    Copyright (C) 2008-2014 Oracle Corporation
 
     This file is part of VirtualBox Open Source Edition (OSE), as
@@ -169 +169 @@
 </xsl:text>
    <xsl:choose>
-      <xsl:when test="($extends = '$unknown') or ($extends = '$dispatched') or ($extends = '$errorinfo')">
+      <xsl:when test="($extends = '$unknown') or ($extends = '$errorinfo')">
          <xsl:value-of select="concat('class ', $ifname, ' extends VBox_ManagedObject&#10;{&#10;')" />
       </xsl:when>
@@ -361 +361 @@
 
 /*
- * Copyright (C) 2008-2013 Oracle Corporation
+ * Copyright (C) 2008-2014 Oracle Corporation
  *
  * This file is part of a free software library; you can redistribute

trunk/src/VBox/Main/webservice/websrv-python.xsl

@@ -10 +10 @@
         web service API. Depends on WSDL file for actual SOAP bindings.
 
-    Copyright (C) 2008-2013 Oracle Corporation
+    Copyright (C) 2008-2014 Oracle Corporation
 
     This file is part of VirtualBox Open Source Edition (OSE), as
@@ -52 +52 @@
     <xsl:when test="$type='octet'">Octet</xsl:when>
     <xsl:when test="$type='$unknown'">IUnknown</xsl:when>
-    <xsl:when test="$type='$dispatched'">IUnknown</xsl:when>
     <xsl:otherwise><xsl:value-of select="$type" /></xsl:otherwise>
   </xsl:choose>
@@ -149 +148 @@
 
   <xsl:choose>
-    <xsl:when test="($base = '$unknown') or ($base = '$dispatched')">
+    <xsl:when test="($base = '$unknown')">
       <xsl:value-of select="'IUnknown'"/>
     </xsl:when>
@@ -469 +468 @@
 
 <xsl:template match="/">
-<xsl:text># Copyright (C) 2008-2011 Oracle Corporation
+<xsl:text># Copyright (C) 2008-2014 Oracle Corporation
 #
 # This file is part of a free software library; you can redistribute